@aztec/simulator 0.0.1-commit.7b97ef96e → 0.0.1-commit.7cbc774

package/src/public/avm/calldata.ts

@@ -33,13 +33,14 @@ export class LazyReaderMemory implements LazyReader {
   }
 
   public slice(start: number, end: number): Fr[] {
-    const clampedEnd = Math.min(end, this.size);
+    const clampedEnd = Math.min(end, this.size, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
     const length = Math.max(0, clampedEnd - start);
     return this.memory.getSlice(this.offset + start, length).map(word => word.toFr());
   }
 
   public readAll(): Fr[] {
-    return this.memory.getSlice(this.offset, this.size).map(word => word.toFr());
+    const size = Math.min(this.size, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
+    return this.memory.getSlice(this.offset, size).map(word => word.toFr());
   }
 
   public length(): number {

package/src/public/avm/fixtures/base_avm_simulation_tester.ts

@@ -2,9 +2,10 @@ import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { getCanonicalAuthRegistry } from '@aztec/protocol-contracts/auth-registry';
+import { getCanonicalClassRegistry } from '@aztec/protocol-contracts/class-registry';
 import { computeFeePayerBalanceStorageSlot, getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
 import { getCanonicalInstanceRegistry } from '@aztec/protocol-contracts/instance-registry';
+import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -91,7 +92,7 @@ export abstract class BaseAvmSimulationTester {
   }
 
   async registerAuthContract(): Promise<ContractInstanceWithAddress> {
-    const authRegistry = await getCanonicalAuthRegistry();
+    const authRegistry = await getStandardAuthRegistry();
     const authRegistryContractClassPublic = {
       ...authRegistry.contractClass,
       privateFunctions: [],
@@ -102,9 +103,28 @@ export abstract class BaseAvmSimulationTester {
       authRegistryContractClassPublic,
       authRegistry.instance,
     );
+    // AuthRegistry is a standard contract (not a protocol contract), so the AVM enforces a
+    // deployment-nullifier check on every instance retrieval. Insert the nullifier here so
+    // calls to AuthRegistry don't EXCEPTIONAL_HALT during simulation.
+    await this.insertContractAddressNullifier(authRegistry.instance.address);
     return authRegistry.instance;
   }
 
+  async registerClassRegistryContract(): Promise<ContractInstanceWithAddress> {
+    const classRegistry = await getCanonicalClassRegistry();
+    const classRegistryContractClassPublic = {
+      ...classRegistry.contractClass,
+      privateFunctions: [],
+      utilityFunctions: [],
+    };
+    await this.contractDataSource.addNewContract(
+      classRegistry.artifact,
+      classRegistryContractClassPublic,
+      classRegistry.instance,
+    );
+    return classRegistry.instance;
+  }
+
   async registerInstanceRegistryContract(): Promise<ContractInstanceWithAddress> {
     const instanceRegistry = await getCanonicalInstanceRegistry();
     const instanceRegistryContractClassPublic = {

package/src/public/avm/fixtures/utils.ts

@@ -128,17 +128,20 @@ export async function createContractClassAndInstance(
   const constructorAbi = getContractFunctionAbi('constructor', contractArtifact);
   const { publicKeys } = await deriveKeys(new Fr(seed));
   const initializationHash = await computeInitializationHash(constructorAbi, constructorArgs);
+  const immutablesHash = new Fr(seed + 1);
   const contractInstance =
     originalContractClassId === undefined
       ? await makeContractInstanceFromClassId(contractClass.id, seed, {
           deployer,
           initializationHash,
+          immutablesHash,
           publicKeys,
         })
       : await makeContractInstanceFromClassId(originalContractClassId, seed, {
           deployer,
           initializationHash,
           currentClassId: contractClass.id,
+          immutablesHash,
           publicKeys,
         });
 

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

@@ -9,6 +9,7 @@ export enum ContractInstanceMember {
   DEPLOYER,
   CLASS_ID,
   INIT_HASH,
+  IMMUTABLES_HASH,
 }
 
 export class GetContractInstance extends Instruction {
@@ -41,7 +42,7 @@ export class GetContractInstance extends Instruction {
     );
 
     if (!(this.memberEnum in ContractInstanceMember)) {
-      throw new InstructionExecutionError(`Invalid GETCONSTRACTINSTANCE member enum ${this.memberEnum}`);
+      throw new InstructionExecutionError(`Invalid GETCONTRACTINSTANCE member enum ${this.memberEnum}`);
     }
 
     const operands = [this.addressOffset, this.dstOffset];
@@ -64,6 +65,9 @@ export class GetContractInstance extends Instruction {
         case ContractInstanceMember.INIT_HASH:
           memberValue = new Field(instance.initializationHash);
           break;
+        case ContractInstanceMember.IMMUTABLES_HASH:
+          memberValue = new Field(instance.immutablesHash);
+          break;
       }
     }
 

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

@@ -2,7 +2,7 @@ import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
 import { Point } from '@aztec/foundation/curves/grumpkin';
 
 import type { AvmContext } from '../avm_context.js';
-import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
+import { Field, TypeTag } from '../avm_memory_types.js';
 import { EcAddPointNotOnCurveError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -18,10 +18,8 @@ export class EcAdd extends Instruction {
     OperandType.UINT16, // indirect
     OperandType.UINT16, // p1X
     OperandType.UINT16, // p1Y
-    OperandType.UINT16, // p1IsInfinite
     OperandType.UINT16, // p2X
     OperandType.UINT16, // p2Y
-    OperandType.UINT16, // p2IsInfinite
     OperandType.UINT16, // dst
   ];
 
@@ -29,10 +27,8 @@ export class EcAdd extends Instruction {
     private addressingMode: number,
     private p1XOffset: number,
     private p1YOffset: number,
-    private p1IsInfiniteOffset: number,
     private p2XOffset: number,
     private p2YOffset: number,
-    private p2IsInfiniteOffset: number,
     private dstOffset: number,
   ) {
     super();
@@ -46,51 +42,38 @@ export class EcAdd extends Instruction {
       this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
     );
 
-    const operands = [
-      this.p1XOffset,
-      this.p1YOffset,
-      this.p1IsInfiniteOffset,
-      this.p2XOffset,
-      this.p2YOffset,
-      this.p2IsInfiniteOffset,
-      this.dstOffset,
-    ];
-    const [p1XOffset, p1YOffset, p1IsInfiniteOffset, p2XOffset, p2YOffset, p2IsInfiniteOffset, dstOffset] =
-      addressing.resolve(operands, memory);
+    const operands = [this.p1XOffset, this.p1YOffset, this.p2XOffset, this.p2YOffset, this.dstOffset];
+    const [p1XOffset, p1YOffset, p2XOffset, p2YOffset, dstOffset] = addressing.resolve(operands, memory);
 
     memory.checkTags(TypeTag.FIELD, p1XOffset, p1YOffset, p2XOffset, p2YOffset);
-    memory.checkTags(TypeTag.UINT1, p1IsInfiniteOffset, p2IsInfiniteOffset);
 
     const p1X = memory.get(p1XOffset);
     const p1Y = memory.get(p1YOffset);
-    const p1IsInfinite = memory.get(p1IsInfiniteOffset).toNumber() === 1;
-    const p1 = new Point(p1X.toFr(), p1Y.toFr(), p1IsInfinite);
-    if (!p1.isOnGrumpkin()) {
+    const p1 = new Point(p1X.toFr(), p1Y.toFr());
+    if (!p1.isOnCurve()) {
       throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 1, p1);
     }
 
     const p2X = memory.get(p2XOffset);
     const p2Y = memory.get(p2YOffset);
-    // unused. Point doesn't store this information
-    const p2IsInfinite = memory.get(p2IsInfiniteOffset).toNumber() === 1;
-    const p2 = new Point(p2X.toFr(), p2Y.toFr(), p2IsInfinite);
-    if (!p2.isOnGrumpkin()) {
+    const p2 = new Point(p2X.toFr(), p2Y.toFr());
+    if (!p2.isOnCurve()) {
       throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 2, p2);
     }
 
     let dest;
-    if (p1IsInfinite && p2IsInfinite) {
-      dest = Point.ZERO;
-    } else if (p1IsInfinite) {
+    if (p1.isInfinite && p2.isInfinite) {
+      dest = Point.INFINITY;
+    } else if (p1.isInfinite) {
       dest = p2;
-    } else if (p2IsInfinite) {
+    } else if (p2.isInfinite) {
       dest = p1;
     } else {
       // TS<>BB ecc add communication is broken for points that add up to infinity.
       // However, here we know that both points are on the curve, and that none is infinity
       // so we can check for the case where you add p + (-p) = infinity.
       if (p1.x.equals(p2.x) && !p1.y.equals(p2.y)) {
-        dest = Point.ZERO;
+        dest = Point.INFINITY;
       } else {
         dest = await Grumpkin.add(p1, p2);
       }
@@ -99,7 +82,5 @@ export class EcAdd extends Instruction {
     // Important to use setSlice() and not set() in the two following statements as
     // this checks that the offsets lie within memory range.
     memory.setSlice(dstOffset, [new Field(dest.x), new Field(dest.y)]);
-    // Check representation of infinity for grumpkin
-    memory.setSlice(dstOffset + 2, [new Uint1(dest.equals(Point.ZERO) ? 1 : 0)]);
   }
 }

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/bulk_test.ts

@@ -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,
@@ -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_tests.ts

@@ -2,7 +2,7 @@ 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, CalldataCopy, Cast, Jump, Return, Set } from '../avm/opcodes/index.js';
 import { encodeToBytecode } from '../avm/serialization/bytecode_serialization.js';
 import {
   MAX_OPCODE_VALUE,
@@ -208,6 +208,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.

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,11 +1,11 @@
-import { DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT } 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';
 import { type ContractArtifact, encodeArguments } from '@aztec/stdlib/abi';
 import { PublicSimulatorConfig, type PublicTxResult } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { Gas, GasFees } from '@aztec/stdlib/gas';
+import { FALLBACK_TEARDOWN_DA_GAS_LIMIT, FALLBACK_TEARDOWN_L2_GAS_LIMIT, Gas, GasFees } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import { PublicCallRequest } from '@aztec/stdlib/kernel';
 import { GlobalVariables, PublicCallRequestWithCalldata, type Tx } from '@aztec/stdlib/tx';
@@ -112,6 +112,7 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     feePayer: AztecAddress = sender,
     /* need some unique first nullifier for note-nonce computations */
     privateInsertions: TestPrivateInsertions = { nonRevertible: { nullifiers: [new Fr(420000 + this.txCount)] } },
+    gasLimits?: Gas,
   ): Promise<Tx> {
     const setupCallRequests = await asyncMap(setupCalls, call =>
       this.#createPubicCallRequestForCall(call, call.sender ?? sender),
@@ -131,9 +132,13 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
       teardownCallRequest,
       feePayer,
       /*gasUsedByPrivate*/ teardownCall
-        ? new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT)
-        : Gas.empty(),
+        ? new Gas(
+            FALLBACK_TEARDOWN_DA_GAS_LIMIT + TX_DA_GAS_OVERHEAD,
+            FALLBACK_TEARDOWN_L2_GAS_LIMIT + PUBLIC_TX_L2_GAS_OVERHEAD,
+          )
+        : new Gas(TX_DA_GAS_OVERHEAD, PUBLIC_TX_L2_GAS_OVERHEAD),
       defaultGlobals(),
+      gasLimits,
     );
   }
 
@@ -146,8 +151,9 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     /* need some unique first nullifier for note-nonce computations */
     privateInsertions?: TestPrivateInsertions,
     txLabel: string = 'unlabeledTx',
+    gasLimits?: Gas,
   ): Promise<PublicTxResult> {
-    const tx = await this.createTx(sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions);
+    const tx = await this.createTx(sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions, gasLimits);
 
     await this.setFeePayerBalance(feePayer);
 
@@ -161,6 +167,8 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     }
     const avmResult = await this.simulator.simulate(tx, fullTxLabel);
 
+    await this.#recordBytecodeSizes(fullTxLabel, [...setupCalls, ...appCalls, ...(teardownCall ? [teardownCall] : [])]);
+
     // Something like this is often useful for debugging:
     //if (avmResult.revertReason) {
     //  // resolve / enrich revert reason
@@ -190,8 +198,18 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     teardownCall?: TestEnqueuedCall,
     feePayer?: AztecAddress,
     privateInsertions?: TestPrivateInsertions,
+    gasLimits?: Gas,
   ): Promise<PublicTxResult> {
-    return await this.simulateTx(sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions, txLabel);
+    return await this.simulateTx(
+      sender,
+      setupCalls,
+      appCalls,
+      teardownCall,
+      feePayer,
+      privateInsertions,
+      txLabel,
+      gasLimits,
+    );
   }
 
   /**
@@ -209,6 +227,7 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     teardownCall?: TestEnqueuedCall,
     feePayer?: AztecAddress,
     privateInsertions?: TestPrivateInsertions,
+    gasLimits?: Gas,
   ): Promise<PublicTxResult> {
     return await this.simulateTxWithLabel(
       txLabel,
@@ -218,6 +237,7 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
       teardownCall,
       feePayer,
       privateInsertions,
+      gasLimits,
     );
   }
 
@@ -277,6 +297,27 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
 
     return new PublicCallRequestWithCalldata(request, calldata);
   }
+
+  // WARNING: Deduplicates by artifact name, so two different artifacts with the same name
+  // in a single tx would only record the first one's bytecode size.
+  async #recordBytecodeSizes(txLabel: string, calls: TestEnqueuedCall[]) {
+    const seenArtifactNames = new Set<string>();
+    for (const call of calls) {
+      const artifact = await this.contractDataSource.getContractArtifact(call.address);
+      if (!artifact || seenArtifactNames.has(artifact.name)) {
+        continue;
+      }
+      seenArtifactNames.add(artifact.name);
+      const instance = await this.contractDataSource.getContract(call.address);
+      if (!instance) {
+        continue;
+      }
+      const contractClass = await this.contractDataSource.getContractClass(instance.currentContractClassId);
+      if (contractClass) {
+        this.metrics.recordBytecodeSize(txLabel, artifact.name, contractClass.packedBytecode.length);
+      }
+    }
+  }
 }
 
 export function defaultGlobals() {