@aztec/txe 0.0.0-test.0 → 0.0.1-commit.001888fc

package/dest/bin/index.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env -S node --no-warnings
 export {};
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iaW4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dest/bin/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env -S node --no-warnings
-import { createLogger } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/aztec.js/log';
 import { startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
 import { createTXERpcServer } from '../index.js';
 /**
@@ -14,10 +14,11 @@ import { createTXERpcServer } from '../index.js';
         logger.info('Received SIGTERM.');
         process.exit(0);
     });
-    const logger = createLogger('txe:service');
+    const logger = createLogger('txe:rpc');
     logger.info(`Setting up TXE...`);
     const txeServer = createTXERpcServer(logger);
     const { port } = await startHttpRpcServer(txeServer, {
+        host: '127.0.0.1',
         port: TXE_PORT,
         timeoutMs: 1e3 * 60 * 5
     });

package/dest/constants.d.ts

@@ -0,0 +1,3 @@
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+export declare const DEFAULT_ADDRESS: AztecAddress;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRCxlQUFPLE1BQU0sZUFBZSxjQUE4QixDQUFDIn0=

package/dest/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,eAAO,MAAM,eAAe,cAA8B,CAAC"}

package/dest/constants.js

@@ -0,0 +1,2 @@
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+export const DEFAULT_ADDRESS = AztecAddress.fromNumber(42);

package/dest/index.d.ts

@@ -5,4 +5,4 @@ import type { Logger } from '@aztec/foundation/log';
  * @returns A TXE RPC server.
  */
 export declare function createTXERpcServer(logger: Logger): import("@aztec/foundation/json-rpc/server").SafeJsonRpcServer;
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFVQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQXFRcEQ7Ozs7R0FJRztBQUNILHdCQUFnQixrQkFBa0IsQ0FBQyxNQUFNLEVBQUUsTUFBTSxpRUFJaEQifQ==

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AA+LpD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,iEAIhD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAqQpD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,iEAIhD"}

package/dest/index.js

@@ -1,16 +1,33 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { AztecAddress, Fr, PublicKeys, deriveKeys, getContractInstanceFromDeployParams, loadContractArtifact } from '@aztec/aztec.js';
+import { loadContractArtifact } from '@aztec/aztec.js/abi';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import { PublicKeys, deriveKeys } from '@aztec/aztec.js/keys';
 import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import { protocolContractNames } from '@aztec/protocol-contracts';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { ContractStore } from '@aztec/pxe/server';
+import { computeArtifactHash } from '@aztec/stdlib/contract';
+import { zodFor } from '@aztec/stdlib/schemas';
+import { createHash } from 'crypto';
+import { createReadStream } from 'fs';
 import { readFile, readdir } from 'fs/promises';
-import { join } from 'path';
+import { join, parse } from 'path';
 import { z } from 'zod';
-import { TXEService } from './txe_service/txe_service.js';
-import { ForeignCallArgsSchema, ForeignCallResultSchema, fromArray, fromSingle, toForeignCallResult, toSingle } from './util/encoding.js';
-const TXESessions = new Map();
-const TXEArtifactsCache = new Map();
-const TXEForeignCallInputSchema = z.object({
+import { TXESession } from './txe_session.js';
+import { ForeignCallArgsSchema, ForeignCallResultSchema, addressFromSingle, fromArray, fromSingle, toSingle } from './util/encoding.js';
+const sessions = new Map();
+/*
+ * TXE typically has to load the same contract artifacts over and over again for multiple tests,
+ * so we cache them here to avoid loading from disk repeatedly.
+ *
+ * The in-flight map coalesces concurrent requests for the same cache key so that
+ * computeArtifactHash (very expensive) is only run once even under parallelism.
+ */ const TXEArtifactsCache = new Map();
+const TXEArtifactsCacheInFlight = new Map();
+const TXEForeignCallInputSchema = zodFor()(z.object({
     // eslint-disable-next-line camelcase
     session_id: z.number().int().nonnegative(),
     function: z.string(),
@@ -19,64 +36,96 @@ const TXEForeignCallInputSchema = z.object({
     // eslint-disable-next-line camelcase
     package_name: z.string(),
     inputs: ForeignCallArgsSchema
-});
+}));
 class TXEDispatcher {
     logger;
-    protocolContracts;
+    contractStore;
     constructor(logger){
         this.logger = logger;
     }
+    fastHashFile(path) {
+        return new Promise((resolve)=>{
+            const fd = createReadStream(path);
+            const hash = createHash('sha1');
+            hash.setEncoding('hex');
+            fd.on('end', function() {
+                hash.end();
+                resolve(hash.read());
+            });
+            fd.pipe(hash);
+        });
+    }
     async #processDeployInputs({ inputs, root_path: rootPath, package_name: packageName }) {
-        const [pathStr, contractName, initializer] = inputs.slice(0, 3).map((input)=>fromArray(input).map((char)=>String.fromCharCode(char.toNumber())).join(''));
-        const decodedArgs = fromArray(inputs[4]);
-        const secret = fromSingle(inputs[5]);
+        const [contractPath, initializer] = inputs.slice(0, 2).map((input)=>fromArray(input).map((char)=>String.fromCharCode(char.toNumber())).join(''));
+        const decodedArgs = fromArray(inputs[3]);
+        const secret = fromSingle(inputs[4]);
+        const salt = fromSingle(inputs[5]);
+        const deployer = addressFromSingle(inputs[6]);
         const publicKeys = secret.equals(Fr.ZERO) ? PublicKeys.default() : (await deriveKeys(secret)).publicKeys;
         const publicKeysHash = await publicKeys.hash();
-        const cacheKey = `${pathStr}-${contractName}-${initializer}-${decodedArgs.map((arg)=>arg.toString()).join('-')}-${publicKeysHash.toString()}`;
-        let artifact;
+        let artifactPath = '';
+        const { dir: contractDirectory, base: contractFilename } = parse(contractPath);
+        if (contractDirectory) {
+            if (contractDirectory.includes('@')) {
+                // We're deploying a contract that belongs in a workspace
+                // env.deploy("../path/to/workspace/root@packageName/contractName")
+                const [workspace, pkg] = contractDirectory.split('@');
+                const targetPath = join(rootPath, workspace, '/target');
+                this.logger.debug(`Looking for compiled artifact in workspace ${targetPath}`);
+                artifactPath = join(targetPath, `${pkg}-${contractFilename}.json`);
+            } else {
+                // We're deploying a standalone external contract
+                // env.deploy("../path/to/contract/root/contractName")
+                const targetPath = join(rootPath, contractDirectory, '/target');
+                this.logger.debug(`Looking for compiled artifact in ${targetPath}`);
+                [artifactPath] = (await readdir(targetPath)).filter((file)=>file.endsWith(`-${contractFilename}.json`));
+            }
+        } else {
+            // We're deploying a local contract
+            // env.deploy("contractName")
+            artifactPath = join(rootPath, './target', `${packageName}-${contractFilename}.json`);
+        }
+        const fileHash = await this.fastHashFile(artifactPath);
+        const cacheKey = `${contractDirectory ?? ''}-${contractFilename}-${initializer}-${decodedArgs.map((arg)=>arg.toString()).join('-')}-${publicKeysHash}-${salt}-${deployer}-${fileHash}`;
         let instance;
+        let artifact;
         if (TXEArtifactsCache.has(cacheKey)) {
             this.logger.debug(`Using cached artifact for ${cacheKey}`);
             ({ artifact, instance } = TXEArtifactsCache.get(cacheKey));
         } else {
-            let artifactPath = '';
-            // We're deploying the contract under test
-            // env.deploy_self("contractName")
-            if (!pathStr) {
-                artifactPath = join(rootPath, './target', `${packageName}-${contractName}.json`);
-            } else {
-                // We're deploying a contract that belongs in a workspace
-                // env.deploy("../path/to/workspace/root@packageName", "contractName")
-                if (pathStr.includes('@')) {
-                    const [workspace, pkg] = pathStr.split('@');
-                    const targetPath = join(rootPath, workspace, './target');
-                    this.logger.debug(`Looking for compiled artifact in workspace ${targetPath}`);
-                    artifactPath = join(targetPath, `${pkg}-${contractName}.json`);
-                } else {
-                    // We're deploying a standalone contract
-                    // env.deploy("../path/to/contract/root", "contractName")
-                    const targetPath = join(rootPath, pathStr, './target');
-                    this.logger.debug(`Looking for compiled artifact in ${targetPath}`);
-                    [artifactPath] = (await readdir(targetPath)).filter((file)=>file.endsWith(`-${contractName}.json`));
-                }
+            if (!TXEArtifactsCacheInFlight.has(cacheKey)) {
+                this.logger.debug(`Loading compiled artifact ${artifactPath}`);
+                const compute = async ()=>{
+                    const artifactJSON = JSON.parse(await readFile(artifactPath, 'utf-8'));
+                    const artifactWithoutHash = loadContractArtifact(artifactJSON);
+                    const computedArtifact = {
+                        ...artifactWithoutHash,
+                        // Artifact hash is *very* expensive to compute, so we do it here once
+                        // and the TXE contract data provider can cache it
+                        artifactHash: await computeArtifactHash(artifactWithoutHash)
+                    };
+                    this.logger.debug(`Deploy ${computedArtifact.name} with initializer ${initializer}(${decodedArgs}) and public keys hash ${publicKeysHash.toString()}`);
+                    const computedInstance = await getContractInstanceFromInstantiationParams(computedArtifact, {
+                        constructorArgs: decodedArgs,
+                        skipArgsDecoding: true,
+                        salt,
+                        publicKeys,
+                        constructorArtifact: initializer ? initializer : undefined,
+                        deployer
+                    });
+                    const result = {
+                        artifact: computedArtifact,
+                        instance: computedInstance
+                    };
+                    TXEArtifactsCache.set(cacheKey, result);
+                    TXEArtifactsCacheInFlight.delete(cacheKey);
+                    return result;
+                };
+                TXEArtifactsCacheInFlight.set(cacheKey, compute());
             }
-            this.logger.debug(`Loading compiled artifact ${artifactPath}`);
-            artifact = loadContractArtifact(JSON.parse(await readFile(artifactPath, 'utf-8')));
-            this.logger.debug(`Deploy ${artifact.name} with initializer ${initializer}(${decodedArgs}) and public keys hash ${publicKeysHash.toString()}`);
-            instance = await getContractInstanceFromDeployParams(artifact, {
-                constructorArgs: decodedArgs,
-                skipArgsDecoding: true,
-                salt: Fr.ONE,
-                publicKeys,
-                constructorArtifact: initializer ? initializer : undefined,
-                deployer: AztecAddress.ZERO
-            });
-            TXEArtifactsCache.set(cacheKey, {
-                artifact,
-                instance
-            });
+            ({ artifact, instance } = await TXEArtifactsCacheInFlight.get(cacheKey));
         }
-        inputs.splice(0, 2, artifact, instance, toSingle(secret));
+        inputs.splice(0, 1, artifact, instance, toSingle(secret));
     }
     async #processAddAccountInputs({ inputs }) {
         const secret = fromSingle(inputs[0]);
@@ -87,24 +136,38 @@ class TXEDispatcher {
             this.logger.debug(`Using cached artifact for ${cacheKey}`);
             ({ artifact, instance } = TXEArtifactsCache.get(cacheKey));
         } else {
-            const keys = await deriveKeys(secret);
-            const args = [
-                keys.publicKeys.masterIncomingViewingPublicKey.x,
-                keys.publicKeys.masterIncomingViewingPublicKey.y
-            ];
-            artifact = SchnorrAccountContractArtifact;
-            instance = await getContractInstanceFromDeployParams(artifact, {
-                constructorArgs: args,
-                skipArgsDecoding: true,
-                salt: Fr.ONE,
-                publicKeys: keys.publicKeys,
-                constructorArtifact: 'constructor',
-                deployer: AztecAddress.ZERO
-            });
-            TXEArtifactsCache.set(cacheKey, {
-                artifact,
-                instance
-            });
+            if (!TXEArtifactsCacheInFlight.has(cacheKey)) {
+                const compute = async ()=>{
+                    const keys = await deriveKeys(secret);
+                    const args = [
+                        keys.publicKeys.masterIncomingViewingPublicKey.x,
+                        keys.publicKeys.masterIncomingViewingPublicKey.y
+                    ];
+                    const computedArtifact = {
+                        ...SchnorrAccountContractArtifact,
+                        // Artifact hash is *very* expensive to compute, so we do it here once
+                        // and the TXE contract data provider can cache it
+                        artifactHash: await computeArtifactHash(SchnorrAccountContractArtifact)
+                    };
+                    const computedInstance = await getContractInstanceFromInstantiationParams(computedArtifact, {
+                        constructorArgs: args,
+                        skipArgsDecoding: true,
+                        salt: Fr.ONE,
+                        publicKeys: keys.publicKeys,
+                        constructorArtifact: 'constructor',
+                        deployer: AztecAddress.ZERO
+                    });
+                    const result = {
+                        artifact: computedArtifact,
+                        instance: computedInstance
+                    };
+                    TXEArtifactsCache.set(cacheKey, result);
+                    TXEArtifactsCacheInFlight.delete(cacheKey);
+                    return result;
+                };
+                TXEArtifactsCacheInFlight.set(cacheKey, compute());
+            }
+            ({ artifact, instance } = await TXEArtifactsCacheInFlight.get(cacheKey));
         }
         inputs.splice(0, 0, artifact, instance);
     }
@@ -112,33 +175,34 @@ class TXEDispatcher {
     async resolve_foreign_call(callData) {
         const { session_id: sessionId, function: functionName, inputs } = callData;
         this.logger.debug(`Calling ${functionName} on session ${sessionId}`);
-        if (!TXESessions.has(sessionId) && functionName != 'reset') {
+        if (!sessions.has(sessionId)) {
             this.logger.debug(`Creating new session ${sessionId}`);
-            if (!this.protocolContracts) {
-                this.protocolContracts = await Promise.all(protocolContractNames.map((name)=>new BundledProtocolContractsProvider().getProtocolContractArtifact(name)));
+            if (!this.contractStore) {
+                const kvStore = await openTmpStore('txe-contracts');
+                this.contractStore = new ContractStore(kvStore);
+                const provider = new BundledProtocolContractsProvider();
+                for (const name of protocolContractNames){
+                    const { instance, artifact } = await provider.getProtocolContractArtifact(name);
+                    await this.contractStore.addContractArtifact(artifact);
+                    await this.contractStore.addContractInstance(instance);
+                }
+                this.logger.debug('Registered protocol contracts in shared contract store');
             }
-            TXESessions.set(sessionId, await TXEService.init(this.logger, this.protocolContracts));
+            sessions.set(sessionId, await TXESession.init(this.contractStore));
         }
         switch(functionName){
-            case 'reset':
-                {
-                    TXESessions.delete(sessionId) && this.logger.debug(`Called reset on session ${sessionId}, yeeting it out of existence`);
-                    return toForeignCallResult([]);
-                }
-            case 'deploy':
+            case 'aztec_txe_deploy':
                 {
                     await this.#processDeployInputs(callData);
                     break;
                 }
-            case 'addAccount':
+            case 'aztec_txe_addAccount':
                 {
                     await this.#processAddAccountInputs(callData);
                     break;
                 }
         }
-        const txeService = TXESessions.get(sessionId);
-        const response = await txeService[functionName](...inputs);
-        return response;
+        return await sessions.get(sessionId).processFunction(functionName, inputs);
     }
 }
 const TXEDispatcherApiSchema = {

package/dest/oracle/interfaces.d.ts

@@ -0,0 +1,58 @@
+import type { ContractArtifact } from '@aztec/aztec.js/abi';
+import { CompleteAddress } from '@aztec/aztec.js/addresses';
+import type { ContractInstanceWithAddress } from '@aztec/aztec.js/contracts';
+import { TxHash } from '@aztec/aztec.js/tx';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { EventSelector, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { UInt64 } from '@aztec/stdlib/types';
+/**
+ * Oracle methods associated with the execution of an Aztec #[external("public")] function.
+ *
+ * Note that real contracts have their Brillig calls to these be transpiled into opcodes, the oracles are only executed
+ * as such when running the original Brillig code, e.g. when invoking functions that interact with a PublicContext
+ * directly in a Noir test.
+ */
+export interface IAvmExecutionOracle {
+    isAvm: true;
+    address(): Promise<AztecAddress>;
+    sender(): Promise<AztecAddress>;
+    blockNumber(): Promise<BlockNumber>;
+    timestamp(): Promise<bigint>;
+    isStaticCall(): Promise<boolean>;
+    chainId(): Promise<Fr>;
+    version(): Promise<Fr>;
+    emitNullifier(nullifier: Fr): Promise<void>;
+    emitNoteHash(noteHash: Fr): Promise<void>;
+    nullifierExists(siloedNullifier: Fr): Promise<boolean>;
+    storageWrite(slot: Fr, value: Fr): Promise<void>;
+    storageRead(slot: Fr, contractAddress: AztecAddress): Promise<Fr>;
+}
+/**
+ * Oracle methods associated with the execution of an Aztec Noir test.
+ */
+export interface ITxeExecutionOracle {
+    isTxe: true;
+    getDefaultAddress(): AztecAddress;
+    getNextBlockNumber(): Promise<BlockNumber>;
+    getNextBlockTimestamp(): Promise<UInt64>;
+    advanceBlocksBy(blocks: number): Promise<void>;
+    advanceTimestampBy(duration: UInt64): void;
+    deploy(artifact: ContractArtifact, instance: ContractInstanceWithAddress, foreignSecret: Fr): Promise<void>;
+    createAccount(secret: Fr): Promise<CompleteAddress>;
+    addAccount(artifact: ContractArtifact, instance: ContractInstanceWithAddress, secret: Fr): Promise<CompleteAddress>;
+    addAuthWitness(address: AztecAddress, messageHash: Fr): Promise<void>;
+    getLastBlockTimestamp(): Promise<bigint>;
+    getLastTxEffects(): Promise<{
+        txHash: TxHash;
+        noteHashes: Fr[];
+        nullifiers: Fr[];
+    }>;
+    getPrivateEvents(selector: EventSelector, contractAddress: AztecAddress, scope: AztecAddress): Promise<Fr[][]>;
+    privateCallNewFlow(from: AztecAddress, targetContractAddress: AztecAddress, functionSelector: FunctionSelector, args: Fr[], argsHash: Fr, isStaticCall: boolean, jobId: string): Promise<Fr[]>;
+    executeUtilityFunction(targetContractAddress: AztecAddress, functionSelector: FunctionSelector, args: Fr[], jobId: string): Promise<Fr[]>;
+    publicCallNewFlow(from: AztecAddress, targetContractAddress: AztecAddress, calldata: Fr[], isStaticCall: boolean): Promise<Fr[]>;
+    syncContractNonOracleMethod(contractAddress: AztecAddress, scope: AztecAddress, jobId: string): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/oracle/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../src/oracle/interfaces.ts"],"names":[],"mappings":"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"}

package/dest/oracle/interfaces.js

@@ -0,0 +1,3 @@
+/**
+ * Oracle methods associated with the execution of an Aztec Noir test.
+ */ export { };

package/dest/oracle/txe_oracle_public_context.d.ts

@@ -0,0 +1,34 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { L2Block } from '@aztec/stdlib/block';
+import { type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import type { IAvmExecutionOracle } from './interfaces.js';
+export declare class TXEOraclePublicContext implements IAvmExecutionOracle {
+    private contractAddress;
+    private forkedWorldTrees;
+    private txRequestHash;
+    private globalVariables;
+    isAvm: true;
+    private logger;
+    private transientUniqueNoteHashes;
+    private transientSiloedNullifiers;
+    private publicDataWrites;
+    constructor(contractAddress: AztecAddress, forkedWorldTrees: MerkleTreeWriteOperations, txRequestHash: Fr, globalVariables: GlobalVariables);
+    address(): Promise<AztecAddress>;
+    sender(): Promise<AztecAddress>;
+    blockNumber(): Promise<BlockNumber>;
+    timestamp(): Promise<bigint>;
+    isStaticCall(): Promise<boolean>;
+    chainId(): Promise<Fr>;
+    version(): Promise<Fr>;
+    emitNullifier(nullifier: Fr): Promise<void>;
+    emitNoteHash(noteHash: Fr): Promise<void>;
+    nullifierExists(siloedNullifier: Fr): Promise<boolean>;
+    storageWrite(slot: Fr, value: Fr): Promise<void>;
+    storageRead(slot: Fr, contractAddress: AztecAddress): Promise<Fr>;
+    close(): Promise<L2Block>;
+    private makeTxEffect;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhlX29yYWNsZV9wdWJsaWNfY29udGV4dC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL29yYWNsZS90eGVfb3JhY2xlX3B1YmxpY19jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM5RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFHcEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQzNELE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRW5ELE9BQU8sRUFFTCxLQUFLLHlCQUF5QixFQUcvQixNQUFNLHFCQUFxQixDQUFDO0FBQzdCLE9BQU8sRUFBRSxlQUFlLEVBQW9CLE1BQU0sa0JBQWtCLENBQUM7QUFHckUsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUzRCxxQkFBYSxzQkFBdUIsWUFBVyxtQkFBbUI7SUFTOUQsT0FBTyxDQUFDLGVBQWU7SUFDdkIsT0FBTyxDQUFDLGdCQUFnQjtJQUN4QixPQUFPLENBQUMsYUFBYTtJQUNyQixPQUFPLENBQUMsZUFBZTtJQVh6QixLQUFLLE9BQWlCO0lBRXRCLE9BQU8sQ0FBQyxNQUFNLENBQVM7SUFDdkIsT0FBTyxDQUFDLHlCQUF5QixDQUFZO0lBQzdDLE9BQU8sQ0FBQyx5QkFBeUIsQ0FBWTtJQUM3QyxPQUFPLENBQUMsZ0JBQWdCLENBQXlCO0lBRWpELFlBQ1UsZUFBZSxFQUFFLFlBQVksRUFDN0IsZ0JBQWdCLEVBQUUseUJBQXlCLEVBQzNDLGFBQWEsRUFBRSxFQUFFLEVBQ2pCLGVBQWUsRUFBRSxlQUFlLEVBU3pDO0lBRUQsT0FBTyxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0FFL0I7SUFFRCxNQUFNLElBQUksT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUU5QjtJQUVELFdBQVcsSUFBSSxPQUFPLENBQUMsV0FBVyxDQUFDLENBRWxDO0lBRUQsU0FBUyxJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FFM0I7SUFFRCxZQUFZLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUUvQjtJQUVELE9BQU8sSUFBSSxPQUFPLENBQUMsRUFBRSxDQUFDLENBRXJCO0lBRUQsT0FBTyxJQUFJLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FFckI7SUFFSyxhQUFhLENBQUMsU0FBUyxFQUFFLEVBQUUsaUJBR2hDO0lBRUssWUFBWSxDQUFDLFFBQVEsRUFBRSxFQUFFLGlCQUk5QjtJQUVLLGVBQWUsQ0FBQyxlQUFlLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FPM0Q7SUFFSyxZQUFZLENBQUMsSUFBSSxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsRUFBRSxpQkFVckM7SUFFSyxXQUFXLENBQUMsSUFBSSxFQUFFLEVBQUUsRUFBRSxlQUFlLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FxQnRFO0lBRUssS0FBSyxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FrQjlCO0lBRUQsT0FBTyxDQUFDLFlBQVk7Q0FhckIifQ==

package/dest/oracle/txe_oracle_public_context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"txe_oracle_public_context.d.ts","sourceRoot":"","sources":["../../src/oracle/txe_oracle_public_context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAGpD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,OAAO,EAEL,KAAK,yBAAyB,EAG/B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAoB,MAAM,kBAAkB,CAAC;AAGrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,qBAAa,sBAAuB,YAAW,mBAAmB;IAS9D,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,eAAe;IAXzB,KAAK,OAAiB;IAEtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,yBAAyB,CAAY;IAC7C,OAAO,CAAC,yBAAyB,CAAY;IAC7C,OAAO,CAAC,gBAAgB,CAAyB;IAEjD,YACU,eAAe,EAAE,YAAY,EAC7B,gBAAgB,EAAE,yBAAyB,EAC3C,aAAa,EAAE,EAAE,EACjB,eAAe,EAAE,eAAe,EASzC;IAED,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CAE/B;IAED,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC,CAE9B;IAED,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC,CAElC;IAED,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAE3B;IAED,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC,CAE/B;IAED,OAAO,IAAI,OAAO,CAAC,EAAE,CAAC,CAErB;IAED,OAAO,IAAI,OAAO,CAAC,EAAE,CAAC,CAErB;IAEK,aAAa,CAAC,SAAS,EAAE,EAAE,iBAGhC;IAEK,YAAY,CAAC,QAAQ,EAAE,EAAE,iBAI9B;IAEK,eAAe,CAAC,eAAe,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAO3D;IAEK,YAAY,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,iBAUrC;IAEK,WAAW,CAAC,IAAI,EAAE,EAAE,EAAE,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC,CAqBtE;IAEK,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAkB9B;IAED,OAAO,CAAC,YAAY;CAarB"}

package/dest/oracle/txe_oracle_public_context.js

@@ -0,0 +1,122 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import { MerkleTreeId, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { TxEffect, TxHash } from '@aztec/stdlib/tx';
+import { insertTxEffectIntoWorldTrees, makeTXEBlock } from '../utils/block_creation.js';
+export class TXEOraclePublicContext {
+    contractAddress;
+    forkedWorldTrees;
+    txRequestHash;
+    globalVariables;
+    isAvm;
+    logger;
+    transientUniqueNoteHashes;
+    transientSiloedNullifiers;
+    publicDataWrites;
+    constructor(contractAddress, forkedWorldTrees, txRequestHash, globalVariables){
+        this.contractAddress = contractAddress;
+        this.forkedWorldTrees = forkedWorldTrees;
+        this.txRequestHash = txRequestHash;
+        this.globalVariables = globalVariables;
+        this.isAvm = true;
+        this.transientUniqueNoteHashes = [];
+        this.transientSiloedNullifiers = [];
+        this.publicDataWrites = [];
+        this.logger = createLogger('txe:public_context');
+        this.logger.debug('Entering Public Context', {
+            contractAddress,
+            blockNumber: globalVariables.blockNumber,
+            timestamp: globalVariables.timestamp
+        });
+    }
+    address() {
+        return Promise.resolve(this.contractAddress);
+    }
+    sender() {
+        return Promise.resolve(AztecAddress.ZERO); // todo: change?
+    }
+    blockNumber() {
+        return Promise.resolve(this.globalVariables.blockNumber);
+    }
+    timestamp() {
+        return Promise.resolve(this.globalVariables.timestamp);
+    }
+    isStaticCall() {
+        return Promise.resolve(false);
+    }
+    chainId() {
+        return Promise.resolve(this.globalVariables.chainId);
+    }
+    version() {
+        return Promise.resolve(this.globalVariables.version);
+    }
+    async emitNullifier(nullifier) {
+        const siloedNullifier = await siloNullifier(this.contractAddress, nullifier);
+        this.transientSiloedNullifiers.push(siloedNullifier);
+    }
+    async emitNoteHash(noteHash) {
+        const siloedNoteHash = await siloNoteHash(this.contractAddress, noteHash);
+        // TODO: make the note hash unique - they are only siloed right now
+        this.transientUniqueNoteHashes.push(siloedNoteHash);
+    }
+    async nullifierExists(siloedNullifier) {
+        const treeIndex = (await this.forkedWorldTrees.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [
+            siloedNullifier.toBuffer()
+        ]))[0];
+        const transientIndex = this.transientSiloedNullifiers.find((n)=>n.equals(siloedNullifier));
+        return treeIndex !== undefined || transientIndex !== undefined;
+    }
+    async storageWrite(slot, value) {
+        this.logger.debug('AVM storage write', {
+            slot,
+            value
+        });
+        const dataWrite = new PublicDataWrite(await computePublicDataTreeLeafSlot(this.contractAddress, slot), value);
+        this.publicDataWrites.push(dataWrite);
+        await this.forkedWorldTrees.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [
+            new PublicDataTreeLeaf(dataWrite.leafSlot, dataWrite.value).toBuffer()
+        ]);
+    }
+    async storageRead(slot, contractAddress) {
+        const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
+        const lowLeafResult = await this.forkedWorldTrees.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
+        const value = !lowLeafResult || !lowLeafResult.alreadyPresent ? Fr.ZERO : (await this.forkedWorldTrees.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index)).leaf.value;
+        this.logger.debug('AVM storage read', {
+            slot,
+            contractAddress,
+            value
+        });
+        return value;
+    }
+    async close() {
+        this.logger.debug('Exiting Public Context, building block with collected side effects', {
+            blockNumber: this.globalVariables.blockNumber
+        });
+        const txEffect = this.makeTxEffect();
+        await insertTxEffectIntoWorldTrees(txEffect, this.forkedWorldTrees);
+        const block = await makeTXEBlock(this.forkedWorldTrees, this.globalVariables, [
+            txEffect
+        ]);
+        await this.forkedWorldTrees.close();
+        this.logger.debug('Exited PublicContext with built block', {
+            blockNumber: block.number,
+            txEffects: block.body.txEffects
+        });
+        return block;
+    }
+    makeTxEffect() {
+        const txEffect = TxEffect.empty();
+        txEffect.noteHashes = this.transientUniqueNoteHashes;
+        txEffect.nullifiers = [
+            this.txRequestHash,
+            ...this.transientSiloedNullifiers
+        ];
+        txEffect.publicDataWrites = this.publicDataWrites;
+        // TODO: support public logs
+        txEffect.txHash = new TxHash(new Fr(this.globalVariables.blockNumber));
+        return txEffect;
+    }
+}