@aztec/simulator 0.37.0 → 0.39.0

package/src/avm/errors.ts

@@ -1,12 +1,16 @@
-import { type AztecAddress } from '@aztec/circuits.js';
+import { type FailingFunction, type NoirCallStack } from '@aztec/circuit-types';
+import { type AztecAddress, type Fr } from '@aztec/circuits.js';
+
+import { ExecutionError } from '../common/errors.js';
+import { type AvmContext } from './avm_context.js';
 
 /**
  * Avm-specific errors should derive from this
  */
 export abstract class AvmExecutionError extends Error {
-  constructor(message: string, ...rest: any[]) {
-    super(message, ...rest);
-    this.name = 'AvmInterpreterError';
+  constructor(message: string) {
+    super(message);
+    this.name = 'AvmExecutionError';
   }
 }
 
@@ -63,3 +67,89 @@ export class OutOfGasError extends AvmExecutionError {
     this.name = 'OutOfGasError';
   }
 }
+
+/**
+ * Error thrown to propagate a nested call's revert.
+ * @param message - the error's message
+ * @param nestedError - the revert reason of the nested call
+ */
+export class RethrownError extends AvmExecutionError {
+  constructor(message: string, public nestedError: AvmRevertReason) {
+    super(message);
+    this.name = 'RethrownError';
+  }
+}
+
+/**
+ * Meaningfully named alias for ExecutionError when used in the context of the AVM.
+ * Maintains a recursive structure reflecting the AVM's external callstack/errorstack, where
+ * options.cause is the error that caused this error (if this is not the root-cause itself).
+ */
+export class AvmRevertReason extends ExecutionError {
+  constructor(message: string, failingFunction: FailingFunction, noirCallStack: NoirCallStack, options?: ErrorOptions) {
+    super(message, failingFunction, noirCallStack, options);
+  }
+}
+
+/**
+ * Helper to create a "revert reason" error optionally with a nested error cause.
+ *
+ * @param message - the error message
+ * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ * @param nestedError - the error that caused this one (if this is not the root-cause itself)
+ */
+function createRevertReason(message: string, context: AvmContext, nestedError?: AvmRevertReason): AvmRevertReason {
+  return new AvmRevertReason(
+    message,
+    /*failingFunction=*/ {
+      contractAddress: context.environment.address,
+      functionSelector: context.environment.temporaryFunctionSelector,
+    },
+    /*noirCallStack=*/ [...context.machineState.internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
+    /*options=*/ { cause: nestedError },
+  );
+}
+
+/**
+ * Create a "revert reason" error for an exceptional halt,
+ * creating the recursive structure if the halt was a RethrownError.
+ *
+ * @param haltingError - the lower-level error causing the exceptional halt
+ * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ */
+export function revertReasonFromExceptionalHalt(haltingError: AvmExecutionError, context: AvmContext): AvmRevertReason {
+  // A RethrownError has a nested/child AvmRevertReason
+  const nestedError = haltingError instanceof RethrownError ? haltingError.nestedError : undefined;
+  return createRevertReason(haltingError.message, context, nestedError);
+}
+
+/**
+ * Create a "revert reason" error for an explicit revert (a root cause).
+ *
+ * @param revertData - output data of the explicit REVERT instruction
+ * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ */
+export function revertReasonFromExplicitRevert(revertData: Fr[], context: AvmContext): AvmRevertReason {
+  const revertMessage = decodeRevertDataAsMessage(revertData);
+  return createRevertReason(revertMessage, context);
+}
+
+/**
+ * Interpret revert data as a message string.
+ *
+ * @param revertData - output data of an explicit REVERT instruction
+ */
+export function decodeRevertDataAsMessage(revertData: Fr[]): string {
+  if (revertData.length === 0) {
+    return 'Assertion failed.';
+  } else {
+    try {
+      // We remove the first element which is the 'error selector'.
+      const revertOutput = revertData.slice(1);
+      // Try to interpret the output as a text string.
+      return 'Assertion failed: ' + String.fromCharCode(...revertOutput.map(fr => fr.toNumber()));
+    } catch (e) {
+      return 'Assertion failed: <cannot interpret as string>';
+    }
+  }
+}

package/src/avm/journal/journal.ts

@@ -1,9 +1,21 @@
+// TODO(5818): Rename file and all uses of "journal"
 import { UnencryptedL2Log } from '@aztec/circuit-types';
-import { AztecAddress, EthAddress, L2ToL1Message } from '@aztec/circuits.js';
+import {
+  AztecAddress,
+  ContractStorageRead,
+  ContractStorageUpdateRequest,
+  EthAddress,
+  L2ToL1Message,
+  NoteHash,
+  Nullifier,
+  ReadRequest,
+  SideEffect,
+} from '@aztec/circuits.js';
 import { EventSelector } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 
+import { type PublicExecutionResult } from '../../index.js';
 import { type HostStorage } from './host_storage.js';
 import { Nullifiers } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
@@ -19,6 +31,7 @@ import {
   type TracedUnencryptedL2Log,
 } from './trace_types.js';
 
+// TODO:(5818): do we need this type anymore?
 /**
  * Data held within the journal
  */
@@ -37,6 +50,25 @@ export type JournalData = {
   newLogsHashes: TracedUnencryptedL2Log[];
   /** contract address -\> key -\> value */
   currentStorageValue: Map<bigint, Map<bigint, Fr>>;
+
+  sideEffectCounter: number;
+};
+
+// TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
+type PartialPublicExecutionResult = {
+  nullifierReadRequests: ReadRequest[];
+  nullifierNonExistentReadRequests: ReadRequest[];
+  newNoteHashes: NoteHash[];
+  newL2ToL1Messages: L2ToL1Message[];
+  startSideEffectCounter: number;
+  newNullifiers: Nullifier[];
+  contractStorageReads: ContractStorageRead[];
+  contractStorageUpdateRequests: ContractStorageUpdateRequest[];
+  unencryptedLogsHashes: SideEffect[];
+  unencryptedLogs: UnencryptedL2Log[];
+  unencryptedLogPreimagesLength: Fr;
+  allUnencryptedLogs: UnencryptedL2Log[];
+  nestedExecutions: PublicExecutionResult[];
 };
 
 /**
@@ -53,7 +85,7 @@ export class AvmPersistableStateManager {
   /** Reference to node storage */
   public readonly hostStorage: HostStorage;
 
-  // TODO: make members private once this is not used in transitional_adaptors.ts.
+  // TODO(5818): make members private once this is not used in transitional_adaptors.ts.
   /** World State */
   /** Public storage, including cached writes */
   public publicStorage: PublicStorage;
@@ -67,11 +99,31 @@ export class AvmPersistableStateManager {
   public newL1Messages: L2ToL1Message[] = [];
   public newLogs: UnencryptedL2Log[] = [];
 
+  // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
+  public transitionalExecutionResult: PartialPublicExecutionResult;
+
   constructor(hostStorage: HostStorage, parent?: AvmPersistableStateManager) {
     this.hostStorage = hostStorage;
     this.publicStorage = new PublicStorage(hostStorage.publicStateDb, parent?.publicStorage);
     this.nullifiers = new Nullifiers(hostStorage.commitmentsDb, parent?.nullifiers);
     this.trace = new WorldStateAccessTrace(parent?.trace);
+
+    this.transitionalExecutionResult = {
+      nullifierReadRequests: [],
+      nullifierNonExistentReadRequests: [],
+      newNoteHashes: [],
+      newL2ToL1Messages: [],
+      startSideEffectCounter: this.trace.accessCounter,
+      newNullifiers: [],
+      contractStorageReads: [],
+      contractStorageUpdateRequests: [],
+      unencryptedLogsHashes: [],
+      unencryptedLogs: [],
+      // The length starts at 4 because it will always include the size.
+      unencryptedLogPreimagesLength: new Fr(4),
+      allUnencryptedLogs: [],
+      nestedExecutions: [],
+    };
   }
 
   /**
@@ -92,6 +144,21 @@ export class AvmPersistableStateManager {
     this.log.debug(`storage(${storageAddress})@${slot} <- ${value}`);
     // Cache storage writes for later reference/reads
     this.publicStorage.write(storageAddress, slot, value);
+
+    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
+    // The current info to the kernel clears any previous read or write request.
+    this.transitionalExecutionResult.contractStorageReads =
+      this.transitionalExecutionResult.contractStorageReads.filter(
+        read => !read.storageSlot.equals(slot) || !read.contractAddress!.equals(storageAddress),
+      );
+    this.transitionalExecutionResult.contractStorageUpdateRequests =
+      this.transitionalExecutionResult.contractStorageUpdateRequests.filter(
+        update => !update.storageSlot.equals(slot) || !update.contractAddress!.equals(storageAddress),
+      );
+    this.transitionalExecutionResult.contractStorageUpdateRequests.push(
+      new ContractStorageUpdateRequest(slot, value, this.trace.accessCounter, storageAddress),
+    );
+
     // Trace all storage writes (even reverted ones)
     this.trace.tracePublicStorageWrite(storageAddress, slot, value);
   }
@@ -104,10 +171,24 @@ export class AvmPersistableStateManager {
    * @returns the latest value written to slot, or 0 if never written to before
    */
   public async readStorage(storageAddress: Fr, slot: Fr): Promise<Fr> {
-    const [exists, value] = await this.publicStorage.read(storageAddress, slot);
-    this.log.debug(`storage(${storageAddress})@${slot} ?? value: ${value}, exists: ${exists}.`);
+    const { value, exists, cached } = await this.publicStorage.read(storageAddress, slot);
+    this.log.debug(`storage(${storageAddress})@${slot} ?? value: ${value}, exists: ${exists}, cached: ${cached}.`);
+
+    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
+    // The current info to the kernel kernel does not consider cached reads.
+    if (!cached) {
+      // The current info to the kernel removes any previous reads to the same slot.
+      this.transitionalExecutionResult.contractStorageReads =
+        this.transitionalExecutionResult.contractStorageReads.filter(
+          read => !read.storageSlot.equals(slot) || !read.contractAddress!.equals(storageAddress),
+        );
+      this.transitionalExecutionResult.contractStorageReads.push(
+        new ContractStorageRead(slot, value, this.trace.accessCounter, storageAddress),
+      );
+    }
+
     // We want to keep track of all performed reads (even reverted ones)
-    this.trace.tracePublicStorageRead(storageAddress, slot, value, exists);
+    this.trace.tracePublicStorageRead(storageAddress, slot, value, exists, cached);
     return Promise.resolve(value);
   }
 
@@ -133,6 +214,9 @@ export class AvmPersistableStateManager {
    * @param noteHash - the unsiloed note hash to write
    */
   public writeNoteHash(storageAddress: Fr, noteHash: Fr) {
+    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
+    this.transitionalExecutionResult.newNoteHashes.push(new NoteHash(noteHash, this.trace.accessCounter));
+
     this.log.debug(`noteHashes(${storageAddress}) += @${noteHash}.`);
     this.trace.traceNewNoteHash(storageAddress, noteHash);
   }
@@ -148,6 +232,16 @@ export class AvmPersistableStateManager {
     this.log.debug(
       `nullifiers(${storageAddress})@${nullifier} ?? leafIndex: ${leafIndex}, pending: ${isPending}, exists: ${exists}.`,
     );
+
+    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
+    if (exists) {
+      this.transitionalExecutionResult.nullifierReadRequests.push(new ReadRequest(nullifier, this.trace.accessCounter));
+    } else {
+      this.transitionalExecutionResult.nullifierNonExistentReadRequests.push(
+        new ReadRequest(nullifier, this.trace.accessCounter),
+      );
+    }
+
     this.trace.traceNullifierCheck(storageAddress, nullifier, exists, isPending, leafIndex);
     return Promise.resolve(exists);
   }
@@ -158,6 +252,9 @@ export class AvmPersistableStateManager {
    * @param nullifier - the unsiloed nullifier to write
    */
   public async writeNullifier(storageAddress: Fr, nullifier: Fr) {
+    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
+    this.transitionalExecutionResult.newNullifiers.push(new Nullifier(nullifier, this.trace.accessCounter, Fr.ZERO));
+
     this.log.debug(`nullifiers(${storageAddress}) += ${nullifier}.`);
     // Cache pending nullifiers for later access
     await this.nullifiers.append(storageAddress, nullifier);
@@ -189,18 +286,39 @@ export class AvmPersistableStateManager {
   public writeL1Message(recipient: EthAddress | Fr, content: Fr) {
     this.log.debug(`L1Messages(${recipient}) += ${content}.`);
     const recipientAddress = recipient instanceof EthAddress ? recipient : EthAddress.fromField(recipient);
-    this.newL1Messages.push(new L2ToL1Message(recipientAddress, content));
+    const message = new L2ToL1Message(recipientAddress, content, 0);
+    this.newL1Messages.push(message);
+
+    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
+    this.transitionalExecutionResult.newL2ToL1Messages.push(message);
   }
 
   public writeLog(contractAddress: Fr, event: Fr, log: Fr[]) {
     this.log.debug(`UnencryptedL2Log(${contractAddress}) += event ${event} with ${log.length} fields.`);
-    const L2log = new UnencryptedL2Log(
+    const ulog = new UnencryptedL2Log(
       AztecAddress.fromField(contractAddress),
       EventSelector.fromField(event),
       Buffer.concat(log.map(f => f.toBuffer())),
     );
-    this.newLogs.push(L2log);
-    this.trace.traceNewLog(Fr.fromBuffer(L2log.hash()));
+    const logHash = Fr.fromBuffer(ulog.hash());
+
+    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
+    this.transitionalExecutionResult.unencryptedLogs.push(ulog);
+    this.transitionalExecutionResult.allUnencryptedLogs.push(ulog);
+    // this duplicates exactly what happens in the trace just for the purpose of transitional integration with the kernel
+    this.transitionalExecutionResult.unencryptedLogsHashes.push(
+      new SideEffect(logHash, new Fr(this.trace.accessCounter)),
+    );
+    // Duplicates computation performed in public_context.nr::emit_unencrypted_log
+    // 44 = addr (32) + selector (4) + raw log len (4) + processed log len (4).
+    this.transitionalExecutionResult.unencryptedLogPreimagesLength = new Fr(
+      this.transitionalExecutionResult.unencryptedLogPreimagesLength.toNumber() + 44 + log.length * Fr.SIZE_IN_BYTES,
+    );
+    // TODO(6206): likely need to track this here and not just in the transitional logic.
+
+    // TODO(6205): why are logs pushed here but logs hashes are traced?
+    this.newLogs.push(ulog);
+    this.trace.traceNewLog(logHash);
   }
 
   /**
@@ -216,6 +334,11 @@ export class AvmPersistableStateManager {
     // Accrued Substate
     this.newL1Messages = this.newL1Messages.concat(nestedJournal.newL1Messages);
     this.newLogs = this.newLogs.concat(nestedJournal.newLogs);
+
+    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
+    this.transitionalExecutionResult.allUnencryptedLogs.concat(
+      nestedJournal.transitionalExecutionResult.allUnencryptedLogs,
+    );
   }
 
   /**
@@ -226,6 +349,7 @@ export class AvmPersistableStateManager {
     this.trace.acceptAndMerge(nestedJournal.trace);
   }
 
+  // TODO:(5818): do we need this type anymore?
   /**
    * Access the current state of the journal
    *
@@ -244,6 +368,7 @@ export class AvmPersistableStateManager {
       currentStorageValue: this.publicStorage.getCache().cachePerContract,
       storageReads: this.trace.publicStorageReads,
       storageWrites: this.trace.publicStorageWrites,
+      sideEffectCounter: this.trace.accessCounter,
     };
   }
 }

package/src/avm/journal/nullifiers.ts

@@ -1,3 +1,4 @@
+import { AztecAddress } from '@aztec/circuits.js';
 import { siloNullifier } from '@aztec/circuits.js/hash';
 import { Fr } from '@aztec/foundation/fields';
 
@@ -10,7 +11,7 @@ import type { CommitmentsDB } from '../../index.js';
  */
 export class Nullifiers {
   /** Cached nullifiers. */
-  private cache: NullifierCache;
+  public cache: NullifierCache;
   /** Parent's nullifier cache. Checked on cache-miss. */
   private readonly parentCache: NullifierCache | undefined;
   /** Reference to node storage. Checked on parent cache-miss. */
@@ -95,6 +96,7 @@ export class NullifierCache {
    * each entry being a nullifier.
    */
   private cachePerContract: Map<bigint, Set<bigint>> = new Map();
+  private siloedNullifiers: Set<bigint> = new Set();
 
   /**
    * Check whether a nullifier exists in the cache.
@@ -104,8 +106,10 @@ export class NullifierCache {
    * @returns whether the nullifier is found in the cache
    */
   public exists(storageAddress: Fr, nullifier: Fr): boolean {
-    const exists = this.cachePerContract.get(storageAddress.toBigInt())?.has(nullifier.toBigInt());
-    return exists ? true : false;
+    const exists =
+      this.cachePerContract.get(storageAddress.toBigInt())?.has(nullifier.toBigInt()) ||
+      this.siloedNullifiers.has(siloNullifier(AztecAddress.fromField(storageAddress), nullifier).toBigInt());
+    return !!exists;
   }
 
   /**
@@ -115,20 +119,25 @@ export class NullifierCache {
    * @param nullifier - the nullifier to stage
    */
   public append(storageAddress: Fr, nullifier: Fr) {
+    if (this.exists(storageAddress, nullifier)) {
+      throw new NullifierCollisionError(
+        `Nullifier ${nullifier} at contract ${storageAddress} already exists in cache.`,
+      );
+    }
+
     let nullifiersForContract = this.cachePerContract.get(storageAddress.toBigInt());
     // If this contract's nullifier set has no cached nullifiers, create a new Set to store them
     if (!nullifiersForContract) {
       nullifiersForContract = new Set();
       this.cachePerContract.set(storageAddress.toBigInt(), nullifiersForContract);
     }
-    if (nullifiersForContract.has(nullifier.toBigInt())) {
-      throw new NullifierCollisionError(
-        `Nullifier ${nullifier} at contract ${storageAddress} already exists in cache.`,
-      );
-    }
     nullifiersForContract.add(nullifier.toBigInt());
   }
 
+  public appendSiloed(siloedNullifier: Fr) {
+    this.siloedNullifiers.add(siloedNullifier.toBigInt());
+  }
+
   /**
    * Merge another cache's nullifiers into this instance's.
    *
@@ -139,6 +148,8 @@ export class NullifierCache {
    * @param incomingNullifiers - the incoming cached nullifiers to merge into this instance's
    */
   public acceptAndMerge(incomingNullifiers: NullifierCache) {
+    // Merge siloed nullifiers.
+    this.siloedNullifiers = new Set([...this.siloedNullifiers, ...incomingNullifiers.siloedNullifiers]);
     // Iterate over all contracts with staged writes in the child.
     for (const [incomingAddress, incomingCacheAtContract] of incomingNullifiers.cachePerContract) {
       const thisCacheAtContract = this.cachePerContract.get(incomingAddress);

package/src/avm/journal/public_storage.ts

@@ -1,7 +1,14 @@
+import { AztecAddress } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
 import type { PublicStateDB } from '../../index.js';
 
+type PublicStorageReadResult = {
+  value: Fr;
+  exists: boolean;
+  cached: boolean;
+};
+
 /**
  * A class to manage public storage reads and writes during a contract call's AVM simulation.
  * Maintains a storage write cache, and ensures that reads fall back to the correct source.
@@ -39,7 +46,8 @@ export class PublicStorage {
    * @param slot - the slot in the contract's storage being read from
    * @returns exists: whether the slot has EVER been written to before, value: the latest value written to slot, or 0 if never written to before
    */
-  public async read(storageAddress: Fr, slot: Fr): Promise<[/*exists=*/ boolean, /*value=*/ Fr]> {
+  public async read(storageAddress: Fr, slot: Fr): Promise<PublicStorageReadResult> {
+    let cached = false;
     // First try check this storage cache
     let value = this.cache.read(storageAddress, slot);
     // Then try parent's storage cache (if it exists / written to earlier in this TX)
@@ -49,11 +57,13 @@ export class PublicStorage {
     // Finally try the host's Aztec state (a trip to the database)
     if (!value) {
       value = await this.hostPublicStorage.storageRead(storageAddress, slot);
+    } else {
+      cached = true;
     }
     // if value is undefined, that means this slot has never been written to!
     const exists = value !== undefined;
     const valueOrZero = exists ? value : Fr.ZERO;
-    return Promise.resolve([exists, valueOrZero]);
+    return Promise.resolve({ value: valueOrZero, exists, cached });
   }
 
   /**
@@ -75,6 +85,17 @@ export class PublicStorage {
   public acceptAndMerge(incomingPublicStorage: PublicStorage) {
     this.cache.acceptAndMerge(incomingPublicStorage.cache);
   }
+
+  /**
+   * Commits ALL staged writes to the host's state.
+   */
+  public async commitToDB() {
+    for (const [storageAddress, cacheAtContract] of this.cache.cachePerContract) {
+      for (const [slot, value] of cacheAtContract) {
+        await this.hostPublicStorage.storageWrite(AztecAddress.fromBigInt(storageAddress), new Fr(slot), value);
+      }
+    }
+  }
 }
 
 /**

package/src/avm/journal/trace.ts

@@ -29,13 +29,14 @@ export class WorldStateAccessTrace {
 
   constructor(parentTrace?: WorldStateAccessTrace) {
     this.accessCounter = parentTrace ? parentTrace.accessCounter : 0;
+    // TODO(4805): consider tracking the parent's trace vector lengths so we can enforce limits
   }
 
   public getAccessCounter() {
     return this.accessCounter;
   }
 
-  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, exists: boolean) {
+  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, exists: boolean, cached: boolean) {
     // TODO(4805): check if some threshold is reached for max storage reads
     // (need access to parent length, or trace needs to be initialized with parent's contents)
     const traced: TracedPublicStorageRead = {
@@ -44,6 +45,7 @@ export class WorldStateAccessTrace {
       slot,
       value,
       exists,
+      cached,
       counter: new Fr(this.accessCounter),
       //  endLifetime: Fr.ZERO,
     };
@@ -151,9 +153,6 @@ export class WorldStateAccessTrace {
   /**
    * Merges another trace into this one
    *
-   * - Public state journals (r/w logs), with the accessing being appended in chronological order
-   * - Utxo objects are concatenated
-   *
    * @param incomingTrace - the incoming trace to merge into this instance
    */
   public acceptAndMerge(incomingTrace: WorldStateAccessTrace) {

package/src/avm/journal/trace_types.ts

@@ -11,6 +11,7 @@ export type TracedPublicStorageRead = {
   //  callPointer: Fr;
   storageAddress: Fr;
   exists: boolean;
+  cached: boolean;
   slot: Fr;
   value: Fr;
   counter: Fr;

package/src/avm/opcodes/bitwise.ts

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { type IntegralValue } from '../avm_memory_types.js';
+import { type IntegralValue, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { ThreeOperandInstruction, TwoOperandInstruction } from './instruction_impl.js';
 
@@ -9,7 +9,7 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    memory.checkTags(this.inTag, this.aOffset, this.bOffset);
+    this.checkTags(memory, this.inTag, this.aOffset, this.bOffset);
 
     const a = memory.getAs<IntegralValue>(this.aOffset);
     const b = memory.getAs<IntegralValue>(this.bOffset);
@@ -22,13 +22,16 @@ abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
   }
 
   protected abstract compute(a: IntegralValue, b: IntegralValue): IntegralValue;
+  protected checkTags(memory: TaggedMemoryInterface, inTag: number, aOffset: number, bOffset: number) {
+    memory.checkTags(inTag, aOffset, bOffset);
+  }
 }
 
 export class And extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'AND';
   static readonly opcode = Opcode.AND;
 
-  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.and(b);
   }
 }
@@ -37,7 +40,7 @@ export class Or extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'OR';
   static readonly opcode = Opcode.OR;
 
-  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.or(b);
   }
 }
@@ -46,7 +49,7 @@ export class Xor extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'XOR';
   static readonly opcode = Opcode.XOR;
 
-  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.xor(b);
   }
 }
@@ -55,18 +58,26 @@ export class Shl extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'SHL';
   static readonly opcode = Opcode.SHL;
 
-  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.shl(b);
   }
+  protected override checkTags(memory: TaggedMemoryInterface, inTag: number, aOffset: number, bOffset: number) {
+    memory.checkTag(inTag, aOffset);
+    memory.checkTag(TypeTag.UINT8, bOffset);
+  }
 }
 
 export class Shr extends ThreeOperandBitwiseInstruction {
   static readonly type: string = 'SHR';
   static readonly opcode = Opcode.SHR;
 
-  protected compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
     return a.shr(b);
   }
+  protected override checkTags(memory: TaggedMemoryInterface, inTag: number, aOffset: number, bOffset: number) {
+    memory.checkTag(inTag, aOffset);
+    memory.checkTag(TypeTag.UINT8, bOffset);
+  }
 }
 
 export class Not extends TwoOperandInstruction {

package/src/avm/opcodes/conversion.ts

@@ -0,0 +1,59 @@
+import { strict as assert } from 'assert';
+
+import { type AvmContext } from '../avm_context.js';
+import { TypeTag, Uint8 } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class ToRadixLE extends Instruction {
+  static type: string = 'TORADIXLE';
+  static readonly opcode: Opcode = Opcode.TORADIXLE;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8, // Opcode
+    OperandType.UINT8, // Indirect
+    OperandType.UINT32, // src memory address
+    OperandType.UINT32, // dst memory address
+    OperandType.UINT32, // radix (immediate)
+    OperandType.UINT32, // number of limbs (Immediate)
+  ];
+
+  constructor(
+    private indirect: number,
+    private srcOffset: number,
+    private dstOffset: number,
+    private radix: number,
+    private numLimbs: number,
+  ) {
+    assert(radix <= 256, 'Radix cannot be greater than 256');
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory.track(this.type);
+    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.srcOffset, this.dstOffset], memory);
+    const memoryOperations = { reads: 1, writes: this.numLimbs, indirect: this.indirect };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+
+    // The radix gadget only takes in a Field
+    memory.checkTag(TypeTag.FIELD, srcOffset);
+
+    let value: bigint = memory.get(srcOffset).toBigInt();
+    const radixBN: bigint = BigInt(this.radix);
+    const limbArray = [];
+
+    for (let i = 0; i < this.numLimbs; i++) {
+      const limb = value % radixBN;
+      limbArray.push(limb);
+      value /= radixBN;
+    }
+
+    const res = [...limbArray].map(byte => new Uint8(byte));
+    memory.setSlice(dstOffset, res);
+
+    memory.assert(memoryOperations);
+    context.machineState.incrementPc();
+  }
+}