From d38a74e7ea0bbb4a298a6bfb0f8419e8b28b1c44 Mon Sep 17 00:00:00 2001 From: Filip Harald Date: Mon, 9 Dec 2024 09:59:18 +0100 Subject: [PATCH] feat: verified contracts v0.1 (#233) also upgraded to aztec-packages 0.65.2 --- packages/backend-utils/src/parse-block.ts | 9 +- packages/types/src/aztec/l2TxEffect.ts | 8 +- packages/types/src/aztec/special.ts | 1 + packages/types/src/aztec/utils.ts | 27 +- services/event-cannon/src/cannon/index.ts | 2 + .../scenarios/simple-deploy-contract.ts | 58 +++ .../src/cannon/scenarios/utils/index.ts | 3 +- .../target/simple_logging-SimpleLogging.json | 436 +++++++++--------- .../simple_logging-SimpleLogging.json.bak | 2 +- ...ble_man.sql => 0000_dry_puppet_master.sql} | 2 +- .../migrations/meta/0000_snapshot.json | 4 +- .../migrations/meta/_journal.json | 4 +- services/explorer-api/src/constants.ts | 10 + .../database/controllers/l2contract/utils.ts | 2 + .../src/database/controllers/sign-of-life.ts | 18 +- .../src/database/schema/l2block/body.ts | 3 +- services/explorer-api/src/environment.ts | 21 +- .../src/event-handler/on-block/contracts.ts | 29 +- .../src/event-handler/on-block/index.ts | 19 + .../src/http-server/express-config.ts | 4 +- .../routes/controllers/inofficial.ts | 12 +- .../src/http-server/routes/index.ts | 2 +- .../routes/paths_and_validation.ts | 2 +- .../pages/contract-instance-details/index.tsx | 16 +- .../pages/contract-instance-details/util.ts | 10 +- .../src/pages/tx-effect-details/index.tsx | 88 ++-- .../src/pages/tx-effect-details/utils.ts | 6 +- .../src/pages/verified-contracts.tsx | 33 ++ services/explorer-ui/src/routeTree.gen.ts | 20 + services/explorer-ui/src/routes/__root.tsx | 4 + .../src/routes/verified-contracts.lazy.tsx | 6 + 31 files changed, 568 insertions(+), 293 deletions(-) create mode 100644 services/event-cannon/src/cannon/scenarios/simple-deploy-contract.ts rename services/explorer-api/migrations/{0000_worried_impossible_man.sql => 0000_dry_puppet_master.sql} (99%) create mode 100644 services/explorer-ui/src/pages/verified-contracts.tsx create mode 100644 services/explorer-ui/src/routes/verified-contracts.lazy.tsx diff --git a/packages/backend-utils/src/parse-block.ts b/packages/backend-utils/src/parse-block.ts index ab982477..197c8237 100644 --- a/packages/backend-utils/src/parse-block.ts +++ b/packages/backend-utils/src/parse-block.ts @@ -28,6 +28,13 @@ export const parseBlock = (b: L2Block): ChicmozL2Block => { return chicmozL2BlockSchema.parse({ hash: blockHash.toString(), height: b.number, - ...JSON.parse(JSON.stringify(blockWithTxEffectsHashesAdded)), + ...blockWithTxEffectsHashesAdded, + header: { + ...blockWithTxEffectsHashesAdded.header, + globalVariables: { + ...blockWithTxEffectsHashesAdded.header.globalVariables, + coinbase: blockWithTxEffectsHashesAdded.header.globalVariables.coinbase.toString(), + }, + }, }); }; diff --git a/packages/types/src/aztec/l2TxEffect.ts b/packages/types/src/aztec/l2TxEffect.ts index 28c47430..1f7d956e 100644 --- a/packages/types/src/aztec/l2TxEffect.ts +++ b/packages/types/src/aztec/l2TxEffect.ts @@ -1,18 +1,18 @@ import { z } from "zod"; import { hexStringSchema } from "../general.js"; -import { aztecAddressSchema, frNumberSchema, frSchema } from "./utils.js"; +import { aztecAddressSchema, bufferSchema, frNumberSchema, frSchema } from "./utils.js"; export const noteEncryptedLogEntrySchema = z.object({ - data: z.string(), + data: bufferSchema, }); export const encryptedLogEntrySchema = z.object({ - data: z.string(), + data: bufferSchema, maskedContractAddress: frSchema, }); export const unencryptedLogEntrySchema = z.object({ - data: z.string(), + data: bufferSchema, contractAddress: aztecAddressSchema, }); diff --git a/packages/types/src/aztec/special.ts b/packages/types/src/aztec/special.ts index 2eb98674..8100607a 100644 --- a/packages/types/src/aztec/special.ts +++ b/packages/types/src/aztec/special.ts @@ -10,6 +10,7 @@ export const chicmozL2ContractInstanceDeluxeSchema = z.object({ ...chicmozL2ContractInstanceDeployedEventSchema.shape, ...chicmozL2ContractClassRegisteredEventSchema.shape, blockHeight: chicmozL2BlockSchema.shape.height.optional(), + aztecScoutVerified: z.boolean().optional(), }); export type ChicmozL2ContractInstanceDeluxe = z.infer< diff --git a/packages/types/src/aztec/utils.ts b/packages/types/src/aztec/utils.ts index 6394de4c..37054eaa 100644 --- a/packages/types/src/aztec/utils.ts +++ b/packages/types/src/aztec/utils.ts @@ -10,11 +10,6 @@ export type AztecAddress = { toString(): string; }; -export type StringifiedAztecFr = { - type: "Fr"; - value: `0x${string}`; -}; - export type StringifiedAztecAddress = { type: "AztecAddress"; value: `0x${string}`; @@ -22,8 +17,6 @@ export type StringifiedAztecAddress = { const frToHexString = (val: unknown) => { if (!val) return val; - else if ((val as StringifiedAztecFr).value) - return (val as StringifiedAztecFr).value; else if ((val as AztecFr).toString) return (val as AztecFr).toString(); else return val; }; @@ -36,12 +29,28 @@ export const frSchema = z.preprocess( .regex(/^0x[0-9a-fA-F]+$/) ); -export const frPointSchema = z.object({ +type FrPoint = { + x: AztecFr; + y: AztecFr; + isInfinite: boolean; + kind: "point"; +}; + +const frPointToObj = (val: unknown) => { + if (!val) return val; + else if ((val as FrPoint).x) return val; + else return val; +}; + +export const frPointSchema = z.preprocess( + frPointToObj, +z.object({ x: frSchema, y: frSchema, isInfinite: z.boolean(), kind: z.enum(["point"]), -}); +}) +); export const frNumberSchema = z.preprocess((val) => { if (typeof val === "number") return val; diff --git a/services/event-cannon/src/cannon/index.ts b/services/event-cannon/src/cannon/index.ts index 0a19e54c..3bde38ac 100644 --- a/services/event-cannon/src/cannon/index.ts +++ b/services/event-cannon/src/cannon/index.ts @@ -1,6 +1,7 @@ import { logger } from "../logger.js"; import { setup } from "./pxe.js"; import { run as deployAndInteractFunctionsVote } from "./scenarios/deploy-and-interact-vote-contract.js"; +import { run as deploySimpleContract } from "./scenarios/simple-deploy-contract.js"; import { run as deploySimpleDefaultAccount } from "./scenarios/deploy-simple-default-account.js"; import { run as deployAndInteractTokenContract } from "./scenarios/deploy-and-interact-token-contract.js"; import { run as deploySimpleLog } from "./scenarios/deploy-and-run-simple-log.js"; @@ -25,6 +26,7 @@ export const start = async () => { deploySimpleDefaultAccount, deployAndInteractTokenContract, deployAndInteractFunctionsVote, + deploySimpleContract, deploySimpleLog, l1L2PublicMessaging, l1L2PrivateMessaging, diff --git a/services/event-cannon/src/cannon/scenarios/simple-deploy-contract.ts b/services/event-cannon/src/cannon/scenarios/simple-deploy-contract.ts new file mode 100644 index 00000000..0b795f74 --- /dev/null +++ b/services/event-cannon/src/cannon/scenarios/simple-deploy-contract.ts @@ -0,0 +1,58 @@ +import { DeploySentTx, waitForPXE } from "@aztec/aztec.js"; +import { logger } from "../../logger.js"; +import { getAztecNodeClient, getPxe, getWallets } from "../pxe.js"; +import { deployContract } from "./utils/index.js"; +import { EasyPrivateVotingContract } from "@aztec/noir-contracts.js"; +import { + ContractClassRegisteredEvent, + ContractInstanceDeployedEvent, +} from "@aztec/circuits.js"; +import { ProtocolContractAddress } from "@aztec/protocol-contracts"; + +export async function run() { + logger.info("===== SIMPLE DEPLOY CONTRACT ====="); + const pxe = getPxe(); + await waitForPXE(pxe); + const namedWallets = getWallets(); + + const deployerWallet = namedWallets.alice; + const votingAdmin = namedWallets.alice.getAddress(); + + const sentTx = EasyPrivateVotingContract.deploy( + deployerWallet, + votingAdmin + ).send(); + + await deployContract({ + contractLoggingName: "Voting Contract", + deployFn: (): DeploySentTx => sentTx, + }); + + const blockNumber = (await sentTx.getReceipt()).blockNumber; + const node = getAztecNodeClient(); + if (blockNumber && blockNumber > 0) { + const b = await node.getBlock(blockNumber); + if (b) { + const encryptedBlockLogs = b.body.txEffects.flatMap((txEffect) => + txEffect.encryptedLogs.unrollLogs() + ); + const contractInstances = + ContractInstanceDeployedEvent.fromLogs(encryptedBlockLogs); + + const contractClassLogs = b.body.txEffects.flatMap((txEffect) => + txEffect.contractClassLogs.unrollLogs() + ); + const contractClasses = ContractClassRegisteredEvent.fromLogs( + contractClassLogs, + ProtocolContractAddress.ContractClassRegisterer + ); + + logger.info( + JSON.stringify({ + contractClasses, + contractInstances, + }) + ); + } + } +} diff --git a/services/event-cannon/src/cannon/scenarios/utils/index.ts b/services/event-cannon/src/cannon/scenarios/utils/index.ts index 8868debf..ba33c5c6 100644 --- a/services/event-cannon/src/cannon/scenarios/utils/index.ts +++ b/services/event-cannon/src/cannon/scenarios/utils/index.ts @@ -98,8 +98,9 @@ export const deployContract = async ({ `📫 ${contractLoggingName} ${truncateHashString(hash)} (Deploying contract)` ); const deployedContract = await contractTx.deployed(); + const receipt = await contractTx.wait(); const addressString = deployedContract.address.toString(); - logger.info(`⛏ ${contractLoggingName} deployed at: ${addressString}`); + logger.info(`⛏ ${contractLoggingName} deployed at: ${addressString} block: ${receipt.blockNumber}`); if (broadcastWithWallet) { await broadcastFunctions({ wallet: broadcastWithWallet, diff --git a/services/event-cannon/src/contract-projects/SimpleLogging/target/simple_logging-SimpleLogging.json b/services/event-cannon/src/contract-projects/SimpleLogging/target/simple_logging-SimpleLogging.json index 6d08ecb9..9a25d51f 100644 --- a/services/event-cannon/src/contract-projects/SimpleLogging/target/simple_logging-SimpleLogging.json +++ b/services/event-cannon/src/contract-projects/SimpleLogging/target/simple_logging-SimpleLogging.json @@ -3,206 +3,6 @@ "noir_version": "0.38.0+c807678263164209f62fa5c9bf19f468cace1f98-x8664", "name": "SimpleLogging", "functions": [ - { - "name": "add_to_counter_public", - "is_unconstrained": true, - "custom_attributes": ["public", "internal"], - "abi": { - "error_types": { - "10176877060487216746": { - "error_kind": "string", - "string": "Function add_to_counter_public 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" - }, - "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" - } - }, - "parameters": [ - { - "name": "counter_id", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": null - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": ["add_to_counter_public"] - }, - { - "name": "public_dispatch", - "is_unconstrained": true, - "custom_attributes": ["public"], - "abi": { - "error_types": { - "10176877060487216746": { - "error_kind": "string", - "string": "Function add_to_counter_public can only be called internally" - }, - "13699457482007836410": { - "error_kind": "string", - "string": "Not initialized" - }, - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "16957488177269924912": { - "error_kind": "fmtstring", - "item_types": [], - "length": 16 - }, - "17618083556256589634": { - "error_kind": "string", - "string": "Initialization hash does not match" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "206160798890201757": { - "error_kind": "string", - "string": "Storage slot 0 not allowed. Storage slots must start from 1." - }, - "2233873454491509486": { - "error_kind": "string", - "string": "Initializer address is not the contract deployer" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - } - }, - "parameters": [ - { - "name": "selector", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": null - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": ["public_dispatch"] - }, - { - "name": "constructor", - "is_unconstrained": true, - "custom_attributes": ["public", "initializer"], - "abi": { - "error_types": { - "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" - }, - "2233873454491509486": { - "error_kind": "string", - "string": "Initializer address is not the contract deployer" - }, - "5019202896831570965": { - "error_kind": "string", - "string": "attempt to add with overflow" - } - }, - "parameters": [], - "return_type": null - }, - "bytecode": "JgAEAQInAASAQwABJgAEAwAmAgQAASYCBAACHxgAAgABgEMkAAAAOicCBIBDAAEmAgQAAjoNAAEAAiQAAAQALAgBAwAAAQIBJgIBAAQsDgQDLAgBAwAAAQIBJgIAAAUsDgUDLAgBAwAAAQIBJgIAAgYsDgYDHgIAAAM1OAAAAwAGAAcmAgEBCCMCAAAAogAHIgAAAJUsDAQBLAwFAiIAAACvLAwIASwMBgIiAAAAryMCAAAAwAABJgIEAAk7CQEJNTgCAAMAAQAJIwIAAADjAAkiAAAA1iwMBAYsDAUHIgAAAPAsDAgGLAwBByIAAADwIwIAAAEBAAYmAgQAAzsJAQMmAgQAAyYCBAEGLAgBCSYCBAIKABABCgEmAwQBCQAoCQIKHzwAAwAGAAoAKAkCCwA4CwMMLA0MChwMBAoLHAwACwksCAEKAAABAgEmAwQBCgAoCgILHzwABgADAAssCAELJgIEBAwAEAEMASYDBAELACgLAgwsDAwNLA4FDQAoDQINLA4FDQAoDQINLA4FDSwNCwwAKAwCDCwODAssDQsMACgMAgwsDgwLLA0LDAAoDAIMLA4MCywNCwwAKAwCDCwODAssCAEMAAABAgEsDgsMKgIAAAAAAAAAAAMAAAAAAAAAAAALLAgBDSYCBAUOABABDgEmAwQBDQAoDQIOLAwODywOBQ8AKA8CDywOBQ8AKA8CDywOBQ8AKA8CDywOCw8sDQ0OACgOAg4sDg4NLAgBDgAAAQIBLA4NDiwIAQsAAAECASwOAwssCAENAAABAgEsDgQNJgIADQ8mAgQRECwIABEsDAwSLAwOEywMCxQsDA0VLAwPFgAQABAAJAAABCksBAAAJgIEAg8sDAMBIgAAApMMOAEPCiMCAAADZwAKIgAAAqUsDQ0BCjgBBAYjAgAAAr8ABiYCBAAJOwkBCSYCBA8BLAgADywMDBAsDA4RLAwLEiwMDRMAEAABACQAAAWSLAQAACwNDAEsDQ4ELA0LBiwOAQwsDgQOLA4GCywOCA0AKAQCCQA4CQMKLA0KBiwNAQMCKAMCAywOAwEsDQQBAigBAgEsDgEECjgHBgEjAgAAAzwAASQAAAcLCjgCBQEeAgEAAwo4AgMEEjgBBAIjAgAAA10AAiQAAAcdHgIAAAEzAgABJSwIAQomAgQDEAAQARABJgMEAQoAKAoCECwMEBEsDgkRACgRAhEsDgURJgIEAhEMOAEREiMCAAADpwASJAAABy8AKAoCEQA4EQESLA0SECYCBBEKLAgAESwMDBIsDA4TLAwLFCwMDRUsDBAWABAACgAkAAAEKSwEAAAAOAEGCg44AQoQIwIAAAP3ABAkAAAHQSwMCgEiAAACkycABHgAgAQNAAAAgASAAyMAAAAEKIADKQEF96Hzr6Wt1MoAATsBAQIlJAAABAAsDQQGJgIBAAcKOAYHCCMCAAAETQAIJgIEAAk7CQEJLA0DBiYCBAMHCjgGBwgmAgQBBiMCAAAFBAAIIgAABG0sDQEHLA0CCCwNAwksDQQKLA0DCyYCBAMNDDgLDQ4jAgAABJgADiQAAAcvLQQAB4ADJwAEAASABCQAAAdTLQiABQAMACgMAg0AOA0LDiwOBQ4sDQwFACgFAgUsDgUMLA0IBQAoBQIFLA4FCAA4CQYFDjgJBQcjAgAABO8AByQAAAdBLA4MASwOCAIsDgUDLA4KBCIAAAWRJgIECAcsCAAILAwBCSwMAgosDAMLLAwEDAAQAAcAJAAABZIsBAAALA0BBywNAggsDQQJJgIEAAotBAAHgAMnAAQABIAEJAAAB1MtCIAFAAsAKAsCDAA4DAoNLA4FDSwNCwUAKAUCBSwOBQssDQgFACgFAgUsDgUILA4LASwOCAIsDgYDLA4JBCIAAAWRJSQAAAQAJgIEAwYmAgQAByYCBAEILAwHBSIAAAWvDDgFBgcjAgAABhwAByIAAAXBLA0BBSwNAwYsDQQHLA0CCCYCBAQJLAgBCiYCBAULABABCwEmAwQBCgAoCAILJgIEBAwAKAoCDT4PAAsADSwOBQEsDgoCLA4GAywOBwQsDQUBAigBAgEsDgEFJSwNAwcMOAUHCSMCAAAGMgAJIgAABussDQEHLA0CCSwNAwosDQQLLA0CDCYCBAQODDgFDg8jAgAABl0ADyQAAAcvACgMAg4AOA4FDywNDw0sDQEMJgIEAw8MOAUPECMCAAAGhgAQJAAABy8AKAwCDwA4DwUQLA0QDgA4DQ4MJgIEBA4MOAUODyMCAAAGsAAPJAAABy8tBAAJgAMnAAQABYAEJAAAB1MtCIAFAA0AKA0CDgA4DgUPLA4MDywOBwEsDg0CLA4KAywOCwQiAAAG6wA4BQgHDjgFBwkjAgAABwIACSQAAAdBLAwHBSIAAAWvKQEF9IABplnTJ0IAATsBAQIlKQEFHwBQEkAkIu4AATsBAQIlKQEF6J0J/qERLQ4AATsBAQIlKQEFRafKcRlB5BUAATsBAQIlLQGAA4AGCwCABgACgAcjAAAAB26AByIAAAd5LQCAA4AFIgAAB9gtAAABgAUBAAABgAQAAQEAgAOABIAJLQCAA4AKLQCABYALCwCACoAJgAwjAAAAB8yADC0BgAqACC0CgAiACwEAgAoAAoAKAQCACwACgAsiAAAHmycBBAABgAUiAAAH2CUtABjKGMo=", - "debug_symbols": "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", - "brillig_names": ["constructor"] - }, - { - "name": "sync_notes", - "is_unconstrained": true, - "custom_attributes": [], - "abi": { - "error_types": { - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - } - }, - "parameters": [], - "return_type": null - }, - "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==", - "debug_symbols": "nZLBCoMwEET/Zc8eTDRR8ytSJGqUQEgkxkIR/71RbLHFS3JZmGXe7GFnhV60y9hIPZgZWL2CMh130miv1i2B1kql5Nhc15DuA6HDP09c73J23DpgGU5A6B5Ynnp6kEoAo9X2SADhQH8W6M8D/STMj2/zK4LLk6gIIV8G0fSASAxEY6AiBiojoOz28RVFxQeiGf2FNi+f3EreKnEWa1h0d+mZe03ir3KTNZ3oFyv28l1652ftb2HsY330Gw==", - "brillig_names": ["sync_notes"] - }, - { - "name": "get_counter_value", - "is_unconstrained": true, - "custom_attributes": [], - "abi": { - "error_types": { - "16761564377371454734": { - "error_kind": "string", - "string": "Array index out of bounds" - }, - "17843811134343075018": { - "error_kind": "string", - "string": "Stack too deep" - }, - "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" - } - }, - "parameters": [ - { - "name": "counter_id", - "type": { - "kind": "field" - }, - "visibility": "private" - } - ], - "return_type": { - "abi_type": { - "kind": "field" - }, - "visibility": "public" - } - }, - "bytecode": "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", - "debug_symbols": "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", - "brillig_names": ["get_counter_value"] - }, { "name": "increace_counter_private", "is_unconstrained": false, @@ -1799,6 +1599,206 @@ ], "verification_key": "AAAAAAAAIAAAAAAAAAAADQAAAAAAAAAAAAAAAAAAAAUAjfaum2pGCa9bm1ND6yy44rz29I0SOGLX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\nj8a+zx02yPQI5Rd6FkK2tUtzEwRFJMUf6M6rFylnBQ==" }, + { + "name": "add_to_counter_public", + "is_unconstrained": true, + "custom_attributes": ["public", "internal"], + "abi": { + "error_types": { + "10176877060487216746": { + "error_kind": "string", + "string": "Function add_to_counter_public 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" + }, + "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" + } + }, + "parameters": [ + { + "name": "counter_id", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": null + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": ["add_to_counter_public"] + }, + { + "name": "public_dispatch", + "is_unconstrained": true, + "custom_attributes": ["public"], + "abi": { + "error_types": { + "10176877060487216746": { + "error_kind": "string", + "string": "Function add_to_counter_public can only be called internally" + }, + "13699457482007836410": { + "error_kind": "string", + "string": "Not initialized" + }, + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "16957488177269924912": { + "error_kind": "fmtstring", + "item_types": [], + "length": 16 + }, + "17618083556256589634": { + "error_kind": "string", + "string": "Initialization hash does not match" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "206160798890201757": { + "error_kind": "string", + "string": "Storage slot 0 not allowed. Storage slots must start from 1." + }, + "2233873454491509486": { + "error_kind": "string", + "string": "Initializer address is not the contract deployer" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + } + }, + "parameters": [ + { + "name": "selector", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": null + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": ["public_dispatch"] + }, + { + "name": "get_counter_value", + "is_unconstrained": true, + "custom_attributes": [], + "abi": { + "error_types": { + "16761564377371454734": { + "error_kind": "string", + "string": "Array index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + }, + "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" + } + }, + "parameters": [ + { + "name": "counter_id", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "field" + }, + "visibility": "public" + } + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": ["get_counter_value"] + }, + { + "name": "sync_notes", + "is_unconstrained": true, + "custom_attributes": [], + "abi": { + "error_types": { + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + }, + "parameters": [], + "return_type": null + }, + "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==", + "debug_symbols": "nZLBCoMwEET/Zc8eTDRR8ytSJGqUQEgkxkIR/71RbLHFS3JZmGXe7GFnhV60y9hIPZgZWL2CMh130miv1i2B1kql5Nhc15DuA6HDP09c73J23DpgGU5A6B5Ynnp6kEoAo9X2SADhQH8W6M8D/STMj2/zK4LLk6gIIV8G0fSASAxEY6AiBiojoOz28RVFxQeiGf2FNi+f3EreKnEWa1h0d+mZe03ir3KTNZ3oFyv28l1652ftb2HsY330Gw==", + "brillig_names": ["sync_notes"] + }, + { + "name": "constructor", + "is_unconstrained": true, + "custom_attributes": ["public", "initializer"], + "abi": { + "error_types": { + "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" + }, + "2233873454491509486": { + "error_kind": "string", + "string": "Initializer address is not the contract deployer" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + } + }, + "parameters": [], + "return_type": null + }, + "bytecode": "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", + "debug_symbols": "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", + "brillig_names": ["constructor"] + }, { "name": "increase_counter_public", "is_unconstrained": true, @@ -1834,7 +1834,7 @@ "return_type": null }, "bytecode": "JgAEAQInAASARAABJgAEAwAmAgQBAiYCBAADHxgAAwACgEMtCIBDAAEkAAAAQCcCBIBEAAEmAgQAAjoNAAEAAiQAAANzLAgBAwAAAQIBJgIBAAQsDgQDLAgBAwAAAQIBJgIAAAQsDgQDLAgBAwAAAQIBJgIAAgUsDgUDHgIAAAMeAgAABTI4AAMABQAGJgIBAQMjAgAAAJ8ABiQAAAOcLAgBAyYCBBkFABABBQEmAwQBAwAoAwIFJgIEGAYAOAYFBiwMBQcMOAcGCBYMCAgjAgAAAOQACCwOBAcAKAcCByIAAADFLA0DBQAoBQIFLA4FAywIAQUAAAECASwOAwUmAgJsAyYCAmQEJgICYwYmAgJyByYCAm4IJgICQwkmAgQACiYCAmILJgICcwwmAgJpDSYCAmUOJgICdQ8mAgQBECwIAREmAgQZEgAQARIBJgMEAREAKBECEiwMEhMsDgkTACgTAhMmAgJvFCwOFBMAKBMCEywODxMAKBMCEywOCBMAKBMCEyYCAnQVLA4VEwAoEwITLA4OEwAoEwITLA4HEwAoEwITJgICIBYsDhYTACgTAhMsDg0TACgTAhMsDggTACgTAhMsDgYTACgTAhMsDgcTACgTAhMsDg4TACgTAhMmAgJhFywOFxMAKBMCEywODBMAKBMCEywODhMAKBMCEywOBBMAKBMCEywOFhMAKBMCEyYCAnAYLA4YEwAoEwITLA4PEwAoEwITLA4LEwAoEwITLA4DEwAoEwITLA4NEwAoEwITLA4GEyYCBBgSLAwKAiIAAAJVDDgCEgEjAgAAAuQAASIAAAJnLA0FASYCBBgEBigEAgImAgQDBgA4BAYFLAgBAwAQAQUBJgMEAQMAKAMCBSwOBAUAKAUCBSwOBAUmAgQDBgA4AwYFACgBAgYtBAAGgAMtBAAFgAQtBAAEgAUkAAADrgAoAwIFLA0FBCYCBAIGADgFBgE2DQABAAQeAgAAASUsDQUBJgIEGBMMOAITGSMCAAAC/wAZJAAAA/QAKBECEwA4EwIZLA0ZChwMAAoTJgIEGBkMOAIZGiMCAAADKQAaJAAAA/QtBAABgAMnAAQAGYAEJAAABAYtCIAFAAoAKAoCGQA4GQIaLA4TGgA4AhABDjgCARMjAgAAA2YAEyQAAASMLA4KBSwMAQIiAAACVScABHgAgAQNAAAAgASAAyMAAAADm4ADKQEF96Hzr6Wt1MoAATsBAQIlKQEFvh4//z6k9voAATsBAQIlAQCAA4AFgActAIADgAgtAIAEgAkLAIAIgAeACiMAAAAD84AKLQGACIAGLQKABoAJAQCACAACgAgBAIAJAAKACSIAAAPCJSkBBeidCf6hES0OAAE7AQECJS0BgAOABgsAgAYAAoAHIwAAAAQhgAciAAAELC0AgAOABSIAAASLLQAAAYAFAQAAAYAEAAEBAIADgASACS0AgAOACi0AgAWACwsAgAqACYAMIwAAAAR/gAwtAYAKgAgtAoAIgAsBAIAKAAKACgEAgAsAAoALIgAABE4nAQQAAYAFIgAABIslKQEFRafKcRlB5BUAATsBAQIlLQAYyhjK", - "debug_symbols": "zZrbjuIwDIbfpde9iGMntudVVqMRhzJCQoA4rLRCvPumDC3MAIOoGvANapBdf/4Tt0maXTGuhtvPj+l8slgXb392xWwxGmymi3lq7fZlMVxNZ7Pp58f534Wrf6Ie7NfLwbxurjeD1aZ4g6iuLKr5OF2yc+kOk+msKt6i7t/LgrGDjzzuIx3iCD/uo9DBJz7uAw66OIUuTh26FYC6OHWJ5B/t2fLS2LnQGDsfWmNgvmJNKHK0JlQ+WSNdsRbA5t4CAb5ZH/ClB3zxjXHifyo+9qE+Qat+vKc+BGzwISjdwVeCeLRWCnqBT9Arfiqwb/iHEDF7iED5Q1wvTQztyEO5E0K4iSAa7/QbIjTG6fI0pL3/woloC0dM4bAtddiWOmJLHbGljtpSR9kSjnfeFk40hXNj0vcyHFOV5b2pyvLeljpoq7LQ1nPnxjz1ZTjBFE5wlnDC099Z7YoIkfQnToRnd1akFofxEqfPlYSeL1W+1nTRU+4AuTPA3Blg7gwIcweQzAFC7gxC7gyizx2AMwdgyB0gZg4guTOQ3Blo7lGkmeuAHeUO0MPTNLg2gNx5wWp6ozfG8XJLlvtYhfWJI6Zw+liF9YljS50bMw+iZhc9bWfH33F6/b7A5CzNpZmevcPBscURusRRUzjBljrR28JhUzhsSx22pY7A63AUL3GevdH76xqeFWzhmFJHHNnCUVM4trajxHtbOGwKB9EWjpjCIVvqkK2xE2xVVrClTrT1GGRnB2efmn8Hq+lgOKuOh04n2/no7Azq5t+y+nEcdblajKrxdlXVB1NPZ1LrtLzDMn19TWnW9QqiJai+1ycbD01XgoS6WU9qvKdkGxND4vgP", + "debug_symbols": "zZrbjuIwDIbfpde9iGMntudVVqMRhzJCQoA4rLRCvPumDC3MAIOoGvANapBdf/4Tt0maXTGuhtvPj+l8slgXb392xWwxGmymi3lq7fZlMVxNZ7Pp58f534Wrf6Ie7NfLwbxurjeD1aZ4g6iuLKr5OF2yc+kOk+msKt6i7t/LgrGDjzzuIx3iCD/uo9DBJz7uAw66OIUuTh26FYC6OHWJ5B/t2fLS2LnQGDsfWmNgvmJNKHK0JlQ+WSNdsRbA5t4CAb5ZH/ClB3zxjXHifyo+9qE+Qat+vKc+BGzwISjdwVeCeLRWCnqBT9Arfiqwb/iHEDF7iED5Q1wvTQztyEO5E0K4iSAa7/QbIjTG6fI0pL3/woloC0dM4bAtddiWOmJLHbGljtpSR9kSjnfeFk40hXNj0vcyHFOV5b2pyvLeljpoq7LQ1nPnxjz1ZTjBFE5wlnDC099Z7YoIkfQnToRnd1akFofxEqfPlYSeL1W+1nTRU+4AuTPA3Blg7gwIcweQzAFC7gxC7gyizx2AMwdgyB0gZg4guTOQ3Blo7lGkmeuAHeUO0MPTNLg2gNx5wWp6ozfG8XJLlvtYhfWJI6Zw+liF9YljS50bMw+iZhc9bWfH33F6/b7A5CzNpZmevcPBscURusRRUzjBljrR28JhUzhsSx22pY7A63AUL3GevdH76xqeFWzhmFJHHNnCUVM4trajxHtbOGwKB9EWjpjCIVvqkK2xE2xVVrClTrT1GGRnB2efmn8Hq+lgOKuOh04n2/no7Azq5t+y+nEcdblajKrxdlXVB1NPZ1LrtLzDMn19TWnW9QqiJai+1ycbD01XgoS6CQdbV6av/IkhcfwH", "brillig_names": ["increase_counter_public"] }, { @@ -1974,21 +1974,14 @@ { "name": "parameters", "type": { - "fields": [ - { - "name": "counter_id", - "type": { - "kind": "field" - } - } - ], + "fields": [], "kind": "struct", - "path": "SimpleLogging::add_to_counter_public_parameters" + "path": "SimpleLogging::constructor_parameters" } } ], "kind": "struct", - "path": "SimpleLogging::add_to_counter_public_abi" + "path": "SimpleLogging::constructor_abi" }, { "fields": [ @@ -2004,26 +1997,33 @@ } ], "kind": "struct", - "path": "SimpleLogging::increase_counter_public_parameters" + "path": "SimpleLogging::increace_counter_private_parameters" } } ], "kind": "struct", - "path": "SimpleLogging::increase_counter_public_abi" + "path": "SimpleLogging::increace_counter_private_abi" }, { "fields": [ { "name": "parameters", "type": { - "fields": [], + "fields": [ + { + "name": "counter_id", + "type": { + "kind": "field" + } + } + ], "kind": "struct", - "path": "SimpleLogging::constructor_parameters" + "path": "SimpleLogging::add_to_counter_public_parameters" } } ], "kind": "struct", - "path": "SimpleLogging::constructor_abi" + "path": "SimpleLogging::add_to_counter_public_abi" }, { "fields": [ @@ -2039,12 +2039,12 @@ } ], "kind": "struct", - "path": "SimpleLogging::increace_counter_private_parameters" + "path": "SimpleLogging::increase_counter_public_parameters" } } ], "kind": "struct", - "path": "SimpleLogging::increace_counter_private_abi" + "path": "SimpleLogging::increase_counter_public_abi" } ] } diff --git a/services/event-cannon/src/contract-projects/SimpleLogging/target/simple_logging-SimpleLogging.json.bak b/services/event-cannon/src/contract-projects/SimpleLogging/target/simple_logging-SimpleLogging.json.bak index 5bbbc4b4..716181cb 100644 --- a/services/event-cannon/src/contract-projects/SimpleLogging/target/simple_logging-SimpleLogging.json.bak +++ b/services/event-cannon/src/contract-projects/SimpleLogging/target/simple_logging-SimpleLogging.json.bak @@ -1 +1 @@ -{"noir_version":"0.38.0+c807678263164209f62fa5c9bf19f468cace1f98-x8664","name":"SimpleLogging","functions":[{"name":"add_to_counter_public","is_unconstrained":true,"custom_attributes":["public","internal"],"abi":{"parameters":[{"name":"counter_id","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."},"5019202896831570965":{"error_kind":"string","string":"attempt to add with overflow"},"10176877060487216746":{"error_kind":"string","string":"Function add_to_counter_public 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":"H4sIAAAAAAAA/+1cS29kxRWu636/3D325LFJpAgpUhZR7u1ujz2KEnWUoGSVSGHBBiF63LeRJWDAM7x2zYIFAsEGJCS2/AU2/BEEG34JAi6q4/789XfL3eNbxgtKsm73PafOq06dU3Wq2olbt8Q/6/TdCZyZf6bXa1mFtNJLQoaUKFPqG/+h47/vAbxWodId4lsl/ZN0Ou0I/SqUf9LxNGPax2hGoJ+2PJ1/rtb0WZeiDfx39CHr0/7xr+ffdQgvxnhGtHd6KOQ3XoWeH5E9amCPpOTp3OXxs7ZHNuN5OqtIp5Hb9KE66VGvUI8GwGYV64A2apAOzQp1aFWvw3hEciKf/o9/I/95/sbL/3v19OEi/8dicZ4/epSQXi0hv2q70GzvQPO3TPO/r7/00tnyLD9/+q2zR483aHcEbfu857RuLBfiYePxqjopN0iH3/tnIdcnYJMh2+SZ/JVFfn6bhs6RKg0hU5tghvuUfxbwT/3niFPlIu21K6edLYz2APSuMIXkFo723WYz2JB4I2wEMA7TdwDWJNgBwFoEOwRYm2B3AabCpbUafUcbFjQ/A7qM54gnhoQhwboAGxGsB7A7BOsD7IBgAyGP+cE+vK/QD8bbpB7k33VR/TJL3KZf1tymffbIdkMh60jALB0PhV1RpzIZ9oUMI9F/n+TDfk+a9kcBmXlZU/G4pJHjUWZ2wiWz6VLEkKfhPc7NuluPjerLOeJtoPkf/3noNuf7PvGzOe2AH27b9gi/L/B7Qj7jjfEE+zIfxrUYauPDMXvmv6fXalnKcR+bivucLzDuc77AuM/54q7Q1WC/Ahjni18DbNd8YTbcNV/guHDcx7HnuI854ZBg6Id3CVY2V56H96j/tnPF8B8Azbn/3AMaaFde+qIPOKfnFOqSEG7R1Jbz58h9xr8r9I6R++okD9uHc19TyKq2cR2yazOyHjZfG077XRPgiP/QP4v591Syxsc+V9mGZUB81Nvwh27T13Dba7FmvXV6/PB8/mL+7PnZ49xR4/0iT4S6wHOEw4opA/KCxfg0S/CNXoPw3/TPwuB/9EiDQH8MMqHkaTJgYFSBokffMSBa3+KdBUAehP/n8wUHEOTJ/BRvxoubUNeTxBJq2SQZAhzx3/FPnCTmD7XVuj9O+qLVV1H0GRdy/Il8B8e1AXxRL+c2F0jObfrdSODj2PAiGTeoXaLVEbRC88r6l80rLlYY/gf+ifNKLeJN70GANi6CY47l8Uma2lwwPzLf5FYHOOJ/7L/zHLTYN3tCOZfH82w5mS/nR/PFYno6PyD6DmzXi8D/QZ7lk+VyOcnn0+W95Y3zP1lMHpwcn07vZeP7x/m9K/njWUC8YlWacsEEZTK+aIsK4840ETZQizjj33Wb+SpGXO+SPGwfXsT1hKwjAcNCKsfMUBy9KVpqQ9shPso23QAf7N/9hc+1+AxEv6TkaXz4HfNRMm8TE9B/KpyDR9vGBON/UzFh2yKSKgz0yOYI43msik99wee20uJiY9Fm/pnu1sb8QslpfGwOol/yHNw1RmJ/Xufxvkc9jQ+/C8XibebgrnxsTNBuVRaYlb36pMegQj32CWdWsR7qMCDynnJs9Edx6F8U6VtijIr9yVfwvvjDwmJN9OW9reF/DzS/8Z9VgWZQwg9x6mIcmN+3/hm5MJbyeh15RS52LvmgDJs61OX1Ahb3OY6hXhx7sLiP48VNFeLNFkUe+Xuypst41pSP8PqqIfQwmCqWqjUOF1nVwY6KZzzWyK9oM/9Mr9cyFYOQF87DotVI9qJx/UXVTFQcCNlyKPrVS+RKBB+US921ahEfdQ8rcXqe4TvFpyFk5u8NoTuvgZ40Rn3nnwW992EucH/j3XPXj8N7nk9B83fEE33Fgy78mg8CZ/57er022SbXI/+u2xy7GOv6OyRP2VxS8dL6jgSM58aB4HMg+ChaHHsO4thkbLJa3C/zuQOAI/7QD6Q6/FH6h2LWoSu3l4oX6LeHZK84PpSN2SewqRzKeRkPyDkv4wE552U8IB8Q7DcAQ5twUznb7FSM34cQMxjPGsYWjlfGg30H1ykoY7MEnw+4Df8P4Gt87qX64xq36tpufnJ/kd5f5vMsy8aLNL/p2vL0aH58Oj/OsvvTLJ9mR1fxt5zRXK3heO5UtJb/bhcPGN/oNQj/z5B3/kI+1BD8Cry/BfCSkudPNMS7+uryu85qE7+22sQ33t3VpowG6wGsQXz6/jvaC2mZHA3C/6sncHFxBfpY/5Hg3yb+l+QW7zC+Mq2aeGf4xfhYod78FnWvMiejL5SdgUTa303UPe8Yl/DacehnvLZDXQqb/YvitLrggX3LLng8B/P73+C73N/8bFgybghTe4qhsBfXgSLVfKehOvttrX9HOqML1r/xPPKGao1Tk2cg5FHnKcV6QdWGVQ0Z1+xcQ0Dbc50AYyuf/+HYNQkW2v8qfomAhS5SjVz5vOw5Pf9qhIv3I1ScwDiC+C9AnHiX4kRLyKPuIvEFL/ZxhOHYcgzpC5qRL+df+OnwCvtxzcDwz2B9y3spdbldncWwDIiPevOFZqw9DQnWJ9rORa+NT4yXum/VELLyfavXArZUtgnZ8qq7TKEfKWBf5sN253OH2+qnbwvb/ox32Y7UXTbMFQ3gWzaX1I9Vdp1L6gcsfYIlAGsRTN1pUzmF8w3mFIuJGIMT4od64Hhz7RPvsu2SB94D/+B9+lVr1ar3yel4cXovHx+fpMfFNazFLnew1DrWbB35N6KpjYGNiaoZqzEw/E+Sy3JGWjfLM7JOwH61gP1i5A+0Xy1gv9iX7Hl8vvQGK/h9lly2V2itpPZGah3FayV1HqbWUTw+kX5ANuFYjDkI5RkAHPE/3zIH4fgWrb6Kos9U5SDM9ZyD1F4mtAYJ5Sy0mbqvzOsTjMG8tlO1XFWzV/dyQnza1+TTFnxCtNQ5LufBZgk+158N/wuR11Re55yPY9kmWE3wVXkd77R/TbE9Ugw9GZDM2PiuEtpA/cAudH+2RjD0qdD/GVLnGWaLXe8gVBFzeW0QqT6T3rY4F/rdSOiHtc5txrlQXESbqjsTofjTIz67xp/elnxixDkVYzjebxtjQvUoXO9bjCn4/ADdfSLbxUwAAA==","debug_symbols":"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","brillig_names":["add_to_counter_public"]},{"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."},"2233873454491509486":{"error_kind":"string","string":"Initializer address is not the contract deployer"},"5019202896831570965":{"error_kind":"string","string":"attempt to add with overflow"},"10176877060487216746":{"error_kind":"string","string":"Function add_to_counter_public can only be called internally"},"13699457482007836410":{"error_kind":"string","string":"Not initialized"},"16761564377371454734":{"error_kind":"string","string":"Array index out of bounds"},"16957488177269924912":{"error_kind":"fmtstring","length":16,"item_types":[]},"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":"constructor","is_unconstrained":true,"custom_attributes":["public","initializer"],"abi":{"parameters":[],"return_type":null,"error_types":{"2233873454491509486":{"error_kind":"string","string":"Initializer address is not the contract deployer"},"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":{"17843811134343075018":{"error_kind":"string","string":"Stack too deep"}}},"bytecode":"H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==","debug_symbols":"nZLBCoMwEET/Zc8eTDRR8ytSJGqUQEgkxkIR/71RbLHFS3JZmGXe7GFnhV60y9hIPZgZWL2CMh130miv1i2B1kql5Nhc15DuA6HDP09c73J23DpgGU5A6B5Ynnp6kEoAo9X2SADhQH8W6M8D/STMj2/zK4LLk6gIIV8G0fSASAxEY6AiBiojoOz28RVFxQeiGf2FNi+f3EreKnEWa1h0d+mZe03ir3KTNZ3oFyv28l1652ftb2HsY330Gw==","brillig_names":["sync_notes"]},{"name":"get_counter_value","is_unconstrained":true,"custom_attributes":[],"abi":{"parameters":[{"name":"counter_id","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_counter_value"]},{"name":"increace_counter_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":"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::header::Header","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":"txs_effects_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":"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":"start_side_effect_counter","type":{"kind":"integer","sign":"unsigned","width":32}}]},"visibility":"private"},{"name":"counter_id","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":4,"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","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","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":"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":"start_side_effect_counter","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"end_side_effect_counter","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"note_encrypted_logs_hashes","type":{"kind":"array","length":16,"type":{"kind":"struct","path":"aztec::protocol_types::abis::log_hash::NoteLogHash","fields":[{"name":"value","type":{"kind":"field"}},{"name":"counter","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"length","type":{"kind":"field"}},{"name":"note_hash_counter","type":{"kind":"integer","sign":"unsigned","width":32}}]}}},{"name":"encrypted_logs_hashes","type":{"kind":"array","length":4,"type":{"kind":"struct","path":"aztec::protocol_types::abis::log_hash::EncryptedLogHash","fields":[{"name":"value","type":{"kind":"field"}},{"name":"counter","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"length","type":{"kind":"field"}},{"name":"randomness","type":{"kind":"field"}}]}}},{"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":"field"}}]}}},{"name":"historical_header","type":{"kind":"struct","path":"aztec::protocol_types::header::Header","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":"txs_effects_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":"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"}}]}}]}}]}}]},"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":"7ZbbisIwEIbfJde9yMzkMPFVFpGqVQqlStWFRXz3TUrTgxuQreyC4E3pJH86X/4Zhl7Ftlhf9quy3h1OYvFxFdVhk5/LQ+2jqwBq107HvA7h6Zw3Z7EA42QminrrX62Ut0zsyqoQC+Nu2Q8xMnEnRjaDGMgk1KTBdWrSDh+oHTJ0aodO92rEFAkwm4jt5KAmSokBIwiA5bF4mQlQb1+Svui3L0lfzNuXpC/2aV8UoO7ECgwMN0XTZuA/z+CezgAkVRQTuSGDtalqsYo8jg1OeBJ9g6xtbBz0pbvnR/ni/JDid4iRSI56NIlvqc9gicdAKXzN0RgDw4dByxYGn4dxUWwV2Qcw4Az2dXJmop/nJr36BdT/XgAlEkUgqUBNgXy0bsqqKveryZ+VDA+V7BYACf3IRL5vMUVzDqk5h/ScQ+bXh3wEQZueRHqohh6NFj+IlzcffuZNma+rIrgadi/1Jprsw/PXMe7EMhybw6bYXpoiFGSoRXCVZKZkGOkBRHGmqWdrl5AyZJ/VZ/4G","brillig_names":["pack_arguments_oracle_wrapper","enqueue_public_function_call_internal"]},{"name":"increase_counter_public","is_unconstrained":true,"custom_attributes":["public"],"abi":{"parameters":[{"name":"counter_id","type":{"kind":"field"},"visibility":"private"}],"return_type":null,"error_types":{"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":"H4sIAAAAAAAA/9VZS4sjVRSu6lTl2ZnEZB49Lbh05eJWUt1JdiUyO9GVP6BMqqRhXnS3oiCYv+HGpXvBjYLgTsGFuHEnCv6RmRrOSb6cOkl3p+6dx4FwX+d+53kfueV7a/KpDETbU3gSKk01iiximQ0ldxmxzaj/qWxReQDjNYtGt4Rcm/hTE8ctxT6L+o9bhOnSP4zpAN80COeD5Rpf2lJQl9qYQzyn+fzXob6W4HMRT4f+NkNFf5ZV2Pmj8EcN/OFvKT1vM35MB8Jncp0mlmzqe+UcCl6CHW+yDaF9G0aaDSzn8PmvT/X0i0cfP50/WWTvLxbn2cWFL+zS9NfoJpjhDTCPJOZHnz98eJafZecPvjy7uCxh1xVsrh94um1SL+RD0vbHghIqTTWKQmHDO1QWe8HPVN+VfzKf7O5X0ew6+Y3y257T8yTyvfL6qXll/8j1Vnfjn6kv8FGfuuIfjmVDGWOsJrVDwEL+OtiI/Fjn+dj3HpV9BTMQOjS8sj3Yx/4tdHmX6j1Pz0XE1eIWKri79rKuMm/f/bi/Q+fWFhsSaptKdDrXzmWL+LGW+xbxV3fThhP8yYjxm270zxi/5QQ/XvmnLXLLDr4xjN9x45+V/w/dxHfln64b/WeMf8sN/gnj99z4Z4Xfd5M/Ee+jb3lrkveKgRPZ179XsPy20NXVvWIg9JH+4XODfTdUdO0rY3KPGSpyhoocjsNtMT+xYvdprul6e09dNayeRazmnljswztifkJtU4kmsabrHYt237KI1dgTi314V8xPqG0q0chout61aHfXIta+eahh1S1i7RtbmznHeXJPzE+obSrRaaTpes+i3YcWsWyu28Ai1r7rimN7JOYn1DaVaKLuAUcW7bZ5FnUsYtUsYtnc53hvcnwXnPJdCt/c+T9TocPXwiaf2vg+gnMHMI783wLmN1TvCR7fW78FaP/PXbwdse41sAffuF/OW5YZ+8J+T9EH5Vd9F0dZr9u7ofYuJPfgm75laVivMqboa3kP0d4zfcU23m9qyzIWjwUwFoqxcFn2SXG/+kXoc9249bxyrOR6duTrkdyfUFeMPcsv7hpvU331rePBo7PLTx5nj+fnXz29zBYfPvnMEyQ/aQygX25lwZY5NeBHusknHW2Ja1QcldfZZuWRmFDbVKL1Nnuf8LYdG0MYR/7vqCzS8ndhv3a8as8FUgfkR7tlGuPT4f0d89qA2xL8rvx5DP7S/In+Rv7vqUR/atuID/YUFCyd2DMr9PgD9JD+DIVOWgyRX8b8WOHH2Mhj4hjGhgJL21pQXl/w8/z6Fn68SiH/D1QWvvlP6IdbGdvd3YGNVziXsZxMjWGZnEecm5ICGEf+n6iN647LoIKe+SSN8nGapyfpYhHP04HA98B3HQfyP82ibJzn+ThL4/w0v1I+9zeW6/Ga8NUL/1Gd128T+cVYC8aC5ab8NrUDkINYrEco+H+jNv+1q8Mcnt9X5NeF/A29lT7Ma4lVU/rw8+ivVHcR12w6W5hZnqVRFI0WJrsqrpqfcM8tiH2NsagrtoWC/0+w+S+qy2seyiv4/t3B528pX2AofcFys0+LEeYu87Ps9rKsI491YAzPg4IOqY3+QizWIxT8/1CbY4L5xvP7ivymkL+ht9Inc7ej8HcU/iI+fzMelWi7zb9nmAsu1kl8kk7m6SSKZnGUxdHJVevkGeT1KLisKwAA","debug_symbols":"zZrdbuIwEIXfJde58NjjsYdXWa0qfkIVCQHiZ6UV4t3rtCTQBhU1ium5QRjN5HwJMwfb+FQsqtnx9aVeLzf7YvLnVKw28+mh3qzT6HQui9muXq3q15fbjwvTvJB9j99vp+tmuD9Md4diQqKmLKr1Ir0NxqQrLOtVVUxEz3/LgtyAHB6Q4wfkyICcMCAnDsjRn+dYMyCHBuQMqAM7oA7sT+ug7Acb49tgY30XTCHciWYX4yWanYZrtOM70ZFce+1Inj5FN/R+BPpo2+CE/1R6GYGeqXv28ujZk3ctPXnlB/TKJJdoZa89+jAqPZnP9I1CzK6guRXcfb9wvis6Fx8oxNAKRJUH35lz1Aant9dqtvaDhqBoLBSNg6JhKBoPRSNQNAGKJkLRKBINQ3kxQ3kxQ3kxQ3kxQ3kxQ3kxQ3kxQ3kxQ3kxQ3kx2Wc3Vbf0cY61j/PsyhHucILr44xZOnq7LPlYvJHVzAKjLnzuClBuAZtbwOUW4NwCPreA5BYIuQVyd7LL3cmcu5M5dydz7k7m3J3MuTuZc3fyGBNFbzqB+OAHVoXarVeV/tYrjTFTHBMnYuEoFI43WDj3/Yq53S5PxS7f44z6P0La1oeaS/tnT+2DdDiR+zgeC0ewcAIWTsTCUSgcMVg49Hs42l80y7P3ML9fw4vDwmEsHI+FI1g4WNtRErFwFAonGCwcwsLBcuWA5coBy5UDlisHLFcOQK58TsN/0109na2qy6nS5XE9vzlkevi/rb6cN93uNvNqcdxVzcnT66HTxr+scaW1Lt1m0yAUtSTV5qbN+9CUFH0zbMzFWk6xkhgSxxs=","brillig_names":["increase_counter_public"]},{"name":"compute_note_hash_and_optionally_a_nullifier","is_unconstrained":true,"custom_attributes":[],"abi":{"parameters":[{"name":"contract_address","type":{"kind":"struct","path":"aztec::protocol_types::address::aztec_address::AztecAddress","fields":[{"name":"inner","type":{"kind":"field"}}]},"visibility":"private"},{"name":"nonce","type":{"kind":"field"},"visibility":"private"},{"name":"storage_slot","type":{"kind":"field"},"visibility":"private"},{"name":"note_type_id","type":{"kind":"field"},"visibility":"private"},{"name":"compute_nullifier","type":{"kind":"boolean"},"visibility":"private"},{"name":"serialized_note","type":{"kind":"array","length":0,"type":{"kind":"field"}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"array","length":4,"type":{"kind":"field"}},"visibility":"public"},"error_types":{"16957488177269924912":{"error_kind":"fmtstring","length":16,"item_types":[]},"17843811134343075018":{"error_kind":"string","string":"Stack too deep"}}},"bytecode":"H4sIAAAAAAAA/9VZ23LaMBAV2AbshIRA0kIfM9O3dsYO5pI3ZnrJd7hJ+IJ+gB/60n51o0FrHy+bDMGrB3aGke2Vzh6dlSzJdMzOBi+/jrsOXdkz+0Z1Nq5M21mmiJX65Nk5EZ7dE+EZnAjPUJFnR+BpS5pvkdnNub7Zzcc9Jza2iQ7Ab94CYkH/uTJ2ZRf8ionJYqGzWvjrNH+MTdOU+c9jh9n3g78g/IEf/JR4fytrfOwLxQ1c+VDWWj5AG2tDd42DmHDJ1wXfd+YLwPeD+XAM/2Q+HPfEiXTrQV8Ux9Xad16ob33oW+eV0phaO3xGWifG6xjNKOcx48P5E58h1SlrPj3mC8EXM18EPtLflrdQj+e+D/W+wnM+JgOzP4bJTzlHrX2MqdAD/ovlku48J2HZjI0+1D0EPW+ZPj7WCtTHh/5Wn8kr/OnaWr80lQVMT9SINBtgfeaLwReWzTiJuw8hDmIRj4jV/+LuL13ZgzbUfiTE77H4Dd7CM9SIYwXCM6pv5+Rnd31mduPnD9U3++8pvU318l56Z+vhr6q9QOyH/zPhJ17w8wr/DPA11zTCP/ejz5Lwh37wq73YhRf8u0qfS8A3evpntC7S/McYFPvKS+6z7JA9C8ZPGFdfe5Yrxofrg+uj9Y0FriPBx+foWIgzFuJQHias/Ual38utxHVyJFcJ60IRK1bEOraPlI9r1n7j7tNWtsolrteK/R4qYg0UsY4dJ5SPG9Z+4+7TVrYU83Gj2G/NfJwrYvUVsTTnraZelEdprbO2cWXa0jhXPM9hTFrnI1b/N+P5Adoorsl3tKZ9NLXx/cDUU+xD9wMUfyjwId6J4GvzUfb512KR3RerLEu3y3xe5XPKuPJneCayv5lQX9pbkNafjBetU+ncPwNdrYXgmzJfBD7iKJ37Z574H6I/xh8JPjzTvCeXY9Mcazgf+XnVGL13CI136du8dM7U/OZ86Nyk+Anjqsznze+LqA/fqycC15Hg42tfIsRJhDiniMW/0aOGdo6QTmFZ+7VyuVrXf3DRuygyze/+hsWPWP2/7h77RmWbd/52VWTbebEtFsXTU/5YjBm+tS7o9B+RfvSPFR8AAA==","debug_symbols":"tdnNioMwFEDhd8nahanJvTe+yjAMtk2LIFqsHRiK7z6xzE+ZWZ+NEIknIn6re3fHvL+d3/rxNF1d+3J3w3Toln4ay+q+Vm4/98PQn9+eb7t6uwR57L9eunFbXpduXlzb7CqXx6NrQ12ePvVDdq2ktfq3Ub83qv5sjLa+Vi4oFTYqnKBwrKmwp8I7KtxQ4UCFIxWm5EVKXqTkRUqeUPKEkieUPKHkCSVPKHlCyRNKnlDyhJKnlDyl5CklTyl5SslTSp5S8pSSp5Q8peQZJc8oeUbJM0qeUfKMkmeUPKPkGSXPKHmJkpcoeYmSlyh5iZKXKHmJkpcoeYmSlyh5vq6xssfKO6zcYOWAlSNWFqysWNmwMmbQYwY9ZtBjBj1m0GMGPWNwLav3bu67/ZC/BhKn23h4mk8sH5f8Z1RxmadDPt7mvA0tfucV21dtQhXC418uC19ezzdaDikHfQI=","brillig_names":["compute_note_hash_and_optionally_a_nullifier"]}],"outputs":{"structs":{"functions":[{"kind":"struct","path":"SimpleLogging::add_to_counter_public_abi","fields":[{"name":"parameters","type":{"kind":"struct","path":"SimpleLogging::add_to_counter_public_parameters","fields":[{"name":"counter_id","type":{"kind":"field"}}]}}]},{"kind":"struct","path":"SimpleLogging::increase_counter_public_abi","fields":[{"name":"parameters","type":{"kind":"struct","path":"SimpleLogging::increase_counter_public_parameters","fields":[{"name":"counter_id","type":{"kind":"field"}}]}}]},{"kind":"struct","path":"SimpleLogging::constructor_abi","fields":[{"name":"parameters","type":{"kind":"struct","path":"SimpleLogging::constructor_parameters","fields":[]}}]},{"kind":"struct","path":"SimpleLogging::increace_counter_private_abi","fields":[{"name":"parameters","type":{"kind":"struct","path":"SimpleLogging::increace_counter_private_parameters","fields":[{"name":"counter_id","type":{"kind":"field"}}]}}]}]},"globals":{"storage":[{"kind":"struct","fields":[{"name":"contract_name","value":{"kind":"string","value":"SimpleLogging"}},{"name":"fields","value":{"kind":"struct","fields":[{"name":"counters","value":{"kind":"struct","fields":[{"name":"slot","value":{"kind":"integer","sign":false,"value":"0000000000000000000000000000000000000000000000000000000000000001"}}]}}]}}]}]}},"file_map":{"33":{"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 if message_size == N {\n Poseidon2::hash_internal(input, N, false)\n } else {\n Poseidon2::hash_internal(input, message_size, true)\n }\n }\n\n pub(crate) 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","path":"std/hash/poseidon2.nr"},"57":{"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","path":"std/option.nr"},"58":{"source":"pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n","path":"std/panic.nr"},"69":{"source":"use dep::aztec::macros::aztec;\n\n#[aztec]\ncontract SimpleLogging {\n use dep::aztec::prelude::{Map, PublicMutable};\n use dep::aztec::{\n //keys::getters::get_public_keys,\n macros::{storage::storage, functions::{public, initializer, private, internal}},\n };\n #[storage]\n struct Storage {\n counters: Map, Context>,\n }\n\n #[public]\n #[initializer]\n fn constructor() {\n }\n\n #[private]\n fn increace_counter_private(counter_id: Field) {\n //let msg_sender_npk_m_hash = get_public_keys(context.msg_sender()).npk_m.hash();\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 SimpleLogging::at(context.this_address()).add_to_counter_public(counter_id).enqueue(\n &mut context,\n );\n }\n\n #[public]\n #[internal]\n fn add_to_counter_public(counter_id: Field) {\n let new_counter_value = storage.counters.at(counter_id).read() + 1;\n storage.counters.at(counter_id).write(new_counter_value);\n }\n\n #[public]\n fn increase_counter_public(counter_id: Field) {\n context.emit_unencrypted_log(/*message=*/\"Counter increased public\");\n SimpleLogging::at(context.this_address()).add_to_counter_public(counter_id);\n }\n unconstrained fn get_counter_value(counter_id: Field) -> pub Field {\n storage.counters.at(counter_id).read()\n }\n}\n","path":"/home/filip/c/chicmoz/services/event-cannon/src/contract-projects/SimpleLogging/src/main.nr"},"109":{"source":"use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{\n storage::map::derive_storage_slot_in_map,\n traits::{Deserialize, Serialize, ToField},\n};\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: Serialize + Deserialize,\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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/state_vars/map.nr"},"122":{"source":"use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::{Deserialize, Serialize};\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: Serialize + Deserialize,\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: Serialize + Deserialize,\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: Deserialize,\n{\n pub unconstrained fn read(self) -> T {\n self.context.storage_read(self.storage_slot)\n }\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr"},"126":{"source":"use crate::{\n context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\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 arguments,\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 header::get_header_at,\n key_validation_request::get_key_validation_request,\n logs::{emit_encrypted_event_log, emit_encrypted_note_log},\n returns::pack_returns,\n },\n};\nuse dep::protocol_types::{\n abis::{\n call_context::CallContext,\n function_selector::FunctionSelector,\n log_hash::{EncryptedLogHash, LogHash, NoteLogHash},\n max_block_number::MaxBlockNumber,\n note_hash::NoteHash,\n nullifier::Nullifier,\n private_call_request::PrivateCallRequest,\n private_circuit_public_inputs::PrivateCircuitPublicInputs,\n public_call_request::PublicCallRequest,\n read_request::ReadRequest,\n side_effect::Counted,\n validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n },\n address::{AztecAddress, EthAddress},\n constants::{\n MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENCRYPTED_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_ENCRYPTED_LOGS_PER_CALL, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n MAX_NOTE_HASHES_PER_CALL, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, PUBLIC_DISPATCH_SELECTOR,\n },\n header::Header,\n messaging::l2_to_l1_message::L2ToL1Message,\n traits::Empty,\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: Header,\n\n pub note_encrypted_logs_hashes: BoundedVec,\n pub encrypted_logs_hashes: 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 note_encrypted_logs_hashes: BoundedVec::new(),\n encrypted_logs_hashes: 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 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\n pub fn push_nullifier(&mut self, nullifier: Field) {\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 self.nullifiers.push(\n Nullifier {\n value: nullifier,\n note_hash: nullified_note_hash,\n counter: self.next_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_header(self) -> Header {\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_header_at(self, block_number: u32) -> Header {\n get_header_at(block_number, self)\n }\n\n pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n pack_returns(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 note_encrypted_logs_hashes: self.note_encrypted_logs_hashes.storage(),\n encrypted_logs_hashes: self.encrypted_logs_hashes.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 let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n assert(request.pk_m.hash() == pk_m_hash);\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 // NB: A randomness value of 0 signals that the kernels should not mask the contract address\n // used in siloing later on e.g. 'handshaking' contract w/ known address.\n pub fn emit_raw_event_log_with_masked_address(\n &mut self,\n randomness: Field,\n log: [u8; M],\n log_hash: Field,\n ) {\n let counter = self.next_counter();\n let contract_address = self.this_address();\n let len = log.len() as Field + 4;\n let side_effect = EncryptedLogHash { value: log_hash, counter, length: len, randomness };\n self.encrypted_logs_hashes.push(side_effect);\n\n emit_encrypted_event_log(contract_address, randomness, log, counter);\n }\n\n pub fn emit_raw_note_log(\n &mut self,\n note_hash_counter: u32,\n log: [u8; M],\n log_hash: Field,\n ) {\n let counter = self.next_counter();\n let len = log.len() as Field + 4;\n let side_effect = NoteLogHash { value: log_hash, counter, length: len, note_hash_counter };\n self.note_encrypted_logs_hashes.push(side_effect);\n\n emit_encrypted_note_log(note_hash_counter, log, counter);\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 ) -> PackedReturns {\n let args_hash = hash_args_array(args);\n arguments::pack_arguments_array(args);\n self.call_private_function_with_packed_args(\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 ) -> PackedReturns {\n let args_hash = hash_args_array(args);\n arguments::pack_arguments_array(args);\n self.call_private_function_with_packed_args(\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 ) -> PackedReturns {\n self.call_private_function_with_packed_args(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 ) -> PackedReturns {\n self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n }\n\n pub fn call_private_function_with_packed_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) -> PackedReturns {\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 // The oracle simulates the private call and returns the value of the side effects counter after execution of\n // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n // 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 PackedReturns::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 arguments::pack_arguments_array(args);\n self.call_public_function_with_packed_args(\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 arguments::pack_arguments_array(args);\n self.call_public_function_with_packed_args(\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_packed_args(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_packed_args(contract_address, function_selector, 0, true)\n }\n\n pub fn call_public_function_with_packed_args(\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 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n // WARNING: This is insecure and should be temporary!\n // The oracle repacks 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 = enqueue_public_function_call_internal(\n contract_address,\n function_selector,\n args_hash,\n counter,\n is_static_call,\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 arguments::pack_arguments_array(args);\n self.set_public_teardown_function_with_packed_args(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn set_public_teardown_function_with_packed_args(\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 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n // WARNING: This is insecure and should be temporary!\n // The oracle repacks 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 = set_public_teardown_function_call_internal(\n contract_address,\n function_selector,\n args_hash,\n counter,\n is_static_call,\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: Header::empty(),\n note_encrypted_logs_hashes: BoundedVec::new(),\n encrypted_logs_hashes: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/context/private_context.nr"},"127":{"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::arguments::pack_arguments;\n\npub trait CallInterface {\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\npub struct PrivateCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args_hash: Field,\n pub args: [Field],\n pub return_type: T,\n pub is_static: bool,\n}\n\nimpl PrivateCallInterface {\n pub fn call(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n pack_arguments(self.args);\n let returns = context.call_private_function_with_packed_args(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n );\n let unpacked: T = returns.unpack_into();\n unpacked\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n pack_arguments(self.args);\n let returns = context.call_private_function_with_packed_args(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns.unpack_into()\n }\n}\n\nimpl CallInterface for PrivateVoidCallInterface {}\n\npub struct PrivateVoidCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args_hash: Field,\n pub args: [Field],\n pub return_type: (),\n pub is_static: bool,\n}\n\nimpl PrivateVoidCallInterface {\n pub fn call(self, context: &mut PrivateContext) {\n pack_arguments(self.args);\n context\n .call_private_function_with_packed_args(\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 pack_arguments(self.args);\n context\n .call_private_function_with_packed_args(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateStaticCallInterface {}\n\npub struct PrivateStaticCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args_hash: Field,\n pub args: [Field],\n pub return_type: T,\n pub is_static: bool,\n}\n\nimpl PrivateStaticCallInterface {\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n pack_arguments(self.args);\n let returns = context.call_private_function_with_packed_args(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns.unpack_into()\n }\n}\n\nimpl CallInterface for PrivateStaticVoidCallInterface {}\n\npub struct PrivateStaticVoidCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args_hash: Field,\n pub args: [Field],\n pub return_type: (),\n pub is_static: bool,\n}\n\nimpl PrivateStaticVoidCallInterface {\n pub fn view(self, context: &mut PrivateContext) {\n pack_arguments(self.args);\n context\n .call_private_function_with_packed_args(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PublicCallInterface {}\n\npub struct PublicCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args: [Field],\n pub gas_opts: GasOpts,\n pub return_type: T,\n pub is_static: bool,\n}\n\nimpl PublicCallInterface {\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicVoidCallInterface {}\n\npub struct PublicVoidCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args: [Field],\n pub return_type: (),\n pub is_static: bool,\n pub gas_opts: GasOpts,\n}\n\nimpl PublicVoidCallInterface {\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticCallInterface {}\n\npub struct PublicStaticCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args: [Field],\n pub return_type: T,\n pub is_static: bool,\n pub gas_opts: GasOpts,\n}\n\nimpl PublicStaticCallInterface {\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticVoidCallInterface {}\n\npub struct PublicStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (),\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticVoidCallInterface {\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr"},"128":{"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::Deserialize};\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: Deserialize,\n {\n T::deserialize(self.raw_storage_read(storage_slot))\n }\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/context/unconstrained_context.nr"},"134":{"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::{Deserialize, Empty, Serialize};\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_unencrypted_log(_self: &mut Self, log: T)\n where\n T: Serialize,\n {\n // AVM opcodes are constrained by the AVM itself\n unsafe { emit_unencrypted_log(Serialize::serialize(log).as_slice()) };\n }\n\n pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n // 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 // 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 // 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 // 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 let success = call(gas_for_call(gas_opts), contract_address, args);\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 let success = call_static(gas_for_call(gas_opts), contract_address, args);\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 // 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 // AVM opcodes are constrained by the AVM itself\n unsafe { emit_nullifier(nullifier) };\n }\n\n pub fn this_address(_self: Self) -> AztecAddress {\n // AVM opcodes are constrained by the AVM itself\n unsafe {\n address()\n }\n }\n pub fn msg_sender(_self: Self) -> AztecAddress {\n // 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 // 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 // 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 // AVM opcodes are constrained by the AVM itself\n unsafe {\n chain_id()\n }\n }\n pub fn version(_self: Self) -> Field {\n // AVM opcodes are constrained by the AVM itself\n unsafe {\n version()\n }\n }\n pub fn block_number(_self: Self) -> Field {\n // AVM opcodes are constrained by the AVM itself\n unsafe {\n block_number()\n }\n }\n pub fn timestamp(_self: Self) -> u64 {\n // 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 // 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 // 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 // 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 // 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 // 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 // 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: Deserialize,\n {\n T::deserialize(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 // 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: Serialize,\n {\n self.raw_storage_write(storage_slot, value.serialize());\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}\n// TODO(9396): Remove.\nunconstrained fn portal() -> EthAddress {\n portal_opcode()\n}\n// TODO(9396): Remove.\n//unconstrained fn function_selector() -> u32 {\n// function_selector_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_unencrypted_log(message: [Field]) {\n emit_unencrypted_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]) -> bool {\n call_opcode(gas, address, args)\n}\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\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\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(avmOpcodePortal)]\nunconstrained fn portal_opcode() -> EthAddress {}\n\n// TODO(9396): Remove.\n//#[oracle(avmOpcodeFunctionSelector)]\n//unconstrained fn function_selector_opcode() -> u32 {}\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#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_unencrypted_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) -> bool {}\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) -> 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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/context/public_context.nr"},"136":{"source":"use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse 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,\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_unencrypted_log_hash(\n contract_address: AztecAddress,\n log: [u8; N],\n) -> Field {\n let mut hash_bytes = [0; N + 36];\n // Address is converted to 32 bytes in ts\n let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n for i in 0..32 {\n hash_bytes[i] = address_bytes[i];\n }\n let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n for i in 0..4 {\n hash_bytes[32 + i] = len_bytes[i];\n }\n for i in 0..N {\n hash_bytes[36 + i] = log[i];\n }\n\n sha256_to_field(hash_bytes)\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\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n let contract_address = AztecAddress::from_field(\n 0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n );\n let log = [\n 0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n 0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n 0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n 0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n 0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n ];\n let serialized_log = arr_to_be_bytes_arr(log);\n let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n let contract_address = AztecAddress::from_field(\n 0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n );\n let log = AztecAddress::from_field(\n 0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n );\n let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n let contract_address = AztecAddress::from_field(\n 0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n );\n let log = \"dummy\";\n let serialized_log = str_to_be_bytes_arr(log);\n let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n let contract_address = AztecAddress::from_field(\n 0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n );\n let log = \"Hello this is a string\";\n let serialized_log = str_to_be_bytes_arr(log);\n let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/hash.nr"},"150":{"source":"/// Notifies the simulator that `args` will later be used at some point during execution, referenced by their hash. This\n/// allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of arguments.\npub fn pack_arguments(args: [Field]) {\n // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n // unpacking however the caller must check that the returned value is indeed the preimage.\n unsafe { pack_arguments_oracle_wrapper(args) };\n}\n\n/// Same as `pack_arguments`, but using arrays instead of slices.\npub fn pack_arguments_array(args: [Field; N]) {\n // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n // unpacking however the caller must check that the returned value is indeed the preimage.\n unsafe { pack_arguments_array_oracle_wrapper(args) };\n}\n\nunconstrained fn pack_arguments_oracle_wrapper(args: [Field]) {\n let _ = pack_arguments_oracle(args);\n}\n\nunconstrained fn pack_arguments_array_oracle_wrapper(args: [Field; N]) {\n let _ = pack_arguments_array_oracle(args);\n}\n\n#[oracle(packArguments)]\nunconstrained fn pack_arguments_oracle(_args: [Field]) -> Field {}\n\n#[oracle(packArgumentsArray)]\nunconstrained fn pack_arguments_array_oracle(_args: [Field; N]) -> Field {}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/arguments.nr"},"151":{"source":"use dep::protocol_types::{\n address::AztecAddress, constants::CONTRACT_INSTANCE_LENGTH, contract_class_id::ContractClassId,\n contract_instance::ContractInstance,\n};\n\n// NOTE: this is for use in private only\n#[oracle(getContractInstance)]\nunconstrained fn get_contract_instance_oracle(\n _address: AztecAddress,\n) -> [Field; CONTRACT_INSTANCE_LENGTH] {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(\n address: AztecAddress,\n) -> [Field; CONTRACT_INSTANCE_LENGTH] {\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 let instance =\n unsafe { ContractInstance::deserialize(get_contract_instance_internal(address)) };\n // The to_address function combines all values in the instance object to produce an address, so by checking that we\n // get the expected address we validate the entire struct.\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 let (member, exists) = 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 let (member, exists) = 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 let (member, exists) = get_contract_instance_initialization_hash_internal_avm(address);\n if exists {\n Option::some(member)\n } else {\n Option::none()\n }\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr"},"158":{"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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/execution.nr"},"160":{"source":"use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n utils::arr_copy_slice,\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 serialized_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n unsafe {\n notify_created_note_oracle_wrapper(\n storage_slot,\n note_type_id,\n serialized_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 // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper(\n storage_slot: Field,\n note_type_id: Field,\n serialized_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n let _ = notify_created_note_oracle(\n storage_slot,\n note_type_id,\n serialized_note,\n note_hash,\n counter,\n );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle(\n _storage_slot: Field,\n _note_type_id: Field,\n _serialized_note: [Field; N],\n _note_hash: Field,\n _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n nullifier: Field,\n note_hash: Field,\n counter: u32,\n) {\n let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n _nullifier: Field,\n _note_hash: Field,\n _counter: u32,\n) -> 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 _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by_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 mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n let return_size = placeholder_fields.len() as u32;\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 return_size,\n placeholder_fields,\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 mut placeholder_opt_notes: [Option; S], // TODO: Remove it and use `limit` to initialize the note array.\n placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option; S]\nwhere\n Note: NoteInterface,\n{\n sync_notes_oracle_wrapper();\n let fields = 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 placeholder_fields,\n );\n let num_notes = fields[0] as u32;\n let contract_address = AztecAddress::from_field(fields[1]);\n for i in 0..placeholder_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 let nonce = fields[read_offset];\n let note_hash_counter = fields[read_offset + 1] as u32;\n let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n let mut note = Note::deserialize_content(serialized_note);\n note.set_header(header);\n placeholder_opt_notes[i] = Option::some(note);\n };\n }\n placeholder_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) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag as an array of bytes, ready to be included in a\n/// log.\npub unconstrained fn get_app_tag_bytes_as_sender(\n sender: AztecAddress,\n recipient: AztecAddress,\n) -> [u8; 32] {\n let tag = get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient);\n tag.to_be_bytes()\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 ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n sender: AztecAddress,\n recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_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 // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe 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\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n unsafe {\n sync_notes_oracle_wrapper();\n }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/notes.nr"},"161":{"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 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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr"},"162":{"source":"use dep::protocol_types::{address::AztecAddress, traits::Deserialize};\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: Deserialize,\n{\n T::deserialize(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;\n\n use crate::test::mocks::mock_struct::MockStruct;\n use std::test::OracleMock;\n\n global address = AztecAddress::from_field(29);\n global slot = 7;\n global block_number = 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.serialize());\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.serialize());\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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/storage.nr"},"177":{"source":"use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress,\n constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator,\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\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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/initializer.nr"},"183":{"source":"use crate::{\n abis::function_selector::FunctionSelector,\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{\n AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n MAX_FIELD_VALUE,\n },\n contract_class_id::ContractClassId,\n hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n merkle_tree::membership::MembershipWitness,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n traits::{Deserialize, Empty, FromField, Serialize, ToField},\n utils,\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 ec::{pow, sqrt},\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\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\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 secrect 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_private_function(\n function_selector: FunctionSelector,\n function_vk_hash: Field,\n function_leaf_membership_witness: MembershipWitness,\n contract_class_artifact_hash: Field,\n contract_class_public_bytecode_commitment: Field,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let private_functions_root = private_functions_root_from_siblings(\n function_selector,\n function_vk_hash,\n function_leaf_membership_witness.leaf_index,\n function_leaf_membership_witness.sibling_path,\n );\n\n let contract_class_id = ContractClassId::compute(\n contract_class_artifact_hash,\n private_functions_root,\n contract_class_public_bytecode_commitment,\n );\n\n // Compute contract address using the preimage which includes the class_id.\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_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 pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n Self { inner: result }\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 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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr"},"194":{"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.to_integer()]\n }\n}\n\nimpl Deserialize for U128 {\n fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n U128::from_integer(fields[0])\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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr"},"212":{"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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr"},"227":{"source":"use crate::meta::{derive_deserialize, 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 U128::from_integer(0)\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.to_integer()\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 U128::from_integer(value)\n }\n}\n\n// docs:start:serialize\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#[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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr"},"229":{"source":"use crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n function_selector::FunctionSelector,\n log_hash::{LogHash, ScopedEncryptedLogHash, ScopedLogHash},\n note_hash::ScopedNoteHash,\n nullifier::ScopedNullifier,\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,\n },\n merkle_tree::root::root_from_sibling_path,\n messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n traits::{is_empty, ToField},\n utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::field::field_from_bytes;\n\npub fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = std::hash::sha256(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\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n // Hashing tx hash with note index in tx is guaranteed to be unique\n poseidon2_hash_with_separator(\n [tx_hash, note_index_in_tx as Field],\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n let inputs = [nonce, note_hash];\n poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), unique_note_hash],\n GENERATOR_INDEX__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, tx_hash: Field, note_index_in_tx: u32) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\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 silo_encrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n // We assume contract address has already been masked\n if log_hash.contract_address.is_zero() {\n 0\n } else {\n accumulate_sha256(\n [log_hash.contract_address.to_field(), log_hash.log_hash.value],\n )\n }\n}\n\npub fn mask_encrypted_log_hash(scoped_log: ScopedEncryptedLogHash) -> AztecAddress {\n if scoped_log.contract_address.is_zero() {\n AztecAddress::from_field(0)\n } else if (scoped_log.log_hash.randomness == 0) {\n scoped_log.contract_address\n } else {\n AztecAddress::from_field(poseidon2_hash_with_separator(\n [scoped_log.contract_address.to_field(), scoped_log.log_hash.randomness],\n 0,\n ))\n }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n if log_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\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: BoundedVec = BoundedVec::new();\n\n let inputs =\n [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n for i in 0..inputs.len() {\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.push(item_bytes[j]);\n }\n }\n\n sha256_to_field(bytes.storage())\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\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash(logs: [LogHash; N]) -> Field {\n // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n let mut hash_input_flattened = [0; N * 32];\n for offset in 0..N {\n // TODO: This is not checking that the decomposition is smaller than P\n let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n for byte_index in 0..32 {\n hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n }\n }\n // Ideally we would push to a slice then hash, but there is no sha_slice\n // Hardcode to 256 bytes for now\n let mut hash = sha256_to_field(hash_input_flattened);\n // Not having a 0 value hash for empty logs causes issues with empty txs\n // used for padding. Returning early is currently unsupported.\n // We always provide sorted logs here, so 0 being empty means all are empty.\n if is_empty(logs[0]) {\n hash = 0;\n }\n hash\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 // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n let in_len = N + 1;\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = std::hash::poseidon2::Poseidon2::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\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 two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = std::hash::poseidon2::Poseidon2::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 // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n let mut in_len = N / 31;\n let mut has_padding = false;\n if N % 31 != 0 {\n in_len += 1;\n has_padding = true;\n }\n\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\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 sponge.absorb(field_from_bytes(current_field, false));\n current_field = [0; 31];\n }\n }\n if has_padding {\n sponge.absorb(field_from_bytes(current_field, false));\n }\n\n 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 = std::hash::sha256(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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr"},"262":{"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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/abis/function_selector.nr"},"311":{"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};\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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr"}}} \ No newline at end of file +{"noir_version":"0.38.0+c807678263164209f62fa5c9bf19f468cace1f98-x8664","name":"SimpleLogging","functions":[{"name":"increace_counter_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":"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::header::Header","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":"txs_effects_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":"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":"start_side_effect_counter","type":{"kind":"integer","sign":"unsigned","width":32}}]},"visibility":"private"},{"name":"counter_id","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":4,"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","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","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":"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":"start_side_effect_counter","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"end_side_effect_counter","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"note_encrypted_logs_hashes","type":{"kind":"array","length":16,"type":{"kind":"struct","path":"aztec::protocol_types::abis::log_hash::NoteLogHash","fields":[{"name":"value","type":{"kind":"field"}},{"name":"counter","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"length","type":{"kind":"field"}},{"name":"note_hash_counter","type":{"kind":"integer","sign":"unsigned","width":32}}]}}},{"name":"encrypted_logs_hashes","type":{"kind":"array","length":4,"type":{"kind":"struct","path":"aztec::protocol_types::abis::log_hash::EncryptedLogHash","fields":[{"name":"value","type":{"kind":"field"}},{"name":"counter","type":{"kind":"integer","sign":"unsigned","width":32}},{"name":"length","type":{"kind":"field"}},{"name":"randomness","type":{"kind":"field"}}]}}},{"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":"field"}}]}}},{"name":"historical_header","type":{"kind":"struct","path":"aztec::protocol_types::header::Header","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":"txs_effects_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":"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"}}]}}]}}]}}]},"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":"7ZbbisIwEIbfJde9yMzkMPFVFpGqVQqlStWFRXz3TUrTgxuQreyC4E3pJH86X/4Zhl7Ftlhf9quy3h1OYvFxFdVhk5/LQ+2jqwBq107HvA7h6Zw3Z7EA42QminrrX62Ut0zsyqoQC+Nu2Q8xMnEnRjaDGMgk1KTBdWrSDh+oHTJ0aodO92rEFAkwm4jt5KAmSokBIwiA5bF4mQlQb1+Svui3L0lfzNuXpC/2aV8UoO7ECgwMN0XTZuA/z+CezgAkVRQTuSGDtalqsYo8jg1OeBJ9g6xtbBz0pbvnR/ni/JDid4iRSI56NIlvqc9gicdAKXzN0RgDw4dByxYGn4dxUWwV2Qcw4Az2dXJmop/nJr36BdT/XgAlEkUgqUBNgXy0bsqqKveryZ+VDA+V7BYACf3IRL5vMUVzDqk5h/ScQ+bXh3wEQZueRHqohh6NFj+IlzcffuZNma+rIrgadi/1Jprsw/PXMe7EMhybw6bYXpoiFGSoRXCVZKZkGOkBRHGmqWdrl5AyZJ/VZ/4G","brillig_names":["pack_arguments_oracle_wrapper","enqueue_public_function_call_internal"]},{"name":"add_to_counter_public","is_unconstrained":true,"custom_attributes":["public","internal"],"abi":{"parameters":[{"name":"counter_id","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."},"5019202896831570965":{"error_kind":"string","string":"attempt to add with overflow"},"10176877060487216746":{"error_kind":"string","string":"Function add_to_counter_public 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":["add_to_counter_public"]},{"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."},"2233873454491509486":{"error_kind":"string","string":"Initializer address is not the contract deployer"},"5019202896831570965":{"error_kind":"string","string":"attempt to add with overflow"},"10176877060487216746":{"error_kind":"string","string":"Function add_to_counter_public can only be called internally"},"13699457482007836410":{"error_kind":"string","string":"Not initialized"},"16761564377371454734":{"error_kind":"string","string":"Array index out of bounds"},"16957488177269924912":{"error_kind":"fmtstring","length":16,"item_types":[]},"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":"get_counter_value","is_unconstrained":true,"custom_attributes":[],"abi":{"parameters":[{"name":"counter_id","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_counter_value"]},{"name":"sync_notes","is_unconstrained":true,"custom_attributes":[],"abi":{"parameters":[],"return_type":null,"error_types":{"17843811134343075018":{"error_kind":"string","string":"Stack too deep"}}},"bytecode":"H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==","debug_symbols":"nZLBCoMwEET/Zc8eTDRR8ytSJGqUQEgkxkIR/71RbLHFS3JZmGXe7GFnhV60y9hIPZgZWL2CMh130miv1i2B1kql5Nhc15DuA6HDP09c73J23DpgGU5A6B5Ynnp6kEoAo9X2SADhQH8W6M8D/STMj2/zK4LLk6gIIV8G0fSASAxEY6AiBiojoOz28RVFxQeiGf2FNi+f3EreKnEWa1h0d+mZe03ir3KTNZ3oFyv28l1652ftb2HsY330Gw==","brillig_names":["sync_notes"]},{"name":"constructor","is_unconstrained":true,"custom_attributes":["public","initializer"],"abi":{"parameters":[],"return_type":null,"error_types":{"2233873454491509486":{"error_kind":"string","string":"Initializer address is not the contract deployer"},"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":"increase_counter_public","is_unconstrained":true,"custom_attributes":["public"],"abi":{"parameters":[{"name":"counter_id","type":{"kind":"field"},"visibility":"private"}],"return_type":null,"error_types":{"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":"H4sIAAAAAAAA/9VZS4sjVRSu6lTl2ZnEZB49Lbh05eJWUt1JdiUyO9GVP6BMqqRhXnS3oiCYv+HGpXvBjYLgTsGFuHEnCv6RmRrOSb6cOkl3p+6dx4FwX+d+53kfueV7a/KpDETbU3gSKk01iiximQ0ldxmxzaj/qWxReQDjNYtGt4Rcm/hTE8ctxT6L+o9bhOnSP4zpAN80COeD5Rpf2lJQl9qYQzyn+fzXob6W4HMRT4f+NkNFf5ZV2Pmj8EcN/OFvKT1vM35MB8Jncp0mlmzqe+UcCl6CHW+yDaF9G0aaDSzn8PmvT/X0i0cfP50/WWTvLxbn2cWFL+zS9NfoJpjhDTCPJOZHnz98eJafZecPvjy7uCxh1xVsrh94um1SL+RD0vbHghIqTTWKQmHDO1QWe8HPVN+VfzKf7O5X0ew6+Y3y257T8yTyvfL6qXll/8j1Vnfjn6kv8FGfuuIfjmVDGWOsJrVDwEL+OtiI/Fjn+dj3HpV9BTMQOjS8sj3Yx/4tdHmX6j1Pz0XE1eIWKri79rKuMm/f/bi/Q+fWFhsSaptKdDrXzmWL+LGW+xbxV3fThhP8yYjxm270zxi/5QQ/XvmnLXLLDr4xjN9x45+V/w/dxHfln64b/WeMf8sN/gnj99z4Z4Xfd5M/Ee+jb3lrkveKgRPZ179XsPy20NXVvWIg9JH+4XODfTdUdO0rY3KPGSpyhoocjsNtMT+xYvdprul6e09dNayeRazmnljswztifkJtU4kmsabrHYt237KI1dgTi314V8xPqG0q0chout61aHfXIta+eahh1S1i7RtbmznHeXJPzE+obSrRaaTpes+i3YcWsWyu28Ai1r7rimN7JOYn1DaVaKLuAUcW7bZ5FnUsYtUsYtnc53hvcnwXnPJdCt/c+T9TocPXwiaf2vg+gnMHMI783wLmN1TvCR7fW78FaP/PXbwdse41sAffuF/OW5YZ+8J+T9EH5Vd9F0dZr9u7ofYuJPfgm75laVivMqboa3kP0d4zfcU23m9qyzIWjwUwFoqxcFn2SXG/+kXoc9249bxyrOR6duTrkdyfUFeMPcsv7hpvU331rePBo7PLTx5nj+fnXz29zBYfPvnMEyQ/aQygX25lwZY5NeBHusknHW2Ja1QcldfZZuWRmFDbVKL1Nnuf8LYdG0MYR/7vqCzS8ndhv3a8as8FUgfkR7tlGuPT4f0d89qA2xL8rvx5DP7S/In+Rv7vqUR/atuID/YUFCyd2DMr9PgD9JD+DIVOWgyRX8b8WOHH2Mhj4hjGhgJL21pQXl/w8/z6Fn68SiH/D1QWvvlP6IdbGdvd3YGNVziXsZxMjWGZnEecm5ICGEf+n6iN647LoIKe+SSN8nGapyfpYhHP04HA98B3HQfyP82ibJzn+ThL4/w0v1I+9zeW6/Ga8NUL/1Gd128T+cVYC8aC5ab8NrUDkINYrEco+H+jNv+1q8Mcnt9X5NeF/A29lT7Ma4lVU/rw8+ivVHcR12w6W5hZnqVRFI0WJrsqrpqfcM8tiH2NsagrtoWC/0+w+S+qy2seyiv4/t3B528pX2AofcFys0+LEeYu87Ps9rKsI491YAzPg4IOqY3+QizWIxT8/1CbY4L5xvP7ivymkL+ht9Inc7ej8HcU/iI+fzMelWi7zb9nmAsu1kl8kk7m6SSKZnGUxdHJVevkGeT1KLisKwAA","debug_symbols":"zZrdbuIwEIXfJde58Njjn+FVVquKn1BFQoACrLRCvPs6lAS6iRo1itNzgzCayfkSZg628TXbFKvL+1u53x5O2eLXNdsd1stzedjH0fWWZ6uq3O3K97fXjzNVv5C+x5+Oy309PJ2X1TlbkBOVZ8V+E996peIVtuWuyBZObr/zjMyIHB6RY0fkuBE5fkROGJEj38/RakQOjcgZUQd6RB3o79ZB3g1WyjbBSts2mLzviWYTwiOajfhntOGe6ECmuXYgS5+ia3o7AX3QTXDEn5XeTUDP1D57N/TsyZqGnqzwAL0wuUe0sJUOvZ+UntRn+lohJFeQ1Aqm3y+MbYvOhAGF4BuBIG7gOzOGmuD49lnNWn/QEBSNhqIxUDQMRWOhaBwUjYeiCVA0gkTDUF7MUF7MUF7MUF7MUF7MUF7MUF7MUF7MUF7MUF5Meu6mapc+xrB0ceauHMctjjddnClLR16XJR+LN9KSWGDShU+vAKUW0KkFTGoBTi1gUwu41AI+tUDqTjapO5lTdzKn7mRO3cmcupM5dSdz6k6eYqJoVSsQBn5gxVGz9Squu/VKU8wUp8QJWDgChWMVFk6/XzE32+Wx2N3XOJP+jxC39aHm0nbuqb13LU7gLo7FwnFYOB4LJ2DhCBSOU1g49HM40l00u7n3ML9ewzuDhcNYOBYLx2HhYG1HuYCFI1A4XmHhEBYOlit7LFf2WK7ssVzZY7myB3LlWxz+WVblcrUrHqdKt5f9+uWQ6fnvsfjvvOmxOqyLzaUq6pOnz0OntX9pZXKtTbzNukEoSE4i9U2r+1DlFGw9pHusyrXSkSFy/AM=","brillig_names":["increase_counter_public"]},{"name":"compute_note_hash_and_optionally_a_nullifier","is_unconstrained":true,"custom_attributes":[],"abi":{"parameters":[{"name":"contract_address","type":{"kind":"struct","path":"aztec::protocol_types::address::aztec_address::AztecAddress","fields":[{"name":"inner","type":{"kind":"field"}}]},"visibility":"private"},{"name":"nonce","type":{"kind":"field"},"visibility":"private"},{"name":"storage_slot","type":{"kind":"field"},"visibility":"private"},{"name":"note_type_id","type":{"kind":"field"},"visibility":"private"},{"name":"compute_nullifier","type":{"kind":"boolean"},"visibility":"private"},{"name":"serialized_note","type":{"kind":"array","length":0,"type":{"kind":"field"}},"visibility":"private"}],"return_type":{"abi_type":{"kind":"array","length":4,"type":{"kind":"field"}},"visibility":"public"},"error_types":{"16957488177269924912":{"error_kind":"fmtstring","length":16,"item_types":[]},"17843811134343075018":{"error_kind":"string","string":"Stack too deep"}}},"bytecode":"H4sIAAAAAAAA/9VZ23LaMBAV2AbshIRA0kIfM9O3dsYO5pI3ZnrJd7hJ+IJ+gB/60n51o0FrHy+bDMGrB3aGke2Vzh6dlSzJdMzOBi+/jrsOXdkz+0Z1Nq5M21mmiJX65Nk5EZ7dE+EZnAjPUJFnR+BpS5pvkdnNub7Zzcc9Jza2iQ7Ab94CYkH/uTJ2ZRf8ionJYqGzWvjrNH+MTdOU+c9jh9n3g78g/IEf/JR4fytrfOwLxQ1c+VDWWj5AG2tDd42DmHDJ1wXfd+YLwPeD+XAM/2Q+HPfEiXTrQV8Ux9Xad16ob33oW+eV0phaO3xGWifG6xjNKOcx48P5E58h1SlrPj3mC8EXM18EPtLflrdQj+e+D/W+wnM+JgOzP4bJTzlHrX2MqdAD/ovlku48J2HZjI0+1D0EPW+ZPj7WCtTHh/5Wn8kr/OnaWr80lQVMT9SINBtgfeaLwReWzTiJuw8hDmIRj4jV/+LuL13ZgzbUfiTE77H4Dd7CM9SIYwXCM6pv5+Rnd31mduPnD9U3++8pvU318l56Z+vhr6q9QOyH/zPhJ17w8wr/DPA11zTCP/ejz5Lwh37wq73YhRf8u0qfS8A3evpntC7S/McYFPvKS+6z7JA9C8ZPGFdfe5Yrxofrg+uj9Y0FriPBx+foWIgzFuJQHias/Ual38utxHVyJFcJ60IRK1bEOraPlI9r1n7j7tNWtsolrteK/R4qYg0UsY4dJ5SPG9Z+4+7TVrYU83Gj2G/NfJwrYvUVsTTnraZelEdprbO2cWXa0jhXPM9hTFrnI1b/N+P5Adoorsl3tKZ9NLXx/cDUU+xD9wMUfyjwId6J4GvzUfb512KR3RerLEu3y3xe5XPKuPJneCayv5lQX9pbkNafjBetU+ncPwNdrYXgmzJfBD7iKJ37Z574H6I/xh8JPjzTvCeXY9Mcazgf+XnVGL13CI136du8dM7U/OZ86Nyk+Anjqsznze+LqA/fqycC15Hg42tfIsRJhDiniMW/0aOGdo6QTmFZ+7VyuVrXf3DRuygyze/+hsWPWP2/7h77RmWbd/52VWTbebEtFsXTU/5YjBm+tS7o9B+RfvSPFR8AAA==","debug_symbols":"tdnNioMwFEDhd8nahanJvTe+yjAMtk2LIFqsHRiK7z6xzE+ZWZ+NEIknIn6re3fHvL+d3/rxNF1d+3J3w3Toln4ay+q+Vm4/98PQn9+eb7t6uwR57L9eunFbXpduXlzb7CqXx6NrQ12ePvVDdq2ktfq3Ub83qv5sjLa+Vi4oFTYqnKBwrKmwp8I7KtxQ4UCFIxWm5EVKXqTkRUqeUPKEkieUPKHkCSVPKHlCyRNKnlDyhJKnlDyl5CklTyl5SslTSp5S8pSSp5Q8peQZJc8oeUbJM0qeUfKMkmeUPKPkGSXPKHmJkpcoeYmSlyh5iZKXKHmJkpcoeYmSlyh5vq6xssfKO6zcYOWAlSNWFqysWNmwMmbQYwY9ZtBjBj1m0GMGPWNwLav3bu67/ZC/BhKn23h4mk8sH5f8Z1RxmadDPt7mvA0tfucV21dtQhXC418uC19ezzdaDikHfQI=","brillig_names":["compute_note_hash_and_optionally_a_nullifier"]}],"outputs":{"structs":{"functions":[{"kind":"struct","path":"SimpleLogging::constructor_abi","fields":[{"name":"parameters","type":{"kind":"struct","path":"SimpleLogging::constructor_parameters","fields":[]}}]},{"kind":"struct","path":"SimpleLogging::increace_counter_private_abi","fields":[{"name":"parameters","type":{"kind":"struct","path":"SimpleLogging::increace_counter_private_parameters","fields":[{"name":"counter_id","type":{"kind":"field"}}]}}]},{"kind":"struct","path":"SimpleLogging::add_to_counter_public_abi","fields":[{"name":"parameters","type":{"kind":"struct","path":"SimpleLogging::add_to_counter_public_parameters","fields":[{"name":"counter_id","type":{"kind":"field"}}]}}]},{"kind":"struct","path":"SimpleLogging::increase_counter_public_abi","fields":[{"name":"parameters","type":{"kind":"struct","path":"SimpleLogging::increase_counter_public_parameters","fields":[{"name":"counter_id","type":{"kind":"field"}}]}}]}]},"globals":{"storage":[{"kind":"struct","fields":[{"name":"contract_name","value":{"kind":"string","value":"SimpleLogging"}},{"name":"fields","value":{"kind":"struct","fields":[{"name":"counters","value":{"kind":"struct","fields":[{"name":"slot","value":{"kind":"integer","sign":false,"value":"0000000000000000000000000000000000000000000000000000000000000001"}}]}}]}}]}]}},"file_map":{"33":{"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 if message_size == N {\n Poseidon2::hash_internal(input, N, false)\n } else {\n Poseidon2::hash_internal(input, message_size, true)\n }\n }\n\n pub(crate) 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","path":"std/hash/poseidon2.nr"},"57":{"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","path":"std/option.nr"},"58":{"source":"pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n","path":"std/panic.nr"},"69":{"source":"use dep::aztec::macros::aztec;\n\n#[aztec]\ncontract SimpleLogging {\n use dep::aztec::prelude::{Map, PublicMutable};\n use dep::aztec::{\n //keys::getters::get_public_keys,\n macros::{storage::storage, functions::{public, initializer, private, internal}},\n };\n #[storage]\n struct Storage {\n counters: Map, Context>,\n }\n\n #[public]\n #[initializer]\n fn constructor() {\n }\n\n #[private]\n fn increace_counter_private(counter_id: Field) {\n //let msg_sender_npk_m_hash = get_public_keys(context.msg_sender()).npk_m.hash();\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 SimpleLogging::at(context.this_address()).add_to_counter_public(counter_id).enqueue(\n &mut context,\n );\n }\n\n #[public]\n #[internal]\n fn add_to_counter_public(counter_id: Field) {\n let new_counter_value = storage.counters.at(counter_id).read() + 1;\n storage.counters.at(counter_id).write(new_counter_value);\n }\n\n #[public]\n fn increase_counter_public(counter_id: Field) {\n context.emit_unencrypted_log(/*message=*/\"Counter increased public\");\n SimpleLogging::at(context.this_address()).add_to_counter_public(counter_id);\n }\n unconstrained fn get_counter_value(counter_id: Field) -> pub Field {\n storage.counters.at(counter_id).read()\n }\n}\n","path":"/home/filip/c/chicmoz/services/event-cannon/src/contract-projects/SimpleLogging/src/main.nr"},"109":{"source":"use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{\n storage::map::derive_storage_slot_in_map,\n traits::{Deserialize, Serialize, ToField},\n};\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: Serialize + Deserialize,\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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/state_vars/map.nr"},"122":{"source":"use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::{Deserialize, Serialize};\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: Serialize + Deserialize,\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: Serialize + Deserialize,\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: Deserialize,\n{\n pub unconstrained fn read(self) -> T {\n self.context.storage_read(self.storage_slot)\n }\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr"},"126":{"source":"use crate::{\n context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\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 arguments,\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 header::get_header_at,\n key_validation_request::get_key_validation_request,\n logs::{emit_encrypted_event_log, emit_encrypted_note_log},\n returns::pack_returns,\n },\n};\nuse dep::protocol_types::{\n abis::{\n call_context::CallContext,\n function_selector::FunctionSelector,\n log_hash::{EncryptedLogHash, LogHash, NoteLogHash},\n max_block_number::MaxBlockNumber,\n note_hash::NoteHash,\n nullifier::Nullifier,\n private_call_request::PrivateCallRequest,\n private_circuit_public_inputs::PrivateCircuitPublicInputs,\n public_call_request::PublicCallRequest,\n read_request::ReadRequest,\n side_effect::Counted,\n validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n },\n address::{AztecAddress, EthAddress},\n constants::{\n MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENCRYPTED_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_ENCRYPTED_LOGS_PER_CALL, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n MAX_NOTE_HASHES_PER_CALL, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, PUBLIC_DISPATCH_SELECTOR,\n },\n header::Header,\n messaging::l2_to_l1_message::L2ToL1Message,\n traits::Empty,\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: Header,\n\n pub note_encrypted_logs_hashes: BoundedVec,\n pub encrypted_logs_hashes: 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 note_encrypted_logs_hashes: BoundedVec::new(),\n encrypted_logs_hashes: 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 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\n pub fn push_nullifier(&mut self, nullifier: Field) {\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 self.nullifiers.push(\n Nullifier {\n value: nullifier,\n note_hash: nullified_note_hash,\n counter: self.next_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_header(self) -> Header {\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_header_at(self, block_number: u32) -> Header {\n get_header_at(block_number, self)\n }\n\n pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n pack_returns(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 note_encrypted_logs_hashes: self.note_encrypted_logs_hashes.storage(),\n encrypted_logs_hashes: self.encrypted_logs_hashes.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 let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n assert(request.pk_m.hash() == pk_m_hash);\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 // NB: A randomness value of 0 signals that the kernels should not mask the contract address\n // used in siloing later on e.g. 'handshaking' contract w/ known address.\n pub fn emit_raw_event_log_with_masked_address(\n &mut self,\n randomness: Field,\n log: [u8; M],\n log_hash: Field,\n ) {\n let counter = self.next_counter();\n let contract_address = self.this_address();\n let len = log.len() as Field + 4;\n let side_effect = EncryptedLogHash { value: log_hash, counter, length: len, randomness };\n self.encrypted_logs_hashes.push(side_effect);\n\n emit_encrypted_event_log(contract_address, randomness, log, counter);\n }\n\n pub fn emit_raw_note_log(\n &mut self,\n note_hash_counter: u32,\n log: [u8; M],\n log_hash: Field,\n ) {\n let counter = self.next_counter();\n let len = log.len() as Field + 4;\n let side_effect = NoteLogHash { value: log_hash, counter, length: len, note_hash_counter };\n self.note_encrypted_logs_hashes.push(side_effect);\n\n emit_encrypted_note_log(note_hash_counter, log, counter);\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 ) -> PackedReturns {\n let args_hash = hash_args_array(args);\n arguments::pack_arguments_array(args);\n self.call_private_function_with_packed_args(\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 ) -> PackedReturns {\n let args_hash = hash_args_array(args);\n arguments::pack_arguments_array(args);\n self.call_private_function_with_packed_args(\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 ) -> PackedReturns {\n self.call_private_function_with_packed_args(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 ) -> PackedReturns {\n self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n }\n\n pub fn call_private_function_with_packed_args(\n &mut self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n is_static_call: bool,\n ) -> PackedReturns {\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 // The oracle simulates the private call and returns the value of the side effects counter after execution of\n // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n // 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 PackedReturns::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 arguments::pack_arguments_array(args);\n self.call_public_function_with_packed_args(\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 arguments::pack_arguments_array(args);\n self.call_public_function_with_packed_args(\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_packed_args(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_packed_args(contract_address, function_selector, 0, true)\n }\n\n pub fn call_public_function_with_packed_args(\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 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n // WARNING: This is insecure and should be temporary!\n // The oracle repacks 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 = enqueue_public_function_call_internal(\n contract_address,\n function_selector,\n args_hash,\n counter,\n is_static_call,\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 arguments::pack_arguments_array(args);\n self.set_public_teardown_function_with_packed_args(\n contract_address,\n function_selector,\n args_hash,\n false,\n )\n }\n\n pub fn set_public_teardown_function_with_packed_args(\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 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n // WARNING: This is insecure and should be temporary!\n // The oracle repacks 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 = set_public_teardown_function_call_internal(\n contract_address,\n function_selector,\n args_hash,\n counter,\n is_static_call,\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: Header::empty(),\n note_encrypted_logs_hashes: BoundedVec::new(),\n encrypted_logs_hashes: BoundedVec::new(),\n contract_class_logs_hashes: BoundedVec::new(),\n last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n }\n }\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/context/private_context.nr"},"127":{"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::arguments::pack_arguments;\n\npub trait CallInterface {\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\npub struct PrivateCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args_hash: Field,\n pub args: [Field],\n pub return_type: T,\n pub is_static: bool,\n}\n\nimpl PrivateCallInterface {\n pub fn call(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n pack_arguments(self.args);\n let returns = context.call_private_function_with_packed_args(\n self.target_contract,\n self.selector,\n self.args_hash,\n false,\n );\n let unpacked: T = returns.unpack_into();\n unpacked\n }\n\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n pack_arguments(self.args);\n let returns = context.call_private_function_with_packed_args(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns.unpack_into()\n }\n}\n\nimpl CallInterface for PrivateVoidCallInterface {}\n\npub struct PrivateVoidCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args_hash: Field,\n pub args: [Field],\n pub return_type: (),\n pub is_static: bool,\n}\n\nimpl PrivateVoidCallInterface {\n pub fn call(self, context: &mut PrivateContext) {\n pack_arguments(self.args);\n context\n .call_private_function_with_packed_args(\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 pack_arguments(self.args);\n context\n .call_private_function_with_packed_args(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PrivateStaticCallInterface {}\n\npub struct PrivateStaticCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args_hash: Field,\n pub args: [Field],\n pub return_type: T,\n pub is_static: bool,\n}\n\nimpl PrivateStaticCallInterface {\n pub fn view(self, context: &mut PrivateContext) -> T\n where\n T: Deserialize,\n {\n pack_arguments(self.args);\n let returns = context.call_private_function_with_packed_args(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n );\n returns.unpack_into()\n }\n}\n\nimpl CallInterface for PrivateStaticVoidCallInterface {}\n\npub struct PrivateStaticVoidCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args_hash: Field,\n pub args: [Field],\n pub return_type: (),\n pub is_static: bool,\n}\n\nimpl PrivateStaticVoidCallInterface {\n pub fn view(self, context: &mut PrivateContext) {\n pack_arguments(self.args);\n context\n .call_private_function_with_packed_args(\n self.target_contract,\n self.selector,\n self.args_hash,\n true,\n )\n .assert_empty();\n }\n}\n\nimpl CallInterface for PublicCallInterface {}\n\npub struct PublicCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args: [Field],\n pub gas_opts: GasOpts,\n pub return_type: T,\n pub is_static: bool,\n}\n\nimpl PublicCallInterface {\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicVoidCallInterface {}\n\npub struct PublicVoidCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args: [Field],\n pub return_type: (),\n pub is_static: bool,\n pub gas_opts: GasOpts,\n}\n\nimpl PublicVoidCallInterface {\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticCallInterface {}\n\npub struct PublicStaticCallInterface {\n pub target_contract: AztecAddress,\n pub selector: FunctionSelector,\n pub name: str,\n pub args: [Field],\n pub return_type: T,\n pub is_static: bool,\n pub gas_opts: GasOpts,\n}\n\nimpl PublicStaticCallInterface {\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n\nimpl CallInterface for PublicStaticVoidCallInterface {}\n\npub struct PublicStaticVoidCallInterface {\n target_contract: AztecAddress,\n selector: FunctionSelector,\n name: str,\n args: [Field],\n return_type: (),\n is_static: bool,\n gas_opts: GasOpts,\n}\n\nimpl PublicStaticVoidCallInterface {\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 pack_arguments(self.args);\n context.call_public_function_with_packed_args(\n self.target_contract,\n self.selector,\n args_hash,\n /*static=*/\n true,\n )\n }\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr"},"128":{"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::Deserialize};\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: Deserialize,\n {\n T::deserialize(self.raw_storage_read(storage_slot))\n }\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/context/unconstrained_context.nr"},"134":{"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::{Deserialize, Empty, Serialize};\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_unencrypted_log(_self: &mut Self, log: T)\n where\n T: Serialize,\n {\n // AVM opcodes are constrained by the AVM itself\n unsafe { emit_unencrypted_log(Serialize::serialize(log).as_slice()) };\n }\n\n pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n // 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 // 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 // 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 // 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 let success = call(gas_for_call(gas_opts), contract_address, args);\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 let success = call_static(gas_for_call(gas_opts), contract_address, args);\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 // 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 // AVM opcodes are constrained by the AVM itself\n unsafe { emit_nullifier(nullifier) };\n }\n\n pub fn this_address(_self: Self) -> AztecAddress {\n // AVM opcodes are constrained by the AVM itself\n unsafe {\n address()\n }\n }\n pub fn msg_sender(_self: Self) -> AztecAddress {\n // 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 // 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 // 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 // AVM opcodes are constrained by the AVM itself\n unsafe {\n chain_id()\n }\n }\n pub fn version(_self: Self) -> Field {\n // AVM opcodes are constrained by the AVM itself\n unsafe {\n version()\n }\n }\n pub fn block_number(_self: Self) -> Field {\n // AVM opcodes are constrained by the AVM itself\n unsafe {\n block_number()\n }\n }\n pub fn timestamp(_self: Self) -> u64 {\n // 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 // 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 // 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 // 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 // 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 // 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 // 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: Deserialize,\n {\n T::deserialize(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 // 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: Serialize,\n {\n self.raw_storage_write(storage_slot, value.serialize());\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}\n// TODO(9396): Remove.\nunconstrained fn portal() -> EthAddress {\n portal_opcode()\n}\n// TODO(9396): Remove.\n//unconstrained fn function_selector() -> u32 {\n// function_selector_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_unencrypted_log(message: [Field]) {\n emit_unencrypted_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]) -> bool {\n call_opcode(gas, address, args)\n}\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\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\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(avmOpcodePortal)]\nunconstrained fn portal_opcode() -> EthAddress {}\n\n// TODO(9396): Remove.\n//#[oracle(avmOpcodeFunctionSelector)]\n//unconstrained fn function_selector_opcode() -> u32 {}\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#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_unencrypted_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) -> bool {}\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) -> 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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/context/public_context.nr"},"136":{"source":"use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse 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,\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_unencrypted_log_hash(\n contract_address: AztecAddress,\n log: [u8; N],\n) -> Field {\n let mut hash_bytes = [0; N + 36];\n // Address is converted to 32 bytes in ts\n let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n for i in 0..32 {\n hash_bytes[i] = address_bytes[i];\n }\n let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n for i in 0..4 {\n hash_bytes[32 + i] = len_bytes[i];\n }\n for i in 0..N {\n hash_bytes[36 + i] = log[i];\n }\n\n sha256_to_field(hash_bytes)\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\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n let contract_address = AztecAddress::from_field(\n 0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n );\n let log = [\n 0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n 0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n 0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n 0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n 0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n ];\n let serialized_log = arr_to_be_bytes_arr(log);\n let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n let contract_address = AztecAddress::from_field(\n 0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n );\n let log = AztecAddress::from_field(\n 0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n );\n let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n let contract_address = AztecAddress::from_field(\n 0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n );\n let log = \"dummy\";\n let serialized_log = str_to_be_bytes_arr(log);\n let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n let contract_address = AztecAddress::from_field(\n 0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n );\n let log = \"Hello this is a string\";\n let serialized_log = str_to_be_bytes_arr(log);\n let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/hash.nr"},"150":{"source":"/// Notifies the simulator that `args` will later be used at some point during execution, referenced by their hash. This\n/// allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of arguments.\npub fn pack_arguments(args: [Field]) {\n // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n // unpacking however the caller must check that the returned value is indeed the preimage.\n unsafe { pack_arguments_oracle_wrapper(args) };\n}\n\n/// Same as `pack_arguments`, but using arrays instead of slices.\npub fn pack_arguments_array(args: [Field; N]) {\n // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n // unpacking however the caller must check that the returned value is indeed the preimage.\n unsafe { pack_arguments_array_oracle_wrapper(args) };\n}\n\nunconstrained fn pack_arguments_oracle_wrapper(args: [Field]) {\n let _ = pack_arguments_oracle(args);\n}\n\nunconstrained fn pack_arguments_array_oracle_wrapper(args: [Field; N]) {\n let _ = pack_arguments_array_oracle(args);\n}\n\n#[oracle(packArguments)]\nunconstrained fn pack_arguments_oracle(_args: [Field]) -> Field {}\n\n#[oracle(packArgumentsArray)]\nunconstrained fn pack_arguments_array_oracle(_args: [Field; N]) -> Field {}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/arguments.nr"},"151":{"source":"use dep::protocol_types::{\n address::AztecAddress, constants::CONTRACT_INSTANCE_LENGTH, contract_class_id::ContractClassId,\n contract_instance::ContractInstance,\n};\n\n// NOTE: this is for use in private only\n#[oracle(getContractInstance)]\nunconstrained fn get_contract_instance_oracle(\n _address: AztecAddress,\n) -> [Field; CONTRACT_INSTANCE_LENGTH] {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(\n address: AztecAddress,\n) -> [Field; CONTRACT_INSTANCE_LENGTH] {\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 let instance =\n unsafe { ContractInstance::deserialize(get_contract_instance_internal(address)) };\n // The to_address function combines all values in the instance object to produce an address, so by checking that we\n // get the expected address we validate the entire struct.\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 let (member, exists) = 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 let (member, exists) = 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 let (member, exists) = get_contract_instance_initialization_hash_internal_avm(address);\n if exists {\n Option::some(member)\n } else {\n Option::none()\n }\n}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr"},"158":{"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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/execution.nr"},"160":{"source":"use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n utils::arr_copy_slice,\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 serialized_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n unsafe {\n notify_created_note_oracle_wrapper(\n storage_slot,\n note_type_id,\n serialized_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 // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper(\n storage_slot: Field,\n note_type_id: Field,\n serialized_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n let _ = notify_created_note_oracle(\n storage_slot,\n note_type_id,\n serialized_note,\n note_hash,\n counter,\n );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle(\n _storage_slot: Field,\n _note_type_id: Field,\n _serialized_note: [Field; N],\n _note_hash: Field,\n _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n nullifier: Field,\n note_hash: Field,\n counter: u32,\n) {\n let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n _nullifier: Field,\n _note_hash: Field,\n _counter: u32,\n) -> 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 _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by_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 mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n let return_size = placeholder_fields.len() as u32;\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 return_size,\n placeholder_fields,\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 mut placeholder_opt_notes: [Option; S], // TODO: Remove it and use `limit` to initialize the note array.\n placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option; S]\nwhere\n Note: NoteInterface,\n{\n sync_notes_oracle_wrapper();\n let fields = 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 placeholder_fields,\n );\n let num_notes = fields[0] as u32;\n let contract_address = AztecAddress::from_field(fields[1]);\n for i in 0..placeholder_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 let nonce = fields[read_offset];\n let note_hash_counter = fields[read_offset + 1] as u32;\n let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n let mut note = Note::deserialize_content(serialized_note);\n note.set_header(header);\n placeholder_opt_notes[i] = Option::some(note);\n };\n }\n placeholder_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) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag as an array of bytes, ready to be included in a\n/// log.\npub unconstrained fn get_app_tag_bytes_as_sender(\n sender: AztecAddress,\n recipient: AztecAddress,\n) -> [u8; 32] {\n let tag = get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient);\n tag.to_be_bytes()\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 ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n sender: AztecAddress,\n recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_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 // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe 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\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n unsafe {\n sync_notes_oracle_wrapper();\n }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/notes.nr"},"161":{"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 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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr"},"162":{"source":"use dep::protocol_types::{address::AztecAddress, traits::Deserialize};\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: Deserialize,\n{\n T::deserialize(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;\n\n use crate::test::mocks::mock_struct::MockStruct;\n use std::test::OracleMock;\n\n global address = AztecAddress::from_field(29);\n global slot = 7;\n global block_number = 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.serialize());\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.serialize());\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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/oracle/storage.nr"},"177":{"source":"use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress,\n constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator,\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\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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/aztec-nr/aztec/src/initializer.nr"},"183":{"source":"use crate::{\n abis::function_selector::FunctionSelector,\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{\n AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n MAX_FIELD_VALUE,\n },\n contract_class_id::ContractClassId,\n hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n merkle_tree::membership::MembershipWitness,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n traits::{Deserialize, Empty, FromField, Serialize, ToField},\n utils,\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 ec::{pow, sqrt},\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\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\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 secrect 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_private_function(\n function_selector: FunctionSelector,\n function_vk_hash: Field,\n function_leaf_membership_witness: MembershipWitness,\n contract_class_artifact_hash: Field,\n contract_class_public_bytecode_commitment: Field,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let private_functions_root = private_functions_root_from_siblings(\n function_selector,\n function_vk_hash,\n function_leaf_membership_witness.leaf_index,\n function_leaf_membership_witness.sibling_path,\n );\n\n let contract_class_id = ContractClassId::compute(\n contract_class_artifact_hash,\n private_functions_root,\n contract_class_public_bytecode_commitment,\n );\n\n // Compute contract address using the preimage which includes the class_id.\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_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 pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n Self { inner: result }\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 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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr"},"194":{"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.to_integer()]\n }\n}\n\nimpl Deserialize for U128 {\n fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n U128::from_integer(fields[0])\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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr"},"212":{"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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr"},"227":{"source":"use crate::meta::{derive_deserialize, 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 U128::from_integer(0)\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.to_integer()\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 U128::from_integer(value)\n }\n}\n\n// docs:start:serialize\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#[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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr"},"229":{"source":"use crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n function_selector::FunctionSelector,\n log_hash::{LogHash, ScopedEncryptedLogHash, ScopedLogHash},\n note_hash::ScopedNoteHash,\n nullifier::ScopedNullifier,\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,\n },\n merkle_tree::root::root_from_sibling_path,\n messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n traits::{is_empty, ToField},\n utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::field::field_from_bytes;\n\npub fn sha256_to_field(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = std::hash::sha256(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\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n // Hashing tx hash with note index in tx is guaranteed to be unique\n poseidon2_hash_with_separator(\n [tx_hash, note_index_in_tx as Field],\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n let inputs = [nonce, note_hash];\n poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), unique_note_hash],\n GENERATOR_INDEX__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, tx_hash: Field, note_index_in_tx: u32) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\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 silo_encrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n // We assume contract address has already been masked\n if log_hash.contract_address.is_zero() {\n 0\n } else {\n accumulate_sha256(\n [log_hash.contract_address.to_field(), log_hash.log_hash.value],\n )\n }\n}\n\npub fn mask_encrypted_log_hash(scoped_log: ScopedEncryptedLogHash) -> AztecAddress {\n if scoped_log.contract_address.is_zero() {\n AztecAddress::from_field(0)\n } else if (scoped_log.log_hash.randomness == 0) {\n scoped_log.contract_address\n } else {\n AztecAddress::from_field(poseidon2_hash_with_separator(\n [scoped_log.contract_address.to_field(), scoped_log.log_hash.randomness],\n 0,\n ))\n }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n if log_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\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: BoundedVec = BoundedVec::new();\n\n let inputs =\n [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n for i in 0..inputs.len() {\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.push(item_bytes[j]);\n }\n }\n\n sha256_to_field(bytes.storage())\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\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash(logs: [LogHash; N]) -> Field {\n // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n let mut hash_input_flattened = [0; N * 32];\n for offset in 0..N {\n // TODO: This is not checking that the decomposition is smaller than P\n let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n for byte_index in 0..32 {\n hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n }\n }\n // Ideally we would push to a slice then hash, but there is no sha_slice\n // Hardcode to 256 bytes for now\n let mut hash = sha256_to_field(hash_input_flattened);\n // Not having a 0 value hash for empty logs causes issues with empty txs\n // used for padding. Returning early is currently unsupported.\n // We always provide sorted logs here, so 0 being empty means all are empty.\n if is_empty(logs[0]) {\n hash = 0;\n }\n hash\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 // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n let in_len = N + 1;\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = std::hash::poseidon2::Poseidon2::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\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 two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = std::hash::poseidon2::Poseidon2::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 // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n let mut in_len = N / 31;\n let mut has_padding = false;\n if N % 31 != 0 {\n in_len += 1;\n has_padding = true;\n }\n\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\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 sponge.absorb(field_from_bytes(current_field, false));\n current_field = [0; 31];\n }\n }\n if has_padding {\n sponge.absorb(field_from_bytes(current_field, false));\n }\n\n 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 = std::hash::sha256(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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr"},"262":{"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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/abis/function_selector.nr"},"311":{"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};\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","path":"/home/filip/nargo/github.com/AztecProtocol/aztec-packages/aztec-packages-v0.65.0/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr"}}} \ No newline at end of file diff --git a/services/explorer-api/migrations/0000_worried_impossible_man.sql b/services/explorer-api/migrations/0000_dry_puppet_master.sql similarity index 99% rename from services/explorer-api/migrations/0000_worried_impossible_man.sql rename to services/explorer-api/migrations/0000_dry_puppet_master.sql index 0839a622..154d5ae9 100644 --- a/services/explorer-api/migrations/0000_worried_impossible_man.sql +++ b/services/explorer-api/migrations/0000_dry_puppet_master.sql @@ -43,7 +43,7 @@ CREATE TABLE IF NOT EXISTS "logs" ( "index" integer NOT NULL, "tx_effect_to_logs_id" uuid NOT NULL, "type" varchar(20) NOT NULL, - "data" varchar NOT NULL, + "data" "bytea" NOT NULL, "masked_contract_address" varchar(66), "contract_address" varchar(66) ); diff --git a/services/explorer-api/migrations/meta/0000_snapshot.json b/services/explorer-api/migrations/meta/0000_snapshot.json index bc3ff745..a0188005 100644 --- a/services/explorer-api/migrations/meta/0000_snapshot.json +++ b/services/explorer-api/migrations/meta/0000_snapshot.json @@ -1,5 +1,5 @@ { - "id": "af074cee-b3a6-4eff-9768-66ad1eace0e0", + "id": "4fe591f8-e500-430d-a332-4c1c8cde201c", "prevId": "00000000-0000-0000-0000-000000000000", "version": "7", "dialect": "postgresql", @@ -271,7 +271,7 @@ }, "data": { "name": "data", - "type": "varchar", + "type": "bytea", "primaryKey": false, "notNull": true }, diff --git a/services/explorer-api/migrations/meta/_journal.json b/services/explorer-api/migrations/meta/_journal.json index 1ec5572f..3ff992f7 100644 --- a/services/explorer-api/migrations/meta/_journal.json +++ b/services/explorer-api/migrations/meta/_journal.json @@ -5,8 +5,8 @@ { "idx": 0, "version": "7", - "when": 1733146511848, - "tag": "0000_worried_impossible_man", + "when": 1733239184791, + "tag": "0000_dry_puppet_master", "breakpoints": true } ] diff --git a/services/explorer-api/src/constants.ts b/services/explorer-api/src/constants.ts index 334e0986..9aae6d85 100644 --- a/services/explorer-api/src/constants.ts +++ b/services/explorer-api/src/constants.ts @@ -1,2 +1,12 @@ export const CHAIN_NAME = "AZTEC"; export const SERVICE_NAME = "explorer-api"; + +export const DEFAULT_VERIFIED_CONTRACT_ADDRESSES_DEV = [ + "0x11a81043f8c2cb2e95fa28e051f042a87e76c9e42d442188638eb2c07ae445b2", // Account address added by Sandbox + "0x17eafcd0961cc68c56b79305fa6fa8ee49bf8185b2bff279be84f3ceb1ae03ec", // Account address added by Sandbox + "0x12fb76c6e2ccbad0919c554c07257fc69993ddd9c799c62179345b5b82a95dd8", // Account address added by Sandbox +]; + +export const DEFAULT_VERIFIED_CONTRACT_ADDRESSES_PROD: string[] = [ + // TODO: Add verified contract addresses for production +]; diff --git a/services/explorer-api/src/database/controllers/l2contract/utils.ts b/services/explorer-api/src/database/controllers/l2contract/utils.ts index 432712ef..c29296c3 100644 --- a/services/explorer-api/src/database/controllers/l2contract/utils.ts +++ b/services/explorer-api/src/database/controllers/l2contract/utils.ts @@ -2,11 +2,13 @@ /* eslint-disable @typescript-eslint/no-unsafe-member-access */ /* eslint-disable @typescript-eslint/no-unsafe-argument */ import { ChicmozL2ContractInstanceDeluxe, chicmozL2ContractInstanceDeluxeSchema } from "@chicmoz-pkg/types"; +import { VERIFIED_CONTRACT_ADDRESSES } from "../../../environment.js"; // eslint-disable-next-line @typescript-eslint/no-explicit-any export const parseDeluxe = (contractClass: any, instance: any): ChicmozL2ContractInstanceDeluxe => { return chicmozL2ContractInstanceDeluxeSchema.parse({ ...contractClass, + aztecScoutVerified: VERIFIED_CONTRACT_ADDRESSES.some((address) => address === instance.address), blockHash: instance.blockHash, packedPublicBytecode: Buffer.from(contractClass.packedPublicBytecode), address: instance.address, diff --git a/services/explorer-api/src/database/controllers/sign-of-life.ts b/services/explorer-api/src/database/controllers/sign-of-life.ts index 661717c1..714cb620 100644 --- a/services/explorer-api/src/database/controllers/sign-of-life.ts +++ b/services/explorer-api/src/database/controllers/sign-of-life.ts @@ -1,10 +1,12 @@ -import { desc, eq, sql } from "drizzle-orm"; +import { desc, eq, isNotNull, sql } from "drizzle-orm"; import { NodePgDatabase } from "drizzle-orm/node-postgres"; import { getDb as db } from "../../database/index.js"; import { body, l2Block, + logs, txEffect, + txEffectToLogs, } from "../../database/schema/l2block/index.js"; import { l2ContractInstanceDeployed, l2PrivateFunction, l2UnconstrainedFunction } from "../schema/index.js"; @@ -64,6 +66,20 @@ export const getABlockWithTxEffects = async () => { }; }; +export const getSomeTxEffectWithUnencryptedLogs = async () => { + const dbRes = await db() + .select({ + hash: txEffectToLogs.txEffectHash, + }) + .from(logs) + .where(isNotNull(logs.contractAddress)) + .innerJoin(txEffectToLogs, eq(logs.txEffectToLogsId, txEffectToLogs.id)) + .limit(10) + .execute(); + if (dbRes.length === 0) return null; + return dbRes.map((row) => row.hash); +} + export const getABlockWithContractInstances = async () => { const dbRes = await db() .select({ diff --git a/services/explorer-api/src/database/schema/l2block/body.ts b/services/explorer-api/src/database/schema/l2block/body.ts index cdcc922f..46344aeb 100644 --- a/services/explorer-api/src/database/schema/l2block/body.ts +++ b/services/explorer-api/src/database/schema/l2block/body.ts @@ -10,6 +10,7 @@ import { varchar, } from "drizzle-orm/pg-core"; import { + bufferType, generateAztecAddressColumn, generateFrColumn, generateFrNumberColumn, @@ -74,7 +75,7 @@ export const logs = pgTable("logs", { .notNull() .references(() => txEffectToLogs.id, { onDelete: "cascade" }), type: varchar("type", { length: 20 }).notNull(), // 'noteEncrypted', 'encrypted', or 'unencrypted' - data: varchar("data").notNull(), + data: bufferType("data").notNull(), maskedContractAddress: generateFrColumn("masked_contract_address"), contractAddress: generateAztecAddressColumn("contract_address"), }); diff --git a/services/explorer-api/src/environment.ts b/services/explorer-api/src/environment.ts index e5f95f82..9d1c2e1d 100644 --- a/services/explorer-api/src/environment.ts +++ b/services/explorer-api/src/environment.ts @@ -1,16 +1,29 @@ -import { CHAIN_NAME } from "./constants.js"; +export const NODE_ENV = process.env.NODE_ENV ?? "development"; +import { + CHAIN_NAME, + DEFAULT_VERIFIED_CONTRACT_ADDRESSES_DEV, + DEFAULT_VERIFIED_CONTRACT_ADDRESSES_PROD, +} from "./constants.js"; + +const verifiedContractAddresses = + NODE_ENV === "production" + ? DEFAULT_VERIFIED_CONTRACT_ADDRESSES_PROD + : DEFAULT_VERIFIED_CONTRACT_ADDRESSES_DEV; -export const PUBLIC_API_KEY = process.env.PUBLIC_API_KEY ?? "d1e2083a-660c-4314-a6f2-1d42f4b944f4"; +export const VERIFIED_CONTRACT_ADDRESSES = verifiedContractAddresses + +export const PUBLIC_API_KEY = + process.env.PUBLIC_API_KEY ?? "d1e2083a-660c-4314-a6f2-1d42f4b944f4"; export const CACHE_TTL_SECONDS = Number(process.env.CACHE_TTL) || 60; -export const CACHE_LATEST_TTL_SECONDS = Number(process.env.CACHE_LATEST_TTL) || 10; +export const CACHE_LATEST_TTL_SECONDS = + Number(process.env.CACHE_LATEST_TTL) || 10; export const REDIS_HOST = process.env.REDIS_HOST ?? "redis-master"; export const REDIS_PORT = Number(process.env.REDIS_PORT) || 6379; export const PORT = Number(process.env.PORT) || 5000; export const BODY_LIMIT = process.env.BODY_LIMIT ?? "64kb"; export const PARAMETER_LIMIT = Number(process.env.PARAMETER_LIMIT) || 100; -export const NODE_ENV = process.env.NODE_ENV ?? "development"; export const DB_MAX_BLOCKS = 20; export const DB_MAX_TX_EFFECTS = 20; diff --git a/services/explorer-api/src/event-handler/on-block/contracts.ts b/services/explorer-api/src/event-handler/on-block/contracts.ts index fe14904c..7c17a7f6 100644 --- a/services/explorer-api/src/event-handler/on-block/contracts.ts +++ b/services/explorer-api/src/event-handler/on-block/contracts.ts @@ -33,14 +33,10 @@ const parseObjs = ( const parsedObjs: T[] = []; for (const obj of objs) { try { - const parsed = parseFn( - JSON.parse( - JSON.stringify({ - blockHash, - ...obj, - }) - ) - ); + const parsed = parseFn({ + blockHash, + ...obj, + }); parsedObjs.push(parsed); } catch (e) { // eslint-disable-next-line @typescript-eslint/restrict-template-expressions @@ -78,6 +74,7 @@ export const storeContracts = async (b: L2Block, blockHash: string) => { contractClassLogs, ProtocolContractAddress.ContractClassRegisterer ); + const unencryptedBlockLogs = b.body.txEffects.flatMap((txEffect) => txEffect.unencryptedLogs.unrollLogs() ); @@ -90,6 +87,22 @@ export const storeContracts = async (b: L2Block, blockHash: string) => { ProtocolContractAddress.ContractClassRegisterer ); + if ( + contractClasses.length > 0 + ) { + logger.info( + contractClasses.map((contractClass) => contractClass.contractClassId.toString()) + ); + } + + if ( + contractInstances.length > 0 + ) { + logger.info( + contractInstances.map((contractInstance) => `Contract instance: ${contractInstance.address.toString()} Contract class: ${contractInstance.contractClassId.toString()}`) + ); + } + logger.info( `📜 Parsing and storing ${contractClasses.length} contract classes and ${contractInstances.length} contract instances, ${privateFnEvents.length} private function events, and ${unconstrainedFnEvents.length} unconstrained function events` ); diff --git a/services/explorer-api/src/event-handler/on-block/index.ts b/services/explorer-api/src/event-handler/on-block/index.ts index ef0080f8..0e8dc3a0 100644 --- a/services/explorer-api/src/event-handler/on-block/index.ts +++ b/services/explorer-api/src/event-handler/on-block/index.ts @@ -5,6 +5,24 @@ import { controllers } from "../../database/index.js"; import { logger } from "../../logger.js"; import { storeContracts } from "./contracts.js"; import { handleDuplicateBlockError } from "../utils.js"; +import {L2Block} from "@aztec/aztec.js"; + +const truncateString = (value: string) => { + const startHash = value.substring(0, 100); + const endHash = value.substring(value.length - 100, value.length); + return `${startHash}...${endHash}`; +}; + +const hackyLogBlock = (b: L2Block) => { + const blockString = JSON.stringify(b, null, 2); + const logString = blockString.split(":").map((v) => { + if (v.length > 200 && v.includes(",")) + return truncateString(v); + + return v; + }).join(":"); + logger.error(`🚫 Block: ${logString}`); +}; export const onBlock = async ({ block, blockNumber }: NewBlockEvent) => { // TODO: start storing NODE_INFO connected to the block @@ -22,6 +40,7 @@ export const onBlock = async ({ block, blockNumber }: NewBlockEvent) => { // eslint-disable-next-line @typescript-eslint/restrict-template-expressions `Failed to parse block ${blockNumber}: ${(e as Error)?.stack ?? e}`, ); + hackyLogBlock(b); return; } await storeBlock(parsedBlock); diff --git a/services/explorer-api/src/http-server/express-config.ts b/services/explorer-api/src/http-server/express-config.ts index 726419c0..d7f7dfb3 100644 --- a/services/explorer-api/src/http-server/express-config.ts +++ b/services/explorer-api/src/http-server/express-config.ts @@ -2,7 +2,7 @@ import bodyParser from "body-parser"; import cors from "cors"; import express from "express"; import helmet from "helmet"; -import morgan from "morgan"; +//import morgan from "morgan"; import { init as initApiRoutes } from "./routes/index.js"; import { createErrorMiddleware } from "@chicmoz-pkg/error-middleware"; import { genereateOpenApiSpec } from "./open-api-spec.js"; @@ -35,7 +35,7 @@ export function setup( parameterLimit: options.PARAMETER_LIMIT, }) ); - app.use(morgan("common")); + //app.use(morgan("common")); const router = express.Router(); router.get("/health", geHealthHandler); diff --git a/services/explorer-api/src/http-server/routes/controllers/inofficial.ts b/services/explorer-api/src/http-server/routes/controllers/inofficial.ts index 7cc947b6..9e8aed04 100644 --- a/services/explorer-api/src/http-server/routes/controllers/inofficial.ts +++ b/services/explorer-api/src/http-server/routes/controllers/inofficial.ts @@ -29,6 +29,7 @@ export const GET_ROUTES = asyncHandler(async (_req, res) => { await db.signOfLife.getABlockWithContractInstances(); const { privateFunction, unconstrainedFunction } = await db.signOfLife.getL2ContractFunctions(); + const someUnencryptedLogsTxEffects = await db.signOfLife.getSomeTxEffectWithUnencryptedLogs(); const r = [paths.latestHeight, paths.latestBlock, `${paths.blocks}?from=0`]; const searchRoutes = []; @@ -59,7 +60,7 @@ export const GET_ROUTES = asyncHandler(async (_req, res) => { ) ); r.push( - paths.txEffectsByTxHash.replace( + paths.txEffectsByTxEffectHash.replace( `:${txEffectHash}`, blockAndTxEffect.txEffects[0].hash ) @@ -70,7 +71,7 @@ export const GET_ROUTES = asyncHandler(async (_req, res) => { } else { r.push(paths.txEffectsByBlockHeight + "NOT FOUND"); r.push(paths.txEffectByBlockHeightAndIndex + "NOT FOUND"); - r.push(paths.txEffectsByTxHash + "NOT FOUND"); + r.push(paths.txEffectsByTxEffectHash + "NOT FOUND"); } if (blockAndAContractInstance) { @@ -171,6 +172,13 @@ export const GET_ROUTES = asyncHandler(async (_req, res) => { .join("")}
+

Some unencrypted logs tx effects

+
    + ${someUnencryptedLogsTxEffects + ?.map((hash) => `
  • ${hash}
    • `) + .join("")} +
+

Search routes

    ${searchRoutes diff --git a/services/explorer-api/src/http-server/routes/index.ts b/services/explorer-api/src/http-server/routes/index.ts index 91b0ac4c..028804e4 100644 --- a/services/explorer-api/src/http-server/routes/index.ts +++ b/services/explorer-api/src/http-server/routes/index.ts @@ -84,7 +84,7 @@ export const init = ({ router }: { router: Router }) => { router.get(paths.txEffectsByBlockHeight, controller.GET_L2_TX_EFFECTS_BY_BLOCK_HEIGHT); router.get(paths.txEffectByBlockHeightAndIndex, controller.GET_L2_TX_EFFECT_BY_BLOCK_HEIGHT_AND_INDEX); - router.get(paths.txEffectsByTxHash, controller.GET_L2_TX_EFFECT_BY_TX_EFFECT_HASH); + router.get(paths.txEffectsByTxEffectHash, controller.GET_L2_TX_EFFECT_BY_TX_EFFECT_HASH); router.get(paths.txs, controller.GET_PENDING_TXS); diff --git a/services/explorer-api/src/http-server/routes/paths_and_validation.ts b/services/explorer-api/src/http-server/routes/paths_and_validation.ts index 5cca464a..af973999 100644 --- a/services/explorer-api/src/http-server/routes/paths_and_validation.ts +++ b/services/explorer-api/src/http-server/routes/paths_and_validation.ts @@ -19,7 +19,7 @@ export const paths = { txEffectsByBlockHeight: `/l2/blocks/:${blockHeight}/tx-effects`, txEffectByBlockHeightAndIndex: `/l2/blocks/:${blockHeight}/tx-effects/:${txEffectIndex}`, - txEffectsByTxHash: `/l2/tx-effects/:${txEffectHash}`, + txEffectsByTxEffectHash: `/l2/tx-effects/:${txEffectHash}`, txs: "/l2/txs", diff --git a/services/explorer-ui/src/pages/contract-instance-details/index.tsx b/services/explorer-ui/src/pages/contract-instance-details/index.tsx index 4fd10248..2fca9e27 100644 --- a/services/explorer-ui/src/pages/contract-instance-details/index.tsx +++ b/services/explorer-ui/src/pages/contract-instance-details/index.tsx @@ -1,5 +1,6 @@ import { useParams } from "@tanstack/react-router"; import { type FC } from "react"; +import { CheckCircledIcon } from "@radix-ui/react-icons"; import { KeyValueDisplay } from "~/components/info-display/key-value-display"; import { useContractInstance } from "~/hooks/"; import { getContractData } from "./util"; @@ -19,12 +20,25 @@ export const ContractInstanceDetails: FC = () => { if (error) return
    Error
    ; if (!contractInstanceDetails) return
    No data
    ; + // TODO: link to a page on verified contracts and what verified means + const verifiedIcon = contractInstanceDetails.aztecScoutVerified ? ( +
    + +
    + Contract verified by Aztec Scout +
    +
    + ) : ( +
    Not verified
    + ); return (
    -

    Contract instance details

    +

    + Contract instance details {verifiedIcon} +

    diff --git a/services/explorer-ui/src/pages/contract-instance-details/util.ts b/services/explorer-ui/src/pages/contract-instance-details/util.ts index 5c89112e..fdd41d1b 100644 --- a/services/explorer-ui/src/pages/contract-instance-details/util.ts +++ b/services/explorer-ui/src/pages/contract-instance-details/util.ts @@ -4,7 +4,7 @@ import { API_URL, aztecExplorer } from "~/service/constants"; export const getContractData = (data: ChicmozL2ContractInstanceDeluxe) => { const link = `${routes.contracts.route}${routes.contracts.children.classes.route}/${data.contractClassId}/versions/${data.version}`; - return [ + const displayData = [ { label: "ADDRESS", value: data.address, @@ -27,4 +27,12 @@ export const getContractData = (data: ChicmozL2ContractInstanceDeluxe) => { extLink: `${API_URL}/${aztecExplorer.getL2ContractInstance(data.address)}`, }, ]; + if (data.aztecScoutVerified) { + displayData.push({ + label: "VERIFIED ✅", + value: "Contract deployer verified by Aztec Scout.", + link: routes.verifiedContracts.route, + }); + } + return displayData; }; diff --git a/services/explorer-ui/src/pages/tx-effect-details/index.tsx b/services/explorer-ui/src/pages/tx-effect-details/index.tsx index f471165f..22df7fb4 100644 --- a/services/explorer-ui/src/pages/tx-effect-details/index.tsx +++ b/services/explorer-ui/src/pages/tx-effect-details/index.tsx @@ -6,6 +6,42 @@ import { txEffectTabs, type TabId } from "./constants"; import { getTxEffectData, mapTxEffectsData } from "./utils"; import { OptionButtons } from "./tabs"; +const naiveDecode = (data: Buffer): string => { + // TODO + let counterZero = 0; + let counterAbove128 = 0; + let counterAbove255 = 0; + let sum = 0; + let totCount = 0; + const res = data.toString("hex").match(/.{1,64}/g) + ?.map((hex) => parseInt(hex, 16)) + .map((charCode): string => { + if (charCode === 0) { + counterZero++; + } else { + //console.log(`charCode: ${charCode} char: ${String.fromCharCode(charCode)}`); + } + if (charCode > 128) { + counterAbove128++; + } + if (charCode > 255) { + counterAbove255++; + } + sum += charCode; + totCount++; + const char = String.fromCharCode(charCode); + return char; + }) + .join(""); + const avg = sum / totCount; + //console.log("avg", avg); + //console.log("counterAbove128", counterAbove128); + //console.log("counterAbove255", counterAbove255); + //console.log("counterZero", counterZero); + //console.log("totCount", totCount); + return res ?? ""; +}; + export const TxEffectDetails: FC = () => { const [selectedTab, setSelectedTab] = useState("encryptedLogs"); const { hash } = useParams({ @@ -19,7 +55,7 @@ export const TxEffectDetails: FC = () => { // check for the first avalible tab with data if (txEffects) { const firstAvailableTab = txEffectTabs.find( - (tab) => tab.id in txEffectData, + (tab) => tab.id in txEffectData ); if (firstAvailableTab) setSelectedTab(firstAvailableTab.id); @@ -62,7 +98,8 @@ export const TxEffectDetails: FC = () => { return Object.entries(log).map(([key, value]) => { return { label: key, - value: value, + value: + value instanceof Buffer ? value.toString() : value, isClickable: false, }; }); @@ -77,7 +114,7 @@ export const TxEffectDetails: FC = () => {
    ); - }, + } )}
    )} @@ -85,29 +122,21 @@ export const TxEffectDetails: FC = () => {
    {txEffects.unencryptedLogs.functionLogs.map( (unencrypted, index) => { - const entries = unencrypted.logs.map( - ({ data, contractAddress }) => { - return [ - { - label: "data", - value: - data - .match(/.{1,64}/g) - ?.map((hex) => parseInt(hex, 16)) - .map((charCode) => - String.fromCharCode(charCode), - ) - .join("") ?? "", - isClickable: false, - }, - { - label: "Contract Address", - value: contractAddress, - isClickable: true, - }, - ]; - }, - ); + const entries = unencrypted.logs.map((unEncLog) => { + return [ + { + label: "data", + value: naiveDecode(unEncLog.data), + isClickable: false, + }, + { + label: "Contract Address", + value: (unEncLog as { contractAddress: string }) + .contractAddress, + isClickable: true, + }, + ]; + }); // Flatten the nested arrays const flattenedEntries = entries.flat(); @@ -118,7 +147,7 @@ export const TxEffectDetails: FC = () => {
    ); - }, + } )}
    )} @@ -139,7 +168,8 @@ export const TxEffectDetails: FC = () => { const entries = noteEncryptedLogs.logs.map((log) => { return Object.entries(log).map(([key, value]) => ({ label: key, - value: value, + value: + value instanceof Buffer ? value.toString() : value, isClickable: false, })); }); @@ -153,7 +183,7 @@ export const TxEffectDetails: FC = () => {
    ); - }, + } )}
    )} diff --git a/services/explorer-ui/src/pages/tx-effect-details/utils.ts b/services/explorer-ui/src/pages/tx-effect-details/utils.ts index 8259d16d..c3237713 100644 --- a/services/explorer-ui/src/pages/tx-effect-details/utils.ts +++ b/services/explorer-ui/src/pages/tx-effect-details/utils.ts @@ -4,14 +4,14 @@ import { formatTimeSince } from "~/lib/utils"; import { API_URL, aztecExplorer } from "~/service/constants"; export type TxEffectDataType = | string[] - | Array<{ logs: Array<{ data: string; contractAddress: string }> }> + | Array<{ logs: Array<{ data: Buffer; contractAddress: string }> }> | Array<{ logs: Array<{ - data: string; + data: Buffer; maskedContractAddress: string; }>; }> - | Array<{ logs: Array<{ data: string }> }> + | Array<{ logs: Array<{ data: Buffer }> }> | Array<{ leafSlot: string; value: string }>; export const getTxEffectData = (data: ChicmozL2TxEffectDeluxe) => [ diff --git a/services/explorer-ui/src/pages/verified-contracts.tsx b/services/explorer-ui/src/pages/verified-contracts.tsx new file mode 100644 index 00000000..39d40986 --- /dev/null +++ b/services/explorer-ui/src/pages/verified-contracts.tsx @@ -0,0 +1,33 @@ +import { type FC } from "react"; +// TODO: make verified contracts link process env + +export const VerifiedContracts: FC = () => { + return ( +
    +

    Verified contracts

    +
    +

    + Verified contracts mean that we have verified the deployer of the + contract. +

    +
    +

    + ⚠️ Please note that this does not mean that the contract is safe to + use. ⚠️ +

    +
    +

    + You can always find the latest verified contracts by checking{" "} + + our github-repo + + . If you think your contract should be verified, please create a PR to + that file. +

    +
    +
    + ); +}; diff --git a/services/explorer-ui/src/routeTree.gen.ts b/services/explorer-ui/src/routeTree.gen.ts index 51f81ce7..7f5925e0 100644 --- a/services/explorer-ui/src/routeTree.gen.ts +++ b/services/explorer-ui/src/routeTree.gen.ts @@ -17,6 +17,7 @@ import { Route as TermsAndConditionsImport } from './routes/terms-and-conditions // Create Virtual Routes +const VerifiedContractsLazyImport = createFileRoute('/verified-contracts')() const PrivacyPolicyLazyImport = createFileRoute('/privacy-policy')() const AboutUsLazyImport = createFileRoute('/about-us')() const IndexLazyImport = createFileRoute('/')() @@ -34,6 +35,13 @@ const ContractsClassesIdVersionsVersionLazyImport = createFileRoute( // Create/Update Routes +const VerifiedContractsLazyRoute = VerifiedContractsLazyImport.update({ + path: '/verified-contracts', + getParentRoute: () => rootRoute, +} as any).lazy(() => + import('./routes/verified-contracts.lazy').then((d) => d.Route), +) + const PrivacyPolicyLazyRoute = PrivacyPolicyLazyImport.update({ path: '/privacy-policy', getParentRoute: () => rootRoute, @@ -139,6 +147,13 @@ declare module '@tanstack/react-router' { preLoaderRoute: typeof PrivacyPolicyLazyImport parentRoute: typeof rootRoute } + '/verified-contracts': { + id: '/verified-contracts' + path: '/verified-contracts' + fullPath: '/verified-contracts' + preLoaderRoute: typeof VerifiedContractsLazyImport + parentRoute: typeof rootRoute + } '/blocks/$blockNumber': { id: '/blocks/$blockNumber' path: '/blocks/$blockNumber' @@ -198,6 +213,7 @@ export const routeTree = rootRoute.addChildren({ TermsAndConditionsRoute, AboutUsLazyRoute, PrivacyPolicyLazyRoute, + VerifiedContractsLazyRoute, BlocksBlockNumberLazyRoute, TxEffectsHashLazyRoute, BlocksIndexLazyRoute, @@ -219,6 +235,7 @@ export const routeTree = rootRoute.addChildren({ "/terms-and-conditions", "/about-us", "/privacy-policy", + "/verified-contracts", "/blocks/$blockNumber", "/tx-effects/$hash", "/blocks/", @@ -240,6 +257,9 @@ export const routeTree = rootRoute.addChildren({ "/privacy-policy": { "filePath": "privacy-policy.lazy.tsx" }, + "/verified-contracts": { + "filePath": "verified-contracts.lazy.tsx" + }, "/blocks/$blockNumber": { "filePath": "blocks/$blockNumber.lazy.tsx" }, diff --git a/services/explorer-ui/src/routes/__root.tsx b/services/explorer-ui/src/routes/__root.tsx index 0761b392..c962f8bf 100644 --- a/services/explorer-ui/src/routes/__root.tsx +++ b/services/explorer-ui/src/routes/__root.tsx @@ -111,6 +111,10 @@ export const routes = { route: "/terms-and-conditions", title: "Terms and Conditions", }, + verifiedContracts: { + route: "/verified-contracts", + title: "Verified Contracts", + }, }; function notFoundComponent() { diff --git a/services/explorer-ui/src/routes/verified-contracts.lazy.tsx b/services/explorer-ui/src/routes/verified-contracts.lazy.tsx new file mode 100644 index 00000000..edfcaf8b --- /dev/null +++ b/services/explorer-ui/src/routes/verified-contracts.lazy.tsx @@ -0,0 +1,6 @@ +import { createLazyFileRoute } from "@tanstack/react-router"; +import { VerifiedContracts } from "~/pages/verified-contracts"; + +export const Route = createLazyFileRoute("/verified-contracts")({ + component: VerifiedContracts, +});