@aztec/simulator 0.0.1-commit.0208eb9 → 0.0.1-commit.031e54b

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

@@ -0,0 +1,166 @@
+/**
+ * Fetches an account proof from the Ethereum mainnet and saves it as account_proof.json.
+ * This script is not using any Aztec library code, so it's easily portable.
+ */
+import fs from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { createPublicClient, fromRlp, hexToBytes, http } from 'viem';
+import { mainnet } from 'viem/chains';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const RPC_URL = process.env.RPC_URL;
+const ADDRESS = (process.env.ADDRESS || '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045') as `0x${string}`;
+const BLOCK_TAG = process.env.BLOCK_NUMBER ? BigInt(process.env.BLOCK_NUMBER) : 'latest';
+const MAX_ACCOUNT_PATH = 15;
+
+function padTo(arr: number[], len: number) {
+  return [...arr, ...Array(len - arr.length).fill(0)].slice(0, len);
+}
+
+function toBytes(hex: `0x${string}`) {
+  return Array.from(hexToBytes(hex));
+}
+
+function bytesToU64s(bytes: number[]) {
+  const paddedBytes = padTo(bytes, 32);
+  return Array.from({ length: 4 }, (_, i) => {
+    let val = 0n;
+    for (let j = 0; j < 8; j++) {
+      val += BigInt(paddedBytes[i * 8 + j]) << BigInt(j * 8);
+    }
+    return val.toString();
+  });
+}
+
+function toBytesAndLen(val: bigint | number) {
+  if (val === 0n || val === 0) {
+    return { bytes: [0], length: 0 };
+  }
+  let hex = val.toString(16);
+  if (hex.length % 2) {
+    hex = '0' + hex;
+  }
+  const bytes = toBytes(`0x${hex}`);
+  return { bytes, length: bytes.length };
+}
+
+function parseNode(rlp: `0x${string}`) {
+  // Should be safe when working with branches and extensions without embedded children.
+  const decoded = fromRlp(rlp) as `0x${string}`[];
+  const node = {
+    rows: Array(16)
+      .fill(0)
+      .map(() => Array(32).fill(0)),
+    row_exist: Array(16).fill(false),
+    node_type: 0,
+  };
+
+  if (decoded.length === 17) {
+    for (let i = 0; i < 16; i++) {
+      if (decoded[i] !== '0x') {
+        node.row_exist[i] = true;
+        node.rows[i] = padTo(toBytes(decoded[i]), 32);
+      }
+    }
+  } else if (decoded.length === 2) {
+    const keyBytes = toBytes(decoded[0]);
+    const prefix = keyBytes[0];
+    if (prefix >> 4 >= 2) {
+      throw new Error('Unsupported: leaf node in proof path');
+    }
+    node.node_type = 1;
+    // Extension header format expected by the noir code: check out storage_proof types.nr.
+    node.rows[0][0] = prefix >> 4;
+    node.rows[0][8] = prefix & 0x0f;
+    node.rows[0][16] = keyBytes.length - 1;
+
+    for (let i = 1; i < keyBytes.length && i < 32; i++) {
+      node.rows[1][i - 1] = keyBytes[i];
+    }
+    node.rows[2] = padTo(toBytes(decoded[1]), 32);
+    node.row_exist[0] = node.row_exist[1] = node.row_exist[2] = true;
+  }
+  return node;
+}
+
+function parseProof(proof: `0x${string}`[], maxLen: number) {
+  const nodes = proof.slice(0, -1).slice(0, maxLen).map(parseNode);
+  while (nodes.length < maxLen) {
+    nodes.push({
+      rows: Array(16)
+        .fill(0)
+        .map(() => Array(32).fill(0)),
+      row_exist: Array(16).fill(false),
+      node_type: 0,
+    });
+  }
+  return nodes;
+}
+
+function nodeToLibFormat(node: { rows: number[][]; row_exist: boolean[]; node_type: number }) {
+  return {
+    rows: node.rows.map(bytesToU64s),
+    row_exist: node.row_exist,
+    node_type: String(node.node_type),
+  };
+}
+
+async function main() {
+  if (!RPC_URL) {
+    throw new Error('RPC_URL is not set');
+  }
+  console.log(`Fetching account proof for ${ADDRESS}`);
+
+  const client = createPublicClient({
+    chain: mainnet,
+    transport: http(RPC_URL),
+  });
+
+  const [blockNumber, proof, block] = await Promise.all([
+    client.getBlockNumber(),
+    client.getProof({
+      address: ADDRESS,
+      storageKeys: [],
+      blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG,
+    }),
+    client.getBlock({
+      blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG,
+    }),
+  ]);
+
+  console.log(`Block: ${blockNumber}, Account nodes: ${proof.accountProof.length}`);
+
+  // The -1 is because the last node in the proof is the leaf, which is excluded from path verification.
+  const accountPathLen = proof.accountProof.length - 1;
+  if (accountPathLen > MAX_ACCOUNT_PATH) {
+    throw new Error(
+      `Account proof path length ${accountPathLen} exceeds MAX_ACCOUNT_PATH ${MAX_ACCOUNT_PATH}. Increase the limit.`,
+    );
+  }
+
+  const nonce = toBytesAndLen(proof.nonce);
+  const balance = toBytesAndLen(proof.balance);
+
+  const data = {
+    block_number: String(blockNumber),
+    node_length: String(accountPathLen),
+    root: bytesToU64s(toBytes(block.stateRoot)),
+    nodes: parseProof(proof.accountProof, MAX_ACCOUNT_PATH).map(nodeToLibFormat),
+    account: {
+      address: toBytes(ADDRESS).map(String),
+      balance: padTo(balance.bytes, 32).map(String),
+      balance_length: String(balance.length),
+      code_hash: bytesToU64s(toBytes(proof.codeHash)),
+      nonce: padTo(nonce.bytes, 8).map(String),
+      nonce_length: String(nonce.length),
+      storage_hash: bytesToU64s(toBytes(proof.storageHash)),
+    },
+  };
+
+  fs.writeFileSync(join(__dirname, 'account_proof.json'), JSON.stringify(data, null, 2));
+  console.log('account_proof.json generated');
+}
+
+main().catch(console.error);

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

@@ -204,10 +204,9 @@ export class L1ToL2MessageExists extends Instruction {
   }
 }
 
-export class EmitUnencryptedLog extends Instruction {
-  // TODO(#11124): rename unencrypted -> public
-  static type: string = 'EMITUNENCRYPTEDLOG';
-  static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
+export class EmitPublicLog extends Instruction {
+  static type: string = 'EMITPUBLICLOG';
+  static readonly opcode: Opcode = Opcode.EMITPUBLICLOG;
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 

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/avm/serialization/bytecode_serialization.ts

@@ -19,7 +19,7 @@ import {
   EcAdd,
   EmitNoteHash,
   EmitNullifier,
-  EmitUnencryptedLog,
+  EmitPublicLog,
   Eq,
   FieldDiv,
   GetContractInstance,
@@ -129,7 +129,7 @@ export const INSTRUCTION_SET = new Map<Opcode, InstructionDeserializer>([
   [L1ToL2MessageExists.opcode, Instruction.fromBuffer.bind(L1ToL2MessageExists)], // Messages
 
   // Accrued Substate
-  [EmitUnencryptedLog.opcode, Instruction.fromBuffer.bind(EmitUnencryptedLog)],
+  [EmitPublicLog.opcode, Instruction.fromBuffer.bind(EmitPublicLog)],
   [SendL2ToL1Message.opcode, Instruction.fromBuffer.bind(SendL2ToL1Message)],
   [GetContractInstance.opcode, Instruction.fromBuffer.bind(GetContractInstance)],
 

package/src/public/avm/serialization/instruction_serialization.ts

@@ -70,7 +70,7 @@ export enum Opcode {
   EMITNULLIFIER,
   L1TOL2MSGEXISTS,
   GETCONTRACTINSTANCE,
-  EMITUNENCRYPTEDLOG,
+  EMITPUBLICLOG,
   SENDL2TOL1MSG,
   // External calls
   CALL,

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

@@ -1,4 +1,4 @@
-import { GeneratorIndex } from '@aztec/constants';
+import { DomainSeparator } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
@@ -326,6 +326,6 @@ async function removeLiquidity(
 async function computePartialNoteValidityCommitment(partialNote: { commitment: Fr }, completer: AztecAddress) {
   return await poseidon2HashWithSeparator(
     [partialNote.commitment, completer],
-    GeneratorIndex.PARTIAL_NOTE_VALIDITY_COMMITMENT,
+    DomainSeparator.PARTIAL_NOTE_VALIDITY_COMMITMENT,
   );
 }

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.