@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.017a351

package/dest/public/fixtures/utils.d.ts

@@ -1,13 +1,26 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { Gas } from '@aztec/stdlib/gas';
-import { type PublicExecutionRequest, Tx } from '@aztec/stdlib/tx';
+import type { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
+import { GlobalVariables, PublicCallRequestWithCalldata, Tx } from '@aztec/stdlib/tx';
+export type TestPrivateInsertions = {
+    revertible?: {
+        nullifiers?: Fr[];
+        noteHashes?: Fr[];
+        l2ToL1Msgs?: ScopedL2ToL1Message[];
+    };
+    nonRevertible?: {
+        nullifiers?: Fr[];
+        noteHashes?: Fr[];
+        l2ToL1Msgs?: ScopedL2ToL1Message[];
+    };
+};
 /**
  * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
  */
-export declare function createTxForPublicCalls(firstNullifier: Fr, setupExecutionRequests: PublicExecutionRequest[], appExecutionRequests: PublicExecutionRequest[], teardownExecutionRequest?: PublicExecutionRequest, feePayer?: AztecAddress, gasUsedByPrivate?: Gas): Promise<Tx>;
-export declare function createTxForPrivateOnly(feePayer?: AztecAddress, gasUsedByPrivate?: Gas): Tx;
+export declare function createTxForPublicCalls(privateInsertions: TestPrivateInsertions, setupCallRequests: PublicCallRequestWithCalldata[], appCallRequests: PublicCallRequestWithCalldata[], teardownCallRequest?: PublicCallRequestWithCalldata, feePayer?: AztecAddress, gasUsedByPrivate?: Gas, globals?: GlobalVariables, gasLimits?: Gas): Promise<Tx>;
+export declare function createTxForPrivateOnly(feePayer?: AztecAddress, gasUsedByPrivate?: Gas): Promise<Tx>;
 export declare function addNewContractClassToTx(tx: Tx, contractClass: ContractClassPublic, skipNullifierInsertion?: boolean): Promise<void>;
 export declare function addNewContractInstanceToTx(tx: Tx, contractInstance: ContractInstanceWithAddress, skipNullifierInsertion?: boolean): Promise<void>;
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaWMvZml4dHVyZXMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBR3BELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRCxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQy9GLE9BQU8sRUFHTCxHQUFHLEVBR0osTUFBTSxtQkFBbUIsQ0FBQztBQVUzQixPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRW5FLE9BQU8sRUFFTCxlQUFlLEVBRWYsNkJBQTZCLEVBQzdCLEVBQUUsRUFHSCxNQUFNLGtCQUFrQixDQUFDO0FBSTFCLE1BQU0sTUFBTSxxQkFBcUIsR0FBRztJQUNsQyxVQUFVLENBQUMsRUFBRTtRQUNYLFVBQVUsQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDO1FBQ2xCLFVBQVUsQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDO1FBQ2xCLFVBQVUsQ0FBQyxFQUFFLG1CQUFtQixFQUFFLENBQUM7S0FDcEMsQ0FBQztJQUNGLGFBQWEsQ0FBQyxFQUFFO1FBQ2QsVUFBVSxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUM7UUFDbEIsVUFBVSxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUM7UUFDbEIsVUFBVSxDQUFDLEVBQUUsbUJBQW1CLEVBQUUsQ0FBQztLQUNwQyxDQUFDO0NBQ0gsQ0FBQztBQUVGOztHQUVHO0FBQ0gsd0JBQXNCLHNCQUFzQixDQUMxQyxpQkFBaUIsRUFBRSxxQkFBcUIsRUFDeEMsaUJBQWlCLEVBQUUsNkJBQTZCLEVBQUUsRUFDbEQsZUFBZSxFQUFFLDZCQUE2QixFQUFFLEVBQ2hELG1CQUFtQixDQUFDLEVBQUUsNkJBQTZCLEVBQ25ELFFBQVEsZUFBc0IsRUFDOUIsZ0JBQWdCLEdBQUUsR0FBaUIsRUFDbkMsT0FBTyxHQUFFLGVBQXlDLEVBQ2xELFNBQVMsQ0FBQyxFQUFFLEdBQUcsR0FDZCxPQUFPLENBQUMsRUFBRSxDQUFDLENBOEZiO0FBRUQsd0JBQXNCLHNCQUFzQixDQUMxQyxRQUFRLGVBQXNCLEVBQzlCLGdCQUFnQixHQUFFLEdBQXFCLEdBQ3RDLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0EwQmI7QUFFRCx3QkFBc0IsdUJBQXVCLENBQzNDLEVBQUUsRUFBRSxFQUFFLEVBQ04sYUFBYSxFQUFFLG1CQUFtQixFQUNsQyxzQkFBc0IsVUFBUSxpQkE2Qi9CO0FBRUQsd0JBQXNCLDBCQUEwQixDQUM5QyxFQUFFLEVBQUUsRUFBRSxFQUNOLGdCQUFnQixFQUFFLDJCQUEyQixFQUM3QyxzQkFBc0IsVUFBUSxpQkF5Qy9CIn0=

package/dest/public/fixtures/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/utils.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC/F,OAAO,EAAE,GAAG,EAAwB,MAAM,mBAAmB,CAAC;AAW9D,OAAO,EAAE,KAAK,sBAAsB,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAKnE;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,cAAc,EAAE,EAAE,EAClB,sBAAsB,EAAE,sBAAsB,EAAE,EAChD,oBAAoB,EAAE,sBAAsB,EAAE,EAC9C,wBAAwB,CAAC,EAAE,sBAAsB,EACjD,QAAQ,eAAsB,EAC9B,gBAAgB,GAAE,GAAiB,GAClC,OAAO,CAAC,EAAE,CAAC,CAkDb;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,eAAsB,EAAE,gBAAgB,GAAE,GAAqB,GAAG,EAAE,CAoBlH;AAED,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,EAAE,EACN,aAAa,EAAE,mBAAmB,EAClC,sBAAsB,UAAQ,iBAiC/B;AAED,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,EAAE,EACN,gBAAgB,EAAE,2BAA2B,EAC7C,sBAAsB,UAAQ,iBA0C/B"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/utils.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAGpD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC/F,OAAO,EAGL,GAAG,EAGJ,MAAM,mBAAmB,CAAC;AAU3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,EAEL,eAAe,EAEf,6BAA6B,EAC7B,EAAE,EAGH,MAAM,kBAAkB,CAAC;AAI1B,MAAM,MAAM,qBAAqB,GAAG;IAClC,UAAU,CAAC,EAAE;QACX,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;KACpC,CAAC;IACF,aAAa,CAAC,EAAE;QACd,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;KACpC,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,iBAAiB,EAAE,qBAAqB,EACxC,iBAAiB,EAAE,6BAA6B,EAAE,EAClD,eAAe,EAAE,6BAA6B,EAAE,EAChD,mBAAmB,CAAC,EAAE,6BAA6B,EACnD,QAAQ,eAAsB,EAC9B,gBAAgB,GAAE,GAAiB,EACnC,OAAO,GAAE,eAAyC,EAClD,SAAS,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,EAAE,CAAC,CA8Fb;AAED,wBAAsB,sBAAsB,CAC1C,QAAQ,eAAsB,EAC9B,gBAAgB,GAAE,GAAqB,GACtC,OAAO,CAAC,EAAE,CAAC,CA0Bb;AAED,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,EAAE,EACN,aAAa,EAAE,mBAAmB,EAClC,sBAAsB,UAAQ,iBA6B/B;AAED,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,EAAE,EACN,gBAAgB,EAAE,2BAA2B,EAC7C,sBAAsB,UAAQ,iBAyC/B"}

package/dest/public/fixtures/utils.js

@@ -1,84 +1,130 @@
-import { CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, DEFAULT_GAS_LIMIT, DEPLOYER_CONTRACT_ADDRESS, MAX_L2_GAS_PER_TX_PUBLIC_PORTION, PRIVATE_LOG_SIZE_IN_FIELDS, REGISTERER_CONTRACT_ADDRESS, REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { assertLength } from '@aztec/foundation/serialize';
-import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '@aztec/protocol-contracts';
+import { CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE, CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG } from '@aztec/protocol-contracts';
 import { bufferAsFields } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
+import { FALLBACK_TEARDOWN_DA_GAS_LIMIT, FALLBACK_TEARDOWN_L2_GAS_LIMIT, Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
 import { siloNullifier } from '@aztec/stdlib/hash';
-import { PartialPrivateTailPublicInputsForPublic, PartialPrivateTailPublicInputsForRollup, PrivateKernelTailCircuitPublicInputs, RollupValidationRequests, ScopedLogHash, countAccumulatedItems } from '@aztec/stdlib/kernel';
-import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
-import { Tx } from '@aztec/stdlib/tx';
-import { BlockHeader, TxConstantData, TxContext } from '@aztec/stdlib/tx';
+import { LogHash, PartialPrivateTailPublicInputsForPublic, PartialPrivateTailPublicInputsForRollup, PrivateKernelTailCircuitPublicInputs, countAccumulatedItems } from '@aztec/stdlib/kernel';
+import { ContractClassLogFields, PrivateLog } from '@aztec/stdlib/logs';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { BlockHeader, GlobalVariables, HashedValues, Tx, TxConstantData, TxContext } from '@aztec/stdlib/tx';
 import { strict as assert } from 'assert';
 /**
  * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
- */ export async function createTxForPublicCalls(firstNullifier, setupExecutionRequests, appExecutionRequests, teardownExecutionRequest, feePayer = AztecAddress.zero(), gasUsedByPrivate = Gas.empty()) {
-    assert(setupExecutionRequests.length > 0 || appExecutionRequests.length > 0 || teardownExecutionRequest !== undefined, "Can't create public tx with no enqueued calls");
-    const setupCallRequests = await Promise.all(setupExecutionRequests.map((er)=>er.toCallRequest()));
-    const appCallRequests = await Promise.all(appExecutionRequests.map((er)=>er.toCallRequest()));
+ */ export async function createTxForPublicCalls(privateInsertions, setupCallRequests, appCallRequests, teardownCallRequest, feePayer = AztecAddress.zero(), gasUsedByPrivate = Gas.empty(), globals = GlobalVariables.empty(), gasLimits) {
+    assert(setupCallRequests.length > 0 || appCallRequests.length > 0 || teardownCallRequest !== undefined, "Can't create public tx with no enqueued calls");
     // use max limits
-    const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
+    gasLimits = gasLimits ?? new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
     const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
-    // TODO(#9269): Remove this fake nullifier method as we move away from 1st nullifier as hash.
-    forPublic.nonRevertibleAccumulatedData.nullifiers[0] = firstNullifier;
-    // We reverse order because the simulator expects it to be like a "stack" of calls to pop from
-    for(let i = setupCallRequests.length - 1; i >= 0; i--){
-        forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i];
+    // Non revertible private insertions
+    if (!privateInsertions.nonRevertible?.nullifiers?.length) {
+        throw new Error('At least one non-revertible nullifier is required');
     }
-    for(let i = appCallRequests.length - 1; i >= 0; i--){
-        forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i];
+    for(let i = 0; i < privateInsertions.nonRevertible.nullifiers.length; i++){
+        assert(i < forPublic.nonRevertibleAccumulatedData.nullifiers.length, 'Nullifier index out of bounds');
+        forPublic.nonRevertibleAccumulatedData.nullifiers[i] = privateInsertions.nonRevertible.nullifiers[i];
     }
-    if (teardownExecutionRequest) {
-        forPublic.publicTeardownCallRequest = await teardownExecutionRequest.toCallRequest();
+    if (privateInsertions.nonRevertible.noteHashes) {
+        for(let i = 0; i < privateInsertions.nonRevertible.noteHashes.length; i++){
+            assert(i < forPublic.nonRevertibleAccumulatedData.noteHashes.length, 'Note hash index out of bounds');
+            forPublic.nonRevertibleAccumulatedData.noteHashes[i] = privateInsertions.nonRevertible.noteHashes[i];
+        }
+    }
+    if (privateInsertions.nonRevertible.l2ToL1Msgs) {
+        for(let i = 0; i < privateInsertions.nonRevertible.l2ToL1Msgs.length; i++){
+            assert(i < forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs.length, 'L2 to L1 message index out of bounds');
+            forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs[i] = privateInsertions.nonRevertible.l2ToL1Msgs[i];
+        }
+    }
+    // Revertible private insertions
+    if (privateInsertions.revertible) {
+        if (privateInsertions.revertible.noteHashes) {
+            for(let i = 0; i < privateInsertions.revertible.noteHashes.length; i++){
+                assert(i < forPublic.revertibleAccumulatedData.noteHashes.length, 'Note hash index out of bounds');
+                forPublic.revertibleAccumulatedData.noteHashes[i] = privateInsertions.revertible.noteHashes[i];
+            }
+        }
+        if (privateInsertions.revertible.nullifiers) {
+            for(let i = 0; i < privateInsertions.revertible.nullifiers.length; i++){
+                assert(i < forPublic.revertibleAccumulatedData.nullifiers.length, 'Nullifier index out of bounds');
+                forPublic.revertibleAccumulatedData.nullifiers[i] = privateInsertions.revertible.nullifiers[i];
+            }
+        }
+        if (privateInsertions.revertible.l2ToL1Msgs) {
+            for(let i = 0; i < privateInsertions.revertible.l2ToL1Msgs.length; i++){
+                assert(i < forPublic.revertibleAccumulatedData.l2ToL1Msgs.length, 'L2 to L1 message index out of bounds');
+                forPublic.revertibleAccumulatedData.l2ToL1Msgs[i] = privateInsertions.revertible.l2ToL1Msgs[i];
+            }
+        }
+    }
+    for(let i = 0; i < setupCallRequests.length; i++){
+        forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i].request;
+    }
+    for(let i = 0; i < appCallRequests.length; i++){
+        forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i].request;
+    }
+    if (teardownCallRequest) {
+        forPublic.publicTeardownCallRequest = teardownCallRequest.request;
     }
     const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
-    const teardownGasLimits = teardownExecutionRequest ? gasLimits : Gas.empty();
+    const teardownGasLimits = teardownCallRequest ? new Gas(FALLBACK_TEARDOWN_DA_GAS_LIMIT, FALLBACK_TEARDOWN_L2_GAS_LIMIT) : Gas.empty();
     const gasSettings = new GasSettings(gasLimits, teardownGasLimits, maxFeesPerGas, GasFees.empty());
     const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
-    const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
-    const txData = new PrivateKernelTailCircuitPublicInputs(constantData, RollupValidationRequests.empty(), /*gasUsed=*/ gasUsedByPrivate, feePayer, forPublic);
-    const tx = Tx.newWithTxData(txData, teardownExecutionRequest);
-    // Reverse order because the simulator expects it to be like a "stack" of calls to pop from.
-    // Also push app calls before setup calls for this reason.
-    for(let i = appExecutionRequests.length - 1; i >= 0; i--){
-        tx.enqueuedPublicFunctionCalls.push(appExecutionRequests[i]);
-    }
-    for(let i = setupExecutionRequests.length - 1; i >= 0; i--){
-        tx.enqueuedPublicFunctionCalls.push(setupExecutionRequests[i]);
-    }
-    return tx;
+    const header = BlockHeader.empty({
+        globalVariables: globals
+    });
+    const constantData = new TxConstantData(header, txContext, Fr.zero(), Fr.zero());
+    const expirationTimestamp = 0n; // Not used in the simulator.
+    const txData = new PrivateKernelTailCircuitPublicInputs(constantData, /*gasUsed=*/ gasUsedByPrivate, feePayer, expirationTimestamp, forPublic);
+    const calldata = [
+        ...setupCallRequests,
+        ...appCallRequests,
+        ...teardownCallRequest ? [
+            teardownCallRequest
+        ] : []
+    ].map((r)=>new HashedValues(r.calldata, r.request.calldataHash));
+    return await Tx.create({
+        data: txData,
+        chonkProof: ChonkProof.random(),
+        contractClassLogFields: [],
+        publicFunctionCalldata: calldata
+    });
 }
-export function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedByPrivate = new Gas(10, 10)) {
+export async function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedByPrivate = new Gas(10, 10)) {
     // use max limits
-    const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
+    const gasLimits = new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
     const forRollup = PartialPrivateTailPublicInputsForRollup.empty();
     const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
     const gasSettings = new GasSettings(gasLimits, Gas.empty(), maxFeesPerGas, GasFees.empty());
     const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
     const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
-    const txData = new PrivateKernelTailCircuitPublicInputs(constantData, RollupValidationRequests.empty(), /*gasUsed=*/ gasUsedByPrivate, feePayer, /*forPublic=*/ undefined, forRollup);
-    return Tx.newWithTxData(txData);
+    const expirationTimestamp = 0n; // Not used in the simulator.
+    const txData = new PrivateKernelTailCircuitPublicInputs(constantData, /*gasUsed=*/ gasUsedByPrivate, feePayer, expirationTimestamp, /*forPublic=*/ undefined, forRollup);
+    return await Tx.create({
+        data: txData,
+        chonkProof: ChonkProof.empty(),
+        contractClassLogFields: [],
+        publicFunctionCalldata: []
+    });
 }
 export async function addNewContractClassToTx(tx, contractClass, skipNullifierInsertion = false) {
     const contractClassLogFields = [
-        new Fr(REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE),
+        new Fr(CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE),
         contractClass.id,
         new Fr(contractClass.version),
         new Fr(contractClass.artifactHash),
         new Fr(contractClass.privateFunctionsRoot),
         ...bufferAsFields(contractClass.packedBytecode, Math.ceil(contractClass.packedBytecode.length / 31) + 1)
     ];
-    const contractClassLog = ContractClassLog.fromFields([
-        new Fr(REGISTERER_CONTRACT_ADDRESS),
-        ...contractClassLogFields.concat(new Array(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS - contractClassLogFields.length).fill(Fr.ZERO))
-    ]);
-    const contractClassLogHash = ScopedLogHash.fromFields([
-        await contractClassLog.hash(),
-        new Fr(7),
-        new Fr(contractClassLog.getEmittedLength()),
-        new Fr(REGISTERER_CONTRACT_ADDRESS)
-    ]);
+    const contractAddress = new AztecAddress(new Fr(CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS));
+    const emittedLength = contractClassLogFields.length;
+    const logFields = ContractClassLogFields.fromEmittedFields(contractClassLogFields);
+    const contractClassLogHash = LogHash.from({
+        value: await logFields.hash(),
+        length: emittedLength
+    }).scope(contractAddress);
     const accumulatedData = tx.data.forPublic ? tx.data.forPublic.revertibleAccumulatedData : tx.data.forRollup.end;
     if (!skipNullifierInsertion) {
         const nextNullifierIndex = countAccumulatedItems(accumulatedData.nullifiers);
@@ -86,36 +132,32 @@ export async function addNewContractClassToTx(tx, contractClass, skipNullifierIn
     }
     const nextLogIndex = countAccumulatedItems(accumulatedData.contractClassLogsHashes);
     accumulatedData.contractClassLogsHashes[nextLogIndex] = contractClassLogHash;
-    tx.contractClassLogs.push(contractClassLog);
+    tx.contractClassLogFields.push(logFields);
 }
 export async function addNewContractInstanceToTx(tx, contractInstance, skipNullifierInsertion = false) {
-    // can't use publicKeys.toFields() because it includes isInfinite which
-    // is not broadcast in such private logs
+    // Only ivpk_m is broadcast as a point (x, y); the other five keys are hashes.
     const publicKeysAsFields = [
-        contractInstance.publicKeys.masterNullifierPublicKey.x,
-        contractInstance.publicKeys.masterNullifierPublicKey.y,
-        contractInstance.publicKeys.masterIncomingViewingPublicKey.x,
-        contractInstance.publicKeys.masterIncomingViewingPublicKey.y,
-        contractInstance.publicKeys.masterOutgoingViewingPublicKey.x,
-        contractInstance.publicKeys.masterOutgoingViewingPublicKey.y,
-        contractInstance.publicKeys.masterTaggingPublicKey.x,
-        contractInstance.publicKeys.masterTaggingPublicKey.y
+        contractInstance.publicKeys.npkMHash,
+        contractInstance.publicKeys.ivpkM.x,
+        contractInstance.publicKeys.ivpkM.y,
+        contractInstance.publicKeys.ovpkMHash,
+        contractInstance.publicKeys.tpkMHash,
+        contractInstance.publicKeys.mspkMHash,
+        contractInstance.publicKeys.fbpkMHash
     ];
-    const fields = [
-        DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG,
+    const logFields = [
+        CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG,
         contractInstance.address.toField(),
         new Fr(contractInstance.version),
         new Fr(contractInstance.salt),
         contractInstance.currentContractClassId,
         contractInstance.initializationHash,
+        contractInstance.immutablesHash,
         ...publicKeysAsFields,
-        contractInstance.deployer.toField(),
-        new Fr(0),
-        new Fr(0),
-        new Fr(0)
+        contractInstance.deployer.toField()
     ];
-    const contractInstanceLog = new PrivateLog(assertLength(fields, PRIVATE_LOG_SIZE_IN_FIELDS));
-    const contractAddressNullifier = await siloNullifier(AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS), contractInstance.address.toField());
+    const contractInstanceLog = new PrivateLog(padArrayEnd(logFields, Fr.ZERO, PRIVATE_LOG_SIZE_IN_FIELDS), logFields.length);
+    const contractAddressNullifier = await siloNullifier(AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS), contractInstance.address.toField());
     const accumulatedData = tx.data.forPublic ? tx.data.forPublic.revertibleAccumulatedData : tx.data.forRollup.end;
     if (!skipNullifierInsertion) {
         const nextNullifierIndex = countAccumulatedItems(accumulatedData.nullifiers);

package/dest/public/fuzzing/avm_fuzzer_simulator.d.ts

@@ -0,0 +1,60 @@
+import { AvmTxHint, type PublicTxResult } from '@aztec/stdlib/avm';
+import { type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { GlobalVariables, ProtocolContracts } from '@aztec/stdlib/tx';
+import type { NativeWorldStateService } from '@aztec/world-state';
+import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
+import { SimpleContractDataSource } from '../fixtures/simple_contract_data_source.js';
+/**
+ * Request structure for fuzzer simulation communication from C++.
+ * Matches the C++ FuzzerSimulationRequest struct
+ */
+export declare class FuzzerSimulationRequest {
+    readonly wsDataDir: string;
+    readonly wsMapSizeKb: number;
+    readonly tx: AvmTxHint;
+    readonly globals: GlobalVariables;
+    readonly contractClasses: any[];
+    readonly contractInstances: [any, any][];
+    readonly publicDataWrites: any[];
+    readonly noteHashes: any[];
+    readonly protocolContracts: ProtocolContracts;
+    constructor(wsDataDir: string, wsMapSizeKb: number, tx: AvmTxHint, globals: GlobalVariables, contractClasses: any[], contractInstances: [any, any][], publicDataWrites: any[], noteHashes: any[], protocolContracts: ProtocolContracts);
+    static fromPlainObject(obj: any): FuzzerSimulationRequest;
+}
+/**
+ * A simulator class for the AVM fuzzer that extends BaseAvmSimulationTester.
+ * It provides methods for registering contracts from C++ msgpack data and simulating transactions.
+ */
+export declare class AvmFuzzerSimulator extends BaseAvmSimulationTester {
+    private simulator;
+    constructor(merkleTrees: MerkleTreeWriteOperations, contractDataSource: SimpleContractDataSource, globals: GlobalVariables, protocolContracts: ProtocolContracts);
+    /**
+     * Static factory method to create an AvmFuzzerSimulator.
+     */
+    static create(worldStateService: NativeWorldStateService, globals: GlobalVariables, protocolContracts: ProtocolContracts): Promise<AvmFuzzerSimulator>;
+    /**
+     * Simulate a transaction from a C++ AvmTxHint.
+     */
+    simulate(txHint: AvmTxHint): Promise<PublicTxResult>;
+    /**
+     * Add a contract class from C++ raw msgpack data.
+     */
+    addContractClassFromCpp(rawClass: any): Promise<void>;
+    /**
+     * Add a contract instance from C++ raw msgpack data.
+     * This also inserts the contract address nullifier into the nullifier tree,
+     * unless the address is a protocol canonical address (1-11).
+     */
+    addContractInstanceFromCpp(rawAddress: any, rawInstance: any): Promise<void>;
+    /**
+     * Apply public data tree writes from C++ raw msgpack data.
+     * This is used to pre-populate the public data tree before simulation (e.g., for bytecode upgrades).
+     */
+    applyPublicDataWrites(rawWrites: any[]): Promise<void>;
+    /**
+     * Apply note hashes from C++ raw msgpack data.
+     * This is used to pre-populate the note hash tree before simulation.
+     */
+    applyNoteHashes(rawNoteHashes: any[]): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/public/fuzzing/avm_fuzzer_simulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_fuzzer_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/fuzzing/avm_fuzzer_simulator.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAYnE,OAAO,EAAgB,KAAK,yBAAyB,EAAsB,MAAM,qBAAqB,CAAC;AACvG,OAAO,EAEL,eAAe,EAEf,iBAAiB,EAKlB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,OAAO,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AACxF,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AAItF;;;GAGG;AACH,qBAAa,uBAAuB;aAEhB,SAAS,EAAE,MAAM;aACjB,WAAW,EAAE,MAAM;aACnB,EAAE,EAAE,SAAS;aACb,OAAO,EAAE,eAAe;aACxB,eAAe,EAAE,GAAG,EAAE;aACtB,iBAAiB,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;aAC/B,gBAAgB,EAAE,GAAG,EAAE;aACvB,UAAU,EAAE,GAAG,EAAE;aACjB,iBAAiB,EAAE,iBAAiB;IATtD,YACkB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,SAAS,EACb,OAAO,EAAE,eAAe,EACxB,eAAe,EAAE,GAAG,EAAE,EACtB,iBAAiB,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAC/B,gBAAgB,EAAE,GAAG,EAAE,EACvB,UAAU,EAAE,GAAG,EAAE,EACjB,iBAAiB,EAAE,iBAAiB,EAClD;IAEJ,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,uBAAuB,CAexD;CACF;AAmHD;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,uBAAuB;IAC7D,OAAO,CAAC,SAAS,CAAoB;IAErC,YACE,WAAW,EAAE,yBAAyB,EACtC,kBAAkB,EAAE,wBAAwB,EAC5C,OAAO,EAAE,eAAe,EACxB,iBAAiB,EAAE,iBAAiB,EAiBrC;IAED;;OAEG;IACH,OAAoB,MAAM,CACxB,iBAAiB,EAAE,uBAAuB,EAC1C,OAAO,EAAE,eAAe,EACxB,iBAAiB,EAAE,iBAAiB,GACnC,OAAO,CAAC,kBAAkB,CAAC,CAI7B;IAED;;OAEG;IACU,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,cAAc,CAAC,CAUhE;IAED;;OAEG;IACU,uBAAuB,CAAC,QAAQ,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjE;IAED;;;;OAIG;IACU,0BAA0B,CAAC,UAAU,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAMxF;IAED;;;OAGG;IACU,qBAAqB,CAAC,SAAS,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAKlE;IAED;;;OAGG;IACU,eAAe,CAAC,aAAa,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhE;CACF"}

package/dest/public/fuzzing/avm_fuzzer_simulator.js

@@ -0,0 +1,171 @@
+import { MAX_ENQUEUED_CALLS_PER_TX, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PRIVATE_LOGS_PER_TX, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { AvmTxHint } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { contractClassPublicFromPlainObject, contractInstanceWithAddressFromPlainObject } from '@aztec/stdlib/contract';
+import { PartialPrivateTailPublicInputsForPublic, PrivateKernelTailCircuitPublicInputs, PrivateToPublicAccumulatedData, PublicCallRequest } from '@aztec/stdlib/kernel';
+import { PrivateLog } from '@aztec/stdlib/logs';
+import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { MerkleTreeId, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { BlockHeader, GlobalVariables, HashedValues, ProtocolContracts, Tx, TxConstantData, TxContext, TxHash } from '@aztec/stdlib/tx';
+import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
+import { SimpleContractDataSource } from '../fixtures/simple_contract_data_source.js';
+import { PublicContractsDB } from '../public_db_sources.js';
+import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
+/**
+ * Request structure for fuzzer simulation communication from C++.
+ * Matches the C++ FuzzerSimulationRequest struct
+ */ export class FuzzerSimulationRequest {
+    wsDataDir;
+    wsMapSizeKb;
+    tx;
+    globals;
+    contractClasses;
+    contractInstances;
+    publicDataWrites;
+    noteHashes;
+    protocolContracts;
+    constructor(wsDataDir, wsMapSizeKb, tx, globals, contractClasses, contractInstances, publicDataWrites, noteHashes, protocolContracts){
+        this.wsDataDir = wsDataDir;
+        this.wsMapSizeKb = wsMapSizeKb;
+        this.tx = tx;
+        this.globals = globals;
+        this.contractClasses = contractClasses;
+        this.contractInstances = contractInstances;
+        this.publicDataWrites = publicDataWrites;
+        this.noteHashes = noteHashes;
+        this.protocolContracts = protocolContracts;
+    }
+    static fromPlainObject(obj) {
+        if (obj instanceof FuzzerSimulationRequest) {
+            return obj;
+        }
+        return new FuzzerSimulationRequest(obj.wsDataDir, obj.wsMapSizeKb, AvmTxHint.fromPlainObject(obj.tx), GlobalVariables.fromPlainObject(obj.globals), obj.contractClasses, obj.contractInstances, obj.publicDataWrites ?? [], obj.noteHashes ?? [], ProtocolContracts.fromPlainObject(obj.protocolContracts));
+    }
+}
+/**
+ * Creates a TypeScript Tx object from a deserialized C++ Tx (AvmTxHint-like structure).
+ * This allows using PublicTxSimulator.simulate() with fuzzer-generated transactions.
+ */ async function createTxFromHint(cppTx) {
+    // Create TxHash from the C++ tx hash string
+    if (!cppTx.hash) {
+        throw new Error(`cppTx.hash is undefined. Keys: ${Object.keys(cppTx || {}).join(', ')}`);
+    }
+    const txHash = TxHash.fromString(cppTx.hash);
+    // Extract PublicCallRequest instances from enqueued calls
+    const setupCallRequests = cppTx.setupEnqueuedCalls.map((call)=>call.request);
+    const paddedSetupCalls = padArrayEnd(setupCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX);
+    const appLogicCallRequests = cppTx.appLogicEnqueuedCalls.map((call)=>call.request);
+    const paddedAppLogicCalls = padArrayEnd(appLogicCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX);
+    // Build non-revertible accumulated data from C++ tx
+    const emptyNonRevertible = PrivateToPublicAccumulatedData.empty();
+    const nonRevertibleAccumulatedData = new PrivateToPublicAccumulatedData(padArrayEnd(cppTx.nonRevertibleAccumulatedData.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX), padArrayEnd(cppTx.nonRevertibleAccumulatedData.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX), padArrayEnd(cppTx.nonRevertibleAccumulatedData.l2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX), padArrayEnd(cppTx.nonRevertibleContractDeploymentData.privateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX), emptyNonRevertible.contractClassLogsHashes, paddedSetupCalls);
+    // Build revertible accumulated data from C++ tx
+    const emptyRevertible = PrivateToPublicAccumulatedData.empty();
+    const revertibleAccumulatedData = new PrivateToPublicAccumulatedData(padArrayEnd(cppTx.revertibleAccumulatedData.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX), padArrayEnd(cppTx.revertibleAccumulatedData.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX), padArrayEnd(cppTx.revertibleAccumulatedData.l2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX), padArrayEnd(cppTx.revertibleContractDeploymentData.privateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX), emptyRevertible.contractClassLogsHashes, paddedAppLogicCalls);
+    // Build teardown call request (if exists)
+    const teardownCallRequest = cppTx.teardownEnqueuedCall?.request ?? PublicCallRequest.empty();
+    // Create forPublic structure
+    const forPublic = new PartialPrivateTailPublicInputsForPublic(nonRevertibleAccumulatedData, revertibleAccumulatedData, teardownCallRequest);
+    // Build TxContext - gasSettings is already a proper GasSettings after AvmTxHint.fromPlainObject
+    const txContext = new TxContext(Fr.ZERO, Fr.ZERO, cppTx.gasSettings);
+    // Build TxConstantData
+    const constants = new TxConstantData(BlockHeader.empty(), txContext, Fr.ZERO, Fr.ZERO);
+    const data = new PrivateKernelTailCircuitPublicInputs(constants, cppTx.gasUsedByPrivate, cppTx.feePayer, 0n, forPublic, undefined);
+    // Build publicFunctionCalldata from all enqueued calls
+    // Calldata is already Fr[] after AvmTxHint.fromPlainObject
+    const publicFunctionCalldata = [];
+    // Add setup calls
+    for (const call of cppTx.setupEnqueuedCalls || []){
+        publicFunctionCalldata.push(await HashedValues.fromCalldata(call.calldata));
+    }
+    // Add app logic calls
+    for (const call of cppTx.appLogicEnqueuedCalls || []){
+        publicFunctionCalldata.push(await HashedValues.fromCalldata(call.calldata));
+    }
+    // Add teardown call if present
+    if (cppTx.teardownEnqueuedCall) {
+        publicFunctionCalldata.push(await HashedValues.fromCalldata(cppTx.teardownEnqueuedCall.calldata));
+    }
+    // Extract contract class log fields from ContractDeploymentData
+    const contractClassLogFields = [
+        ...cppTx.nonRevertibleContractDeploymentData.contractClassLogs.map((log)=>log.fields),
+        ...cppTx.revertibleContractDeploymentData.contractClassLogs.map((log)=>log.fields)
+    ];
+    // Create the Tx
+    return new Tx(txHash, data, ChonkProof.empty(), contractClassLogFields, publicFunctionCalldata);
+}
+/**
+ * A simulator class for the AVM fuzzer that extends BaseAvmSimulationTester.
+ * It provides methods for registering contracts from C++ msgpack data and simulating transactions.
+ */ export class AvmFuzzerSimulator extends BaseAvmSimulationTester {
+    simulator;
+    constructor(merkleTrees, contractDataSource, globals, protocolContracts){
+        super(contractDataSource, merkleTrees);
+        const contractsDb = new PublicContractsDB(contractDataSource);
+        this.simulator = new PublicTxSimulator(merkleTrees, contractsDb, globals, {
+            skipFeeEnforcement: false,
+            collectDebugLogs: false,
+            collectHints: false,
+            collectStatistics: false,
+            collectCallMetadata: false
+        }, protocolContracts);
+    }
+    /**
+   * Static factory method to create an AvmFuzzerSimulator.
+   */ static async create(worldStateService, globals, protocolContracts) {
+        const contractDataSource = new SimpleContractDataSource();
+        const merkleTrees = await worldStateService.fork();
+        return new AvmFuzzerSimulator(merkleTrees, contractDataSource, globals, protocolContracts);
+    }
+    /**
+   * Simulate a transaction from a C++ AvmTxHint.
+   */ async simulate(txHint) {
+        // Compute fee from gas limits and max fees per gas (upper bound on fee)
+        const totalFee = BigInt(txHint.gasSettings.gasLimits.daGas) * txHint.gasSettings.maxFeesPerGas.feePerDaGas + BigInt(txHint.gasSettings.gasLimits.l2Gas) * txHint.gasSettings.maxFeesPerGas.feePerL2Gas;
+        await this.setFeePayerBalance(txHint.feePayer, new Fr(totalFee));
+        const tx = await createTxFromHint(txHint);
+        return await this.simulator.simulate(tx);
+    }
+    /**
+   * Add a contract class from C++ raw msgpack data.
+   */ async addContractClassFromCpp(rawClass) {
+        const contractClass = contractClassPublicFromPlainObject(rawClass);
+        await this.contractDataSource.addContractClass(contractClass);
+    }
+    /**
+   * Add a contract instance from C++ raw msgpack data.
+   * This also inserts the contract address nullifier into the nullifier tree,
+   * unless the address is a protocol canonical address (1-11).
+   */ async addContractInstanceFromCpp(rawAddress, rawInstance) {
+        const address = AztecAddress.fromPlainObject(rawAddress);
+        const instance = contractInstanceWithAddressFromPlainObject(address, rawInstance);
+        // Protocol canonical addresses (1-11) should not have nullifiers inserted
+        const isProtocolCanonicalAddress = address.toBigInt() <= MAX_PROTOCOL_CONTRACTS && address.toBigInt() >= 1n;
+        await this.addContractInstance(instance, /* skipNullifierInsertion */ isProtocolCanonicalAddress);
+    }
+    /**
+   * Apply public data tree writes from C++ raw msgpack data.
+   * This is used to pre-populate the public data tree before simulation (e.g., for bytecode upgrades).
+   */ async applyPublicDataWrites(rawWrites) {
+        for (const rawWrite of rawWrites){
+            const leaf = PublicDataTreeLeaf.fromPlainObject(rawWrite);
+            await this.merkleTrees.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [
+                leaf.toBuffer()
+            ]);
+        }
+    }
+    /**
+   * Apply note hashes from C++ raw msgpack data.
+   * This is used to pre-populate the note hash tree before simulation.
+   */ async applyNoteHashes(rawNoteHashes) {
+        const paddingLeaves = MAX_NOTE_HASHES_PER_TX - rawNoteHashes.length % MAX_NOTE_HASHES_PER_TX;
+        const paddedNoteHashes = [
+            ...rawNoteHashes,
+            ...Array(paddingLeaves).fill(Fr.ZERO)
+        ];
+        await this.merkleTrees.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, paddedNoteHashes);
+    }
+}

package/dest/public/fuzzing/avm_simulator_bin.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZtX3NpbXVsYXRvcl9iaW4uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaWMvZnV6emluZy9hdm1fc2ltdWxhdG9yX2Jpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/public/fuzzing/avm_simulator_bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_simulator_bin.d.ts","sourceRoot":"","sources":["../../../src/public/fuzzing/avm_simulator_bin.ts"],"names":[],"mappings":""}