@aztec/simulator 0.0.1-commit.3fd054f6 → 0.0.1-commit.431c48d

package/src/public/avm/opcodes/external_calls.ts

@@ -14,8 +14,8 @@ abstract class ExternalCall extends Instruction {
     OperandType.UINT16, // L2 gas offset
     OperandType.UINT16, // DA gas offset
     OperandType.UINT16, // Address offset
-    OperandType.UINT16, // Args offset
     OperandType.UINT16, // Args size offset
+    OperandType.UINT16, // Args offset
   ];
 
   constructor(

package/src/public/contracts_db_checkpoint.ts

@@ -31,7 +31,7 @@ export class ContractsDbCheckpoint {
     return this.bytecodeCommitments.get(classId.toString());
   }
 
-  public deepCopy(): ContractsDbCheckpoint {
+  public fork(): ContractsDbCheckpoint {
     const copy = new ContractsDbCheckpoint();
     this.instances.forEach((value, key) => copy.instances.set(key, value));
     this.classes.forEach((value, key) => copy.classes.set(key, value));

package/src/public/fixtures/amm_test.ts

@@ -25,8 +25,8 @@ export async function ammTest(
 ) {
   const timer = new Timer();
 
-  const admin = AztecAddress.fromNumber(42);
-  const sender = AztecAddress.fromNumber(111);
+  const admin = AztecAddress.fromNumberUnsafe(42);
+  const sender = AztecAddress.fromNumberUnsafe(111);
 
   logger.debug(`Deploying tokens`);
   const token0 = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue, /*seed=*/ 0);

package/src/public/fixtures/bulk_test.ts

@@ -13,7 +13,7 @@ export async function bulkTest(
 ) {
   const timer = new Timer();
 
-  const deployer = AztecAddress.fromNumber(42);
+  const deployer = AztecAddress.fromNumberUnsafe(42);
   const avmTestContract = await tester.registerAndDeployContract(
     /*constructorArgs=*/ [],
     deployer,
@@ -25,14 +25,26 @@ export async function bulkTest(
   // Register multiple different protocol contracts (to ensure we don't dedup bytecode hashing events):
   await tester.registerAuthContract();
   await tester.registerInstanceRegistryContract();
+  await tester.registerClassRegistryContract();
 
   // Get a deployed contract instance to pass to the contract
   // for it to use as "expected" values when testing contract instance retrieval.
   const expectContractInstance = avmTestContract;
   const argsField = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8].map(x => new Fr(x));
-  argsU8.push(new Fr(2n ** 128n + 9n)); // Trigger truncation from large (> 128 bits) value (canonical decomposition event)
-  argsU8.push(new Fr(2n ** 125n + 10n)); // Trigger truncation from small (< 128 bits) value (no canonical decomposition event)
+  const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  // Pinned grumpkin-Poseidon2 Schnorr signature (mirrors the C++ `pinned_test_vector_large`
+  // and noir-lang/schnorr v0.4.0's `pinned_vector_large`). Passing these in as calldata
+  // (rather than baking them into Noir as constants) keeps MSM + Poseidon2 from being folded
+  // by the Noir compiler.
+  const schnorrInputs = [
+    Fr.fromHexString('0x065812e335a97c2108ea8cf4ccfe2f9dd6b117a0714f5e18461575be93f61da6'), // pubkey.x
+    Fr.fromHexString('0x1a915003e8ec534f9a15d926a7ded478e178468ccc4f28e236e67450a55ac622'), // pubkey.y
+    Fr.fromHexString('0xf3bc3b7147acb9c621fd9f72dbf15ffa'), // sig_s.lo
+    Fr.fromHexString('0x08599f379f0301dfefdbd0272554454d'), // sig_s.hi
+    Fr.fromHexString('0x97065383ebbbd76620398792bd259bc2'), // sig_e.lo
+    Fr.fromHexString('0x2ceaee87f45b7a417f0ffb05451a8c92'), // sig_e.hi
+    Fr.fromHexString('0x0123456789abcdef0fedcba9876543210123456789abcdef0fedcba987654321'), // message
+  ];
   const args = [
     argsField,
     argsU8,
@@ -40,6 +52,8 @@ export async function bulkTest(
     /*expectedDeployer=*/ expectContractInstance.deployer,
     /*expectedClassId=*/ expectContractInstance.currentContractClassId,
     /*expectedInitializationHash=*/ expectContractInstance.initializationHash,
+    /*expectedImmutablesHash=*/ expectContractInstance.immutablesHash,
+    /*schnorrInputs=*/ schnorrInputs,
     /*skip_strictly_limited_side_effects=*/ false,
   ];
 
@@ -62,7 +76,7 @@ export async function bulkTest(
       {
         address: avmTestContract.address,
         fnName: 'assert_calldata_copy',
-        args: [argsField.slice(3), /* with_selector: */ true],
+        args: [argsField.slice(0, 3), /* with_selector: */ true],
       },
       {
         address: avmTestContract.address,
@@ -100,7 +114,7 @@ export async function megaBulkTest(
 ) {
   const timer = new Timer();
 
-  const deployer = AztecAddress.fromNumber(42);
+  const deployer = AztecAddress.fromNumberUnsafe(42);
   const avmTestContract = await tester.registerAndDeployContract(
     /*constructorArgs=*/ [],
     deployer,
@@ -123,6 +137,15 @@ export async function megaBulkTest(
   //const argsField7 = [15, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
   //const argsField8 = [17, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
   const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const schnorrInputs = [
+    Fr.fromHexString('0x065812e335a97c2108ea8cf4ccfe2f9dd6b117a0714f5e18461575be93f61da6'), // pubkey.x
+    Fr.fromHexString('0x1a915003e8ec534f9a15d926a7ded478e178468ccc4f28e236e67450a55ac622'), // pubkey.y
+    Fr.fromHexString('0xf3bc3b7147acb9c621fd9f72dbf15ffa'), // sig_s.lo
+    Fr.fromHexString('0x08599f379f0301dfefdbd0272554454d'), // sig_s.hi
+    Fr.fromHexString('0x97065383ebbbd76620398792bd259bc2'), // sig_e.lo
+    Fr.fromHexString('0x2ceaee87f45b7a417f0ffb05451a8c92'), // sig_e.hi
+    Fr.fromHexString('0x0123456789abcdef0fedcba9876543210123456789abcdef0fedcba987654321'), // message
+  ];
   const genArgs = (argsField: Fr[]) => [
     argsField,
     argsU8,
@@ -130,6 +153,8 @@ export async function megaBulkTest(
     /*expectedDeployer=*/ expectContractInstance.deployer.toField(),
     /*expectedClassId=*/ expectContractInstance.currentContractClassId.toField(),
     /*expectedInitializationHash=*/ expectContractInstance.initializationHash.toField(),
+    /*expectedImmutablesHash=*/ expectContractInstance.immutablesHash.toField(),
+    /*schnorrInputs=*/ schnorrInputs,
     // Must skip strictly limited side effects (logs, messages) so we can spam the bulk test several times.
     /*skip_strictly_limited_side_effects=*/ true,
   ];

package/src/public/fixtures/custom_bytecode_tester.ts

@@ -17,7 +17,7 @@ export async function deployCustomBytecode(
   bytecode: Buffer,
   tester: PublicTxSimulationTester,
   contractName: string = 'CustomBytecodeContract',
-  deployer: AztecAddress = AztecAddress.fromNumber(42),
+  deployer: AztecAddress = AztecAddress.fromNumberUnsafe(42),
 ): Promise<ContractInstanceWithAddress> {
   const contractArtifact = emptyContractArtifact();
   contractArtifact.name = contractName;
@@ -75,7 +75,7 @@ export async function deployAndExecuteCustomBytecode(
   tester: PublicTxSimulationTester,
   txLabel: string = 'CustomBytecodeTest',
   contractName: string = 'CustomBytecodeContract',
-  deployer: AztecAddress = AztecAddress.fromNumber(42),
+  deployer: AztecAddress = AztecAddress.fromNumberUnsafe(42),
   calldata: any[] = [],
 ): Promise<PublicTxResult> {
   const testContract = await deployCustomBytecode(bytecode, tester, contractName, deployer);

package/src/public/fixtures/custom_bytecode_tests.ts

@@ -1,8 +1,10 @@
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
 import { strict as assert } from 'assert';
 
 import { TypeTag } from '../avm/avm_memory_types.js';
 import { Addressing, AddressingMode } from '../avm/opcodes/addressing_mode.js';
-import { Add, CalldataCopy, Jump, Return, Set } from '../avm/opcodes/index.js';
+import { Add, Call, CalldataCopy, Cast, Jump, Return, Set, Sha256Compression, Xor } from '../avm/opcodes/index.js';
 import { encodeToBytecode } from '../avm/serialization/bytecode_serialization.js';
 import {
   MAX_OPCODE_VALUE,
@@ -10,7 +12,7 @@ import {
   OperandType,
   getOperandSize,
 } from '../avm/serialization/instruction_serialization.js';
-import { deployAndExecuteCustomBytecode } from './custom_bytecode_tester.js';
+import { deployAndExecuteCustomBytecode, deployCustomBytecode } from './custom_bytecode_tester.js';
 import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
 
 // First instruction resolved a base address (offset 0) which is uninitialized and therefore
@@ -208,6 +210,144 @@ export async function invalidTagValueAndInstructionTruncatedTest(tester: PublicT
   return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
 }
 
+// Exercise SET truncation: set values whose widths exceed the target tag and
+// rely on `buildFromTagTruncating` to truncate to the low bits of the tag.
+// Covers sources larger than 128 bits (via SET_FF) and sources in (32, 128]
+// bits (via SET_64) against destination tags U1/U8/U16/U32/U64/U128.
+export async function setTruncationTest(tester: PublicTxSimulationTester) {
+  // 200-bit value: forces truncation for every target tag up to U128.
+  const LARGE_FIELD_VALUE = (1n << 200n) + 0x1234567890abcdef1234567890abcdefn;
+  // 40-bit value: forces truncation for target tags up to U32.
+  const LARGE_U64_VALUE = (1n << 40n) + 0xdeadbeefn;
+
+  const bytecode = encodeToBytecode([
+    // Zero U32 at offset 0 — used as the Return copy-size slot.
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8),
+
+    // Source >128 bits (via SET_FF) truncated to smaller target tags.
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 1, TypeTag.UINT128, LARGE_FIELD_VALUE).as(
+      Opcode.SET_FF,
+      Set.wireFormatFF,
+    ),
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 2, TypeTag.UINT64, LARGE_FIELD_VALUE).as(
+      Opcode.SET_FF,
+      Set.wireFormatFF,
+    ),
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 3, TypeTag.UINT32, LARGE_FIELD_VALUE).as(
+      Opcode.SET_FF,
+      Set.wireFormatFF,
+    ),
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 4, TypeTag.UINT16, LARGE_FIELD_VALUE).as(
+      Opcode.SET_FF,
+      Set.wireFormatFF,
+    ),
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 5, TypeTag.UINT8, LARGE_FIELD_VALUE).as(
+      Opcode.SET_FF,
+      Set.wireFormatFF,
+    ),
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 6, TypeTag.UINT1, LARGE_FIELD_VALUE).as(
+      Opcode.SET_FF,
+      Set.wireFormatFF,
+    ),
+
+    // Source in (32, 128] bits (via SET_64) truncated to smaller target tags.
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 7, TypeTag.UINT32, LARGE_U64_VALUE).as(
+      Opcode.SET_64,
+      Set.wireFormat64,
+    ),
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 8, TypeTag.UINT16, LARGE_U64_VALUE).as(
+      Opcode.SET_64,
+      Set.wireFormat64,
+    ),
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 9, TypeTag.UINT8, LARGE_U64_VALUE).as(
+      Opcode.SET_64,
+      Set.wireFormat64,
+    ),
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 10, TypeTag.UINT1, LARGE_U64_VALUE).as(
+      Opcode.SET_64,
+      Set.wireFormat64,
+    ),
+
+    new Return(/*addressing_mode=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0),
+  ]);
+
+  const txLabel = 'SetTruncation';
+  return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+
+// Exercise CAST truncation: store a wide source value in memory then CAST it
+// to smaller destination tags. Covers sources larger than 128 bits (FIELD
+// source) and sources in (32, 128] bits (UINT64 source) against destination
+// tags U1/U8/U16/U32/U64/U128.
+export async function castTruncationTest(tester: PublicTxSimulationTester) {
+  // 200-bit source: stored as FIELD so that CASTs to any integer tag truncate.
+  const LARGE_FIELD_VALUE = (1n << 200n) + 0x1234567890abcdef1234567890abcdefn;
+  // 40-bit source: stored as UINT64 so CASTs to U1/U8/U16/U32 truncate.
+  const LARGE_U64_VALUE = (1n << 40n) + 0xdeadbeefn;
+
+  const bytecode = encodeToBytecode([
+    // Zero U32 at offset 0 — used as the Return copy-size slot.
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8),
+
+    // Store wide FIELD source at offset 10, then CAST to smaller tags.
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 10, TypeTag.FIELD, LARGE_FIELD_VALUE).as(
+      Opcode.SET_FF,
+      Set.wireFormatFF,
+    ),
+    new Cast(/*addressing_mode=*/ 0, /*srcOffset=*/ 10, /*dstOffset=*/ 11, TypeTag.UINT128).as(
+      Opcode.CAST_8,
+      Cast.wireFormat8,
+    ),
+    new Cast(/*addressing_mode=*/ 0, /*srcOffset=*/ 10, /*dstOffset=*/ 12, TypeTag.UINT64).as(
+      Opcode.CAST_8,
+      Cast.wireFormat8,
+    ),
+    new Cast(/*addressing_mode=*/ 0, /*srcOffset=*/ 10, /*dstOffset=*/ 13, TypeTag.UINT32).as(
+      Opcode.CAST_8,
+      Cast.wireFormat8,
+    ),
+    new Cast(/*addressing_mode=*/ 0, /*srcOffset=*/ 10, /*dstOffset=*/ 14, TypeTag.UINT16).as(
+      Opcode.CAST_8,
+      Cast.wireFormat8,
+    ),
+    new Cast(/*addressing_mode=*/ 0, /*srcOffset=*/ 10, /*dstOffset=*/ 15, TypeTag.UINT8).as(
+      Opcode.CAST_8,
+      Cast.wireFormat8,
+    ),
+    new Cast(/*addressing_mode=*/ 0, /*srcOffset=*/ 10, /*dstOffset=*/ 16, TypeTag.UINT1).as(
+      Opcode.CAST_8,
+      Cast.wireFormat8,
+    ),
+
+    // Store UINT64 source at offset 20, then CAST to smaller integer tags.
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 20, TypeTag.UINT64, LARGE_U64_VALUE).as(
+      Opcode.SET_64,
+      Set.wireFormat64,
+    ),
+    new Cast(/*addressing_mode=*/ 0, /*srcOffset=*/ 20, /*dstOffset=*/ 21, TypeTag.UINT32).as(
+      Opcode.CAST_8,
+      Cast.wireFormat8,
+    ),
+    new Cast(/*addressing_mode=*/ 0, /*srcOffset=*/ 20, /*dstOffset=*/ 22, TypeTag.UINT16).as(
+      Opcode.CAST_8,
+      Cast.wireFormat8,
+    ),
+    new Cast(/*addressing_mode=*/ 0, /*srcOffset=*/ 20, /*dstOffset=*/ 23, TypeTag.UINT8).as(
+      Opcode.CAST_8,
+      Cast.wireFormat8,
+    ),
+    new Cast(/*addressing_mode=*/ 0, /*srcOffset=*/ 20, /*dstOffset=*/ 24, TypeTag.UINT1).as(
+      Opcode.CAST_8,
+      Cast.wireFormat8,
+    ),
+
+    new Return(/*addressing_mode=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0),
+  ]);
+
+  const txLabel = 'CastTruncation';
+  return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+
 /**
  * Returns the offset of the tag in an instruction.
  * @details Loops over the wire format operand type entries until it finds the tag.
@@ -226,3 +366,70 @@ function getTagOffsetInInstruction(wireFormat: OperandType[]): number {
   }
   return offset;
 }
+
+export async function deployBitwiseSha256ErrorRowCollisionContracts(
+  tester: PublicTxSimulationTester,
+): Promise<{ innerContract: ContractInstanceWithAddress; outerContract: ContractInstanceWithAddress }> {
+  const innerBytecode = encodeToBytecode([
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8),
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 1, TypeTag.UINT16, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8),
+    new Xor(/*addressing_mode=*/ 0, /*aOffset=*/ 0, /*bOffset=*/ 1, /*dstOffset=*/ 2).as(Opcode.XOR_8, Xor.wireFormat8),
+    new Return(/*addressing_mode=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0),
+  ]);
+
+  const outerInstructions = [
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8),
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 1, TypeTag.UINT32, /*value=*/ 1).as(Opcode.SET_8, Set.wireFormat8),
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 2, TypeTag.UINT32, /*value=*/ 100_000).as(
+      Opcode.SET_32,
+      Set.wireFormat32,
+    ),
+    new CalldataCopy(/*addressing_mode=*/ 0, /*copySizeOffset=*/ 1, /*cdStartOffset=*/ 0, /*dstOffset=*/ 3),
+    new Call(
+      /*addressing_mode=*/ 0,
+      /*l2GasOffset=*/ 2,
+      /*daGasOffset=*/ 2,
+      /*addrOffset=*/ 3,
+      /*argsSizeOffset=*/ 0,
+      /*argsOffset=*/ 0,
+    ),
+  ];
+
+  for (let i = 0; i < 8; i++) {
+    outerInstructions.push(
+      new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 10 + i, TypeTag.UINT32, /*value=*/ 0).as(
+        Opcode.SET_8,
+        Set.wireFormat8,
+      ),
+    );
+  }
+
+  outerInstructions.push(
+    new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 18, TypeTag.UINT32, /*value=*/ 0x61626364).as(
+      Opcode.SET_32,
+      Set.wireFormat32,
+    ),
+  );
+
+  for (let i = 0; i < 15; i++) {
+    outerInstructions.push(
+      new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 19 + i, TypeTag.UINT32, /*value=*/ 0).as(
+        Opcode.SET_8,
+        Set.wireFormat8,
+      ),
+    );
+  }
+
+  outerInstructions.push(
+    new Sha256Compression(/*addressing_mode=*/ 0, /*outputOffset=*/ 34, /*stateOffset=*/ 10, /*inputsOffset=*/ 18),
+    new Return(/*addressing_mode=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0),
+  );
+
+  const innerContract = await deployCustomBytecode(innerBytecode, tester, 'BitwiseSha256CollisionInner');
+  const outerContract = await deployCustomBytecode(
+    encodeToBytecode(outerInstructions),
+    tester,
+    'BitwiseSha256CollisionOuter',
+  );
+  return { innerContract, outerContract };
+}

package/src/public/fixtures/opcode_spammer.ts

@@ -1339,20 +1339,16 @@ export const SPAM_CONFIGS: Partial<Record<Opcode, SpamConfig[]>> = {
       setup: [
         { offset: 0, value: new Field(Grumpkin.generator.x) }, // p1X = G.x
         { offset: 1, value: new Field(Grumpkin.generator.y) }, // p1Y = G.y
-        { offset: 2, value: new Uint1(0n) }, // p1IsInfinite = false
-        { offset: 3, value: new Field(Grumpkin.generator.x) }, // p2X = G.x
-        { offset: 4, value: new Field(Grumpkin.generator.y) }, // p2Y = G.y
-        { offset: 5, value: new Uint1(0n) }, // p2IsInfinite = false
+        { offset: 2, value: new Field(Grumpkin.generator.x) }, // p2X = G.x
+        { offset: 3, value: new Field(Grumpkin.generator.y) }, // p2Y = G.y
       ],
       targetInstructions: () => [
         new EcAdd(
           /*addressing_mode=*/ 0,
           /*p1XOffset=*/ 0,
           /*p1YOffset=*/ 1,
-          /*p1IsInfiniteOffset=*/ 2,
-          /*p2XOffset=*/ 3,
-          /*p2YOffset=*/ 4,
-          /*p2IsInfiniteOffset=*/ 5,
+          /*p2XOffset=*/ 2,
+          /*p2YOffset=*/ 3,
           /*dstOffset=*/ 0,
         ),
       ],

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -1,9 +1,4 @@
-import {
-  DEFAULT_TEARDOWN_DA_GAS_LIMIT,
-  DEFAULT_TEARDOWN_L2_GAS_LIMIT,
-  PUBLIC_TX_L2_GAS_OVERHEAD,
-  TX_DA_GAS_OVERHEAD,
-} from '@aztec/constants';
+import { PUBLIC_TX_L2_GAS_OVERHEAD, TX_DA_GAS_OVERHEAD } from '@aztec/constants';
 import { asyncMap } from '@aztec/foundation/async-map';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -32,6 +27,8 @@ import { SimpleContractDataSource } from './simple_contract_data_source.js';
 import { type TestPrivateInsertions, createTxForPublicCalls } from './utils.js';
 
 const DEFAULT_GAS_FEES = new GasFees(2, 3);
+const TEARDOWN_DA_GAS_LIMIT = 98_304;
+const TEARDOWN_L2_GAS_LIMIT = 817_500;
 
 export type TestEnqueuedCall = {
   sender?: AztecAddress;
@@ -137,10 +134,7 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
       teardownCallRequest,
       feePayer,
       /*gasUsedByPrivate*/ teardownCall
-        ? new Gas(
-            DEFAULT_TEARDOWN_DA_GAS_LIMIT + TX_DA_GAS_OVERHEAD,
-            DEFAULT_TEARDOWN_L2_GAS_LIMIT + PUBLIC_TX_L2_GAS_OVERHEAD,
-          )
+        ? new Gas(TEARDOWN_DA_GAS_LIMIT + TX_DA_GAS_OVERHEAD, TEARDOWN_L2_GAS_LIMIT + PUBLIC_TX_L2_GAS_OVERHEAD)
         : new Gas(TX_DA_GAS_OVERHEAD, PUBLIC_TX_L2_GAS_OVERHEAD),
       defaultGlobals(),
       gasLimits,

package/src/public/fixtures/token_test.ts

@@ -21,9 +21,9 @@ export async function tokenTest(
 ) {
   const timer = new Timer();
 
-  const admin = AztecAddress.fromNumber(42);
-  const sender = AztecAddress.fromNumber(111);
-  const receiver = AztecAddress.fromNumber(222);
+  const admin = AztecAddress.fromNumberUnsafe(42);
+  const sender = AztecAddress.fromNumberUnsafe(111);
+  const receiver = AztecAddress.fromNumberUnsafe(222);
 
   const token = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue);
 

package/src/public/fixtures/utils.ts

@@ -2,10 +2,8 @@ import {
   CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE,
   CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
   CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
-  DEFAULT_DA_GAS_LIMIT,
-  DEFAULT_L2_GAS_LIMIT,
-  DEFAULT_TEARDOWN_DA_GAS_LIMIT,
-  DEFAULT_TEARDOWN_L2_GAS_LIMIT,
+  MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT,
+  MAX_PROCESSABLE_L2_GAS,
   PRIVATE_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -38,6 +36,9 @@ import {
 
 import { strict as assert } from 'assert';
 
+const TEARDOWN_DA_GAS_LIMIT = 98_304;
+const TEARDOWN_L2_GAS_LIMIT = 817_500;
+
 export type TestPrivateInsertions = {
   revertible?: {
     nullifiers?: Fr[];
@@ -69,7 +70,7 @@ export async function createTxForPublicCalls(
     "Can't create public tx with no enqueued calls",
   );
   // use max limits
-  gasLimits = gasLimits ?? new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
+  gasLimits = gasLimits ?? new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
 
   const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
 
@@ -128,9 +129,7 @@ export async function createTxForPublicCalls(
   }
 
   const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
-  const teardownGasLimits = teardownCallRequest
-    ? new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT)
-    : Gas.empty();
+  const teardownGasLimits = teardownCallRequest ? new Gas(TEARDOWN_DA_GAS_LIMIT, 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 header = BlockHeader.empty({ globalVariables: globals });
@@ -164,7 +163,7 @@ export async function createTxForPrivateOnly(
   gasUsedByPrivate: Gas = new Gas(10, 10),
 ): Promise<Tx> {
   // use max limits
-  const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
+  const gasLimits = new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
 
   const forRollup = PartialPrivateTailPublicInputsForRollup.empty();
 
@@ -229,17 +228,15 @@ export async function addNewContractInstanceToTx(
   contractInstance: ContractInstanceWithAddress,
   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 logFields = [
     CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG,
@@ -248,6 +245,7 @@ export async function addNewContractInstanceToTx(
     new Fr(contractInstance.salt),
     contractInstance.currentContractClassId,
     contractInstance.initializationHash,
+    contractInstance.immutablesHash,
     ...publicKeysAsFields,
     contractInstance.deployer.toField(),
   ];
@@ -257,7 +255,7 @@ export async function addNewContractInstanceToTx(
   );
 
   const contractAddressNullifier = await siloNullifier(
-    AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
+    AztecAddress.fromNumberUnsafe(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
     contractInstance.address.toField(),
   );
 

package/src/public/hinting_db_sources.ts

@@ -83,6 +83,7 @@ export class HintingPublicContractsDB implements PublicContractsDBInterface {
           instance.currentContractClassId,
           instance.originalContractClassId,
           instance.initializationHash,
+          instance.immutablesHash,
           instance.publicKeys,
         ),
       );

package/src/public/public_db_sources.ts

@@ -55,7 +55,8 @@ export class PublicContractsDB implements PublicContractsDBInterface {
     this.log = createLogger('simulator:contracts-data-source', bindings);
   }
 
-  public addContracts(contractDeploymentData: ContractDeploymentData): void {
+  /** Parses raw log data from the C++/NAPI bridge and inserts the resulting contracts into the current checkpoint. */
+  public addContractsFromLogs(contractDeploymentData: ContractDeploymentData): void {
     const currentState = this.getCurrentState();
 
     this.addContractClassesFromEvents(
@@ -71,8 +72,16 @@ export class PublicContractsDB implements PublicContractsDBInterface {
 
   public addNewContracts(tx: Tx): void {
     const contractDeploymentData = AllContractDeploymentData.fromTx(tx);
-    this.addContracts(contractDeploymentData.getNonRevertibleContractDeploymentData());
-    this.addContracts(contractDeploymentData.getRevertibleContractDeploymentData());
+    this.addContractsFromLogs(contractDeploymentData.getNonRevertibleContractDeploymentData());
+    this.addContractsFromLogs(contractDeploymentData.getRevertibleContractDeploymentData());
+  }
+
+  /** Inserts typed contract instances directly into the current checkpoint. */
+  public addContracts(contractInstances?: ContractInstanceWithAddress[]): void {
+    const currentState = this.getCurrentState();
+    for (const instance of contractInstances ?? []) {
+      currentState.addInstance(instance.address, instance);
+    }
   }
 
   /**
@@ -81,7 +90,7 @@ export class PublicContractsDB implements PublicContractsDBInterface {
    */
   public createCheckpoint(): void {
     const currentState = this.getCurrentState();
-    const newState = currentState.deepCopy();
+    const newState = currentState.fork();
     this.contractStateStack.push(newState);
   }