@aztec/simulator 0.55.1 → 0.56.0

package/src/avm/avm_machine_state.ts

@@ -1,6 +1,6 @@
 import { type Fr } from '@aztec/circuits.js';
 
-import { type Gas, GasDimensions } from './avm_gas.js';
+import { GAS_DIMENSIONS, type Gas } from './avm_gas.js';
 import { TaggedMemory } from './avm_memory_types.js';
 import { OutOfGasError } from './errors.js';
 
@@ -67,7 +67,7 @@ export class AvmMachineState {
    */
   public consumeGas(gasCost: Partial<Gas>) {
     // Assert there is enough gas on every dimension.
-    const outOfGasDimensions = GasDimensions.filter(
+    const outOfGasDimensions = GAS_DIMENSIONS.filter(
       dimension => this[`${dimension}Left`] - (gasCost[dimension] ?? 0) < 0,
     );
     // If not, trigger an exceptional halt.
@@ -77,14 +77,14 @@ export class AvmMachineState {
       throw new OutOfGasError(outOfGasDimensions);
     }
     // Otherwise, charge the corresponding gas
-    for (const dimension of GasDimensions) {
+    for (const dimension of GAS_DIMENSIONS) {
       this[`${dimension}Left`] -= gasCost[dimension] ?? 0;
     }
   }
 
   /** Increases the gas left by the amounts specified. */
   public refundGas(gasRefund: Partial<Gas>) {
-    for (const dimension of GasDimensions) {
+    for (const dimension of GAS_DIMENSIONS) {
       this[`${dimension}Left`] += gasRefund[dimension] ?? 0;
     }
   }
@@ -133,7 +133,7 @@ export class AvmMachineState {
    * Flag an exceptional halt. Clears gas left and sets the reverted flag. No output data.
    */
   private exceptionalHalt() {
-    GasDimensions.forEach(dimension => (this[`${dimension}Left`] = 0));
+    GAS_DIMENSIONS.forEach(dimension => (this[`${dimension}Left`] = 0));
     this.reverted = true;
     this.halted = true;
   }

package/src/avm/avm_memory_types.ts

@@ -1,3 +1,12 @@
+import {
+  MEM_TAG_FF,
+  MEM_TAG_U1,
+  MEM_TAG_U8,
+  MEM_TAG_U16,
+  MEM_TAG_U32,
+  MEM_TAG_U64,
+  MEM_TAG_U128,
+} from '@aztec/circuits.js';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
@@ -128,6 +137,9 @@ function UnsignedIntegerClassFactory(bits: number) {
     }
 
     public toBuffer(): Buffer {
+      if (bits < 8) {
+        return toBufferBE(this.n, 1);
+      }
       return toBufferBE(this.n, bits / 8);
     }
   };
@@ -136,6 +148,7 @@ function UnsignedIntegerClassFactory(bits: number) {
 // Now we can create the classes for each unsigned integer type.
 // We extend instead of just assigning so that the class has the right name.
 // Otherwise they are all called "NewUintClass".
+export class Uint1 extends UnsignedIntegerClassFactory(1) {}
 export class Uint8 extends UnsignedIntegerClassFactory(8) {}
 export class Uint16 extends UnsignedIntegerClassFactory(16) {}
 export class Uint32 extends UnsignedIntegerClassFactory(32) {}
@@ -196,12 +209,13 @@ export class Field extends MemoryValue {
 
 export enum TypeTag {
   UNINITIALIZED,
-  UINT8,
-  UINT16,
-  UINT32,
-  UINT64,
-  UINT128,
-  FIELD,
+  UINT1 = MEM_TAG_U1,
+  UINT8 = MEM_TAG_U8,
+  UINT16 = MEM_TAG_U16,
+  UINT32 = MEM_TAG_U32,
+  UINT64 = MEM_TAG_U64,
+  UINT128 = MEM_TAG_U128,
+  FIELD = MEM_TAG_FF,
   INVALID,
 }
 
@@ -302,7 +316,9 @@ export class TaggedMemory implements TaggedMemoryInterface {
   }
 
   public static checkIsIntegralTag(tag: TypeTag) {
-    if (![TypeTag.UINT8, TypeTag.UINT16, TypeTag.UINT32, TypeTag.UINT64, TypeTag.UINT128].includes(tag)) {
+    if (
+      ![TypeTag.UINT1, TypeTag.UINT8, TypeTag.UINT16, TypeTag.UINT32, TypeTag.UINT64, TypeTag.UINT128].includes(tag)
+    ) {
       throw TagCheckError.forTag(TypeTag[tag], 'integral');
     }
   }
@@ -332,8 +348,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
 
     if (v === undefined) {
       tag = TypeTag.UNINITIALIZED;
-    } else if (v instanceof Field) {
-      tag = TypeTag.FIELD;
+    } else if (v instanceof Uint1) {
+      tag = TypeTag.UINT1;
     } else if (v instanceof Uint8) {
       tag = TypeTag.UINT8;
     } else if (v instanceof Uint16) {
@@ -344,6 +360,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
       tag = TypeTag.UINT64;
     } else if (v instanceof Uint128) {
       tag = TypeTag.UINT128;
+    } else if (v instanceof Field) {
+      tag = TypeTag.FIELD;
     }
 
     return tag;
@@ -353,6 +371,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public static buildFromTagTruncating(v: bigint | number, tag: TypeTag): MemoryValue {
     v = BigInt(v);
     switch (tag) {
+      case TypeTag.UINT1:
+        return new Uint1(v & 1n);
       case TypeTag.UINT8:
         return new Uint8(v & ((1n << 8n) - 1n));
       case TypeTag.UINT16:
@@ -373,6 +393,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
   // Does not truncate. Type constructor will check that it fits.
   public static buildFromTagOrDie(v: bigint | number, tag: TypeTag): MemoryValue {
     switch (tag) {
+      case TypeTag.UINT1:
+        return new Uint1(v);
       case TypeTag.UINT8:
         return new Uint8(v);
       case TypeTag.UINT16:

package/src/avm/avm_simulator.ts

@@ -4,7 +4,7 @@ import { strict as assert } from 'assert';
 
 import type { AvmContext } from './avm_context.js';
 import { AvmContractCallResult } from './avm_contract_call_result.js';
-import { decompressBytecodeIfCompressed, isAvmBytecode } from './bytecode_utils.js';
+import { isAvmBytecode } from './bytecode_utils.js';
 import {
   AvmExecutionError,
   InvalidProgramCounterError,
@@ -53,11 +53,10 @@ export class AvmSimulator {
    * This method is useful for testing and debugging.
    */
   public async executeBytecode(bytecode: Buffer): Promise<AvmContractCallResult> {
-    const decompressedBytecode = await decompressBytecodeIfCompressed(bytecode);
-    assert(await isAvmBytecode(decompressedBytecode), "AVM simulator can't execute non-AVM bytecode");
+    assert(isAvmBytecode(bytecode), "AVM simulator can't execute non-AVM bytecode");
 
-    this.bytecode = decompressedBytecode;
-    return await this.executeInstructions(decodeFromBytecode(decompressedBytecode));
+    this.bytecode = bytecode;
+    return await this.executeInstructions(decodeFromBytecode(bytecode));
   }
 
   /**

package/src/avm/bytecode_utils.ts

@@ -1,6 +1,3 @@
-import { promisify } from 'util';
-import { gunzip } from 'zlib';
-
 import { Opcode } from './serialization/instruction_serialization.js';
 
 const AVM_MAGIC_SUFFIX = Buffer.from([
@@ -14,19 +11,7 @@ export function markBytecodeAsAvm(bytecode: Buffer): Buffer {
   return Buffer.concat([bytecode, AVM_MAGIC_SUFFIX]);
 }
 
-// This is just a helper function for the AVM simulator
-export async function decompressBytecodeIfCompressed(bytecode: Buffer): Promise<Buffer> {
-  try {
-    return await promisify(gunzip)(bytecode);
-  } catch {
-    // If the bytecode is not compressed, the gunzip call will throw an error
-    // In this case, we assume the bytecode is not compressed and continue.
-    return Promise.resolve(bytecode);
-  }
-}
-
-export async function isAvmBytecode(bytecode: Buffer): Promise<boolean> {
-  const decompressedBytecode = await decompressBytecodeIfCompressed(bytecode);
+export function isAvmBytecode(bytecode: Buffer): boolean {
   const magicSize = AVM_MAGIC_SUFFIX.length;
-  return decompressedBytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
+  return bytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
 }

package/src/avm/fixtures/index.ts

@@ -10,20 +10,13 @@ import { strict as assert } from 'assert';
 import { mock } from 'jest-mock-extended';
 import merge from 'lodash.merge';
 
-import {
-  type CommitmentsDB,
-  type PublicContractsDB,
-  type PublicStateDB,
-  resolveAssertionMessage,
-  traverseCauseChain,
-} from '../../index.js';
+import { type WorldStateDB, resolveAssertionMessage, traverseCauseChain } from '../../index.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
 import { AvmContext } from '../avm_context.js';
-import { AvmContextInputs, AvmExecutionEnvironment } from '../avm_execution_environment.js';
+import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
 import { AvmMachineState } from '../avm_machine_state.js';
-import { Field, Uint8, Uint64 } from '../avm_memory_types.js';
+import { Field, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
 import { type AvmRevertReason } from '../errors.js';
-import { HostStorage } from '../journal/host_storage.js';
 import { AvmPersistableStateManager } from '../journal/journal.js';
 import { NullifierManager } from '../journal/nullifiers.js';
 import { PublicStorage } from '../journal/public_storage.js';
@@ -43,32 +36,19 @@ export function initContext(overrides?: {
   );
 }
 
-/** Creates an empty host storage with mocked dbs. */
-export function initHostStorage(overrides?: {
-  publicDb?: PublicStateDB;
-  contractsDb?: PublicContractsDB;
-  commitmentsDb?: CommitmentsDB;
-}): HostStorage {
-  return new HostStorage(
-    overrides?.publicDb || mock<PublicStateDB>(),
-    overrides?.contractsDb || mock<PublicContractsDB>(),
-    overrides?.commitmentsDb || mock<CommitmentsDB>(),
-  );
-}
-
 /** Creates an empty state manager with mocked host storage. */
 export function initPersistableStateManager(overrides?: {
-  hostStorage?: HostStorage;
+  worldStateDB?: WorldStateDB;
   trace?: PublicSideEffectTraceInterface;
   publicStorage?: PublicStorage;
   nullifiers?: NullifierManager;
 }): AvmPersistableStateManager {
-  const hostStorage = overrides?.hostStorage || initHostStorage();
+  const worldStateDB = overrides?.worldStateDB || mock<WorldStateDB>();
   return new AvmPersistableStateManager(
-    hostStorage,
+    worldStateDB,
     overrides?.trace || mock<PublicSideEffectTraceInterface>(),
-    overrides?.publicStorage || new PublicStorage(hostStorage.publicStateDb),
-    overrides?.nullifiers || new NullifierManager(hostStorage.commitmentsDb),
+    overrides?.publicStorage || new PublicStorage(worldStateDB),
+    overrides?.nullifiers || new NullifierManager(worldStateDB),
   );
 }
 
@@ -124,26 +104,14 @@ export function allSameExcept(original: any, overrides: any): any {
   return merge({}, original, overrides);
 }
 
-/**
- * Adjust the user index to account for the AvmContextInputs size.
- * This is a hack for testing, and should go away once AvmContextInputs themselves go away.
- */
-export function adjustCalldataIndex(userIndex: number): number {
-  return userIndex + AvmContextInputs.SIZE;
-}
-
-export function anyAvmContextInputs() {
-  const tv = [];
-  for (let i = 0; i < AvmContextInputs.SIZE; i++) {
-    tv.push(expect.any(Fr));
-  }
-  return tv;
-}
-
 export function randomMemoryBytes(length: number): Uint8[] {
   return [...Array(length)].map(_ => new Uint8(Math.floor(Math.random() * 255)));
 }
 
+export function randomMemoryUint32s(length: number): Uint32[] {
+  return [...Array(length)].map(_ => new Uint32(Math.floor(Math.random() * 255)));
+}
+
 export function randomMemoryUint64s(length: number): Uint64[] {
   return [...Array(length)].map(_ => new Uint64(Math.floor(Math.random() * 255)));
 }

package/src/avm/journal/index.ts

@@ -1,2 +1 @@
-export * from './host_storage.js';
 export * from './journal.js';

package/src/avm/journal/journal.ts

@@ -3,11 +3,11 @@ import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { SerializableContractInstance } from '@aztec/types/contracts';
 
+import { type WorldStateDB } from '../../public/public_db_sources.js';
 import { type TracedContractInstance } from '../../public/side_effect_trace.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
 import { type AvmContractCallResult } from '../avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { type HostStorage } from './host_storage.js';
 import { NullifierManager } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
 
@@ -25,7 +25,7 @@ export class AvmPersistableStateManager {
 
   constructor(
     /** Reference to node storage */
-    private readonly hostStorage: HostStorage,
+    private readonly worldStateDB: WorldStateDB,
     /** Side effect trace */
     private readonly trace: PublicSideEffectTraceInterface,
     /** Public storage, including cached writes */
@@ -39,18 +39,15 @@ export class AvmPersistableStateManager {
    * Create a new state manager with some preloaded pending siloed nullifiers
    */
   public static newWithPendingSiloedNullifiers(
-    hostStorage: HostStorage,
+    worldStateDB: WorldStateDB,
     trace: PublicSideEffectTraceInterface,
     pendingSiloedNullifiers: Fr[],
   ) {
-    const parentNullifiers = NullifierManager.newWithPendingSiloedNullifiers(
-      hostStorage.commitmentsDb,
-      pendingSiloedNullifiers,
-    );
+    const parentNullifiers = NullifierManager.newWithPendingSiloedNullifiers(worldStateDB, pendingSiloedNullifiers);
     return new AvmPersistableStateManager(
-      hostStorage,
+      worldStateDB,
       trace,
-      /*publicStorage=*/ new PublicStorage(hostStorage.publicStateDb),
+      /*publicStorage=*/ new PublicStorage(worldStateDB),
       /*nullifiers=*/ parentNullifiers.fork(),
     );
   }
@@ -60,7 +57,7 @@ export class AvmPersistableStateManager {
    */
   public fork() {
     return new AvmPersistableStateManager(
-      this.hostStorage,
+      this.worldStateDB,
       this.trace.fork(),
       this.publicStorage.fork(),
       this.nullifiers.fork(),
@@ -122,7 +119,7 @@ export class AvmPersistableStateManager {
    * @returns true if the note hash exists at the given leaf index, false otherwise
    */
   public async checkNoteHashExists(storageAddress: Fr, noteHash: Fr, leafIndex: Fr): Promise<boolean> {
-    const gotLeafValue = (await this.hostStorage.commitmentsDb.getCommitmentValue(leafIndex.toBigInt())) ?? Fr.ZERO;
+    const gotLeafValue = (await this.worldStateDB.getCommitmentValue(leafIndex.toBigInt())) ?? Fr.ZERO;
     const exists = gotLeafValue.equals(noteHash);
     this.log.debug(
       `noteHashes(${storageAddress})@${noteHash} ?? leafIndex: ${leafIndex} | gotLeafValue: ${gotLeafValue}, exists: ${exists}.`,
@@ -177,7 +174,7 @@ export class AvmPersistableStateManager {
    * @returns exists - whether the message exists in the L1 to L2 Messages tree
    */
   public async checkL1ToL2MessageExists(contractAddress: Fr, msgHash: Fr, msgLeafIndex: Fr): Promise<boolean> {
-    const valueAtIndex = (await this.hostStorage.commitmentsDb.getL1ToL2LeafValue(msgLeafIndex.toBigInt())) ?? Fr.ZERO;
+    const valueAtIndex = (await this.worldStateDB.getL1ToL2LeafValue(msgLeafIndex.toBigInt())) ?? Fr.ZERO;
     const exists = valueAtIndex.equals(msgHash);
     this.log.debug(
       `l1ToL2Messages(@${msgLeafIndex}) ?? exists: ${exists}, expected: ${msgHash}, found: ${valueAtIndex}.`,
@@ -217,7 +214,7 @@ export class AvmPersistableStateManager {
   public async getContractInstance(contractAddress: Fr): Promise<TracedContractInstance> {
     let exists = true;
     const aztecAddress = AztecAddress.fromField(contractAddress);
-    let instance = await this.hostStorage.contractsDb.getContractInstance(aztecAddress);
+    let instance = await this.worldStateDB.getContractInstance(aztecAddress);
     if (instance === undefined) {
       instance = SerializableContractInstance.empty().withAddress(aztecAddress);
       exists = false;
@@ -242,7 +239,7 @@ export class AvmPersistableStateManager {
    * Get a contract's bytecode from the contracts DB
    */
   public async getBytecode(contractAddress: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
-    return await this.hostStorage.contractsDb.getBytecode(contractAddress, selector);
+    return await this.worldStateDB.getBytecode(contractAddress, selector);
   }
 
   /**
@@ -260,10 +257,8 @@ export class AvmPersistableStateManager {
       this.acceptNestedCallState(nestedState);
     }
     const functionName =
-      (await nestedState.hostStorage.contractsDb.getDebugFunctionName(
-        nestedEnvironment.address,
-        nestedEnvironment.functionSelector,
-      )) ?? `${nestedEnvironment.address}:${nestedEnvironment.functionSelector}`;
+      (await this.worldStateDB.getDebugFunctionName(nestedEnvironment.address, nestedEnvironment.functionSelector)) ??
+      `${nestedEnvironment.address}:${nestedEnvironment.functionSelector}`;
 
     this.log.verbose(`[AVM] Calling nested function ${functionName}`);
 

package/src/avm/opcodes/bitwise.ts

@@ -1,8 +1,9 @@
 import type { AvmContext } from '../avm_context.js';
-import { type IntegralValue, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
-import { Opcode } from '../serialization/instruction_serialization.js';
+import { type IntegralValue, TaggedMemory, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
-import { ThreeOperandInstruction, TwoOperandInstruction } from './instruction_impl.js';
+import { Instruction } from './instruction.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
 
 abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
   public async execute(context: AvmContext): Promise<void> {
@@ -85,12 +86,15 @@ export class Shr extends ThreeOperandBitwiseInstruction {
   }
 }
 
-export class Not extends TwoOperandInstruction {
+export class Not extends Instruction {
   static readonly type: string = 'NOT';
   static readonly opcode = Opcode.NOT_8;
 
-  constructor(indirect: number, inTag: number, aOffset: number, dstOffset: number) {
-    super(indirect, inTag, aOffset, dstOffset);
+  static readonly wireFormat8 = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT8, OperandType.UINT8];
+  static readonly wireFormat16 = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
+
+  constructor(private indirect: number, private srcOffset: number, private dstOffset: number) {
+    super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
@@ -98,11 +102,11 @@ export class Not extends TwoOperandInstruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const [aOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.dstOffset], memory);
-    memory.checkTags(this.inTag, aOffset);
-    const a = memory.getAs<IntegralValue>(aOffset);
+    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.srcOffset, this.dstOffset], memory);
+    TaggedMemory.checkIsIntegralTag(memory.getTag(srcOffset));
+    const value = memory.getAs<IntegralValue>(srcOffset);
 
-    const res = a.not();
+    const res = value.not();
     memory.set(dstOffset, res);
 
     memory.assert(memoryOperations);

package/src/avm/opcodes/commitment.ts

@@ -47,7 +47,7 @@ export class PedersenCommitment extends Instruction {
     memory.checkTag(TypeTag.UINT32, genIndexOffset);
 
     const memoryOperations = { reads: inputSize + 2, writes: 3, indirect: this.indirect };
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: inputSize }));
 
     const inputBuffer: Buffer[] = inputs.map(input => input.toBuffer());
     // TODO: Add the generate index to the pedersenCommit function

package/src/avm/opcodes/comparators.ts

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { type MemoryValue, Uint8 } from '../avm_memory_types.js';
+import { type MemoryValue, Uint1 } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
@@ -19,7 +19,7 @@ abstract class ComparatorInstruction extends ThreeOperandInstruction {
     const a = memory.get(aOffset);
     const b = memory.get(bOffset);
 
-    const dest = new Uint8(this.compare(a, b) ? 1 : 0);
+    const dest = new Uint1(this.compare(a, b) ? 1 : 0);
     memory.set(dstOffset, dest);
 
     memory.assert(memoryOperations);

package/src/avm/opcodes/conversion.ts

@@ -1,7 +1,6 @@
-import { strict as assert } from 'assert';
-
 import { type AvmContext } from '../avm_context.js';
-import { TypeTag, Uint8 } from '../avm_memory_types.js';
+import { TypeTag, Uint1, Uint8 } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -16,32 +15,41 @@ export class ToRadixLE extends Instruction {
     OperandType.UINT8, // Indirect
     OperandType.UINT32, // src memory address
     OperandType.UINT32, // dst memory address
-    OperandType.UINT32, // radix (immediate)
+    OperandType.UINT32, // radix memory address
     OperandType.UINT32, // number of limbs (Immediate)
+    OperandType.UINT1, // output is in "bits" mode (Immediate - Uint1 still takes up a whole byte)
   ];
 
   constructor(
     private indirect: number,
     private srcOffset: number,
     private dstOffset: number,
-    private radix: number,
+    private radixOffset: number,
     private numLimbs: number,
+    private outputBits: number, // effectively a bool
   ) {
-    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 };
+    const [srcOffset, dstOffset, radixOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.srcOffset, this.dstOffset, this.radixOffset],
+      memory,
+    );
+    const memoryOperations = { reads: 2, writes: this.numLimbs, indirect: this.indirect };
     context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.numLimbs }));
 
     // The radix gadget only takes in a Field
     memory.checkTag(TypeTag.FIELD, srcOffset);
+    memory.checkTag(TypeTag.UINT32, radixOffset);
 
     let value: bigint = memory.get(srcOffset).toBigInt();
-    const radixBN: bigint = BigInt(this.radix);
+    const radix: bigint = memory.get(radixOffset).toBigInt();
+    if (radix > 256) {
+      throw new InstructionExecutionError(`ToRadixLE instruction's radix should be <= 256 (was ${radix})`);
+    }
+    const radixBN: bigint = BigInt(radix);
     const limbArray = [];
 
     for (let i = 0; i < this.numLimbs; i++) {
@@ -50,7 +58,8 @@ export class ToRadixLE extends Instruction {
       value /= radixBN;
     }
 
-    const res = limbArray.map(byte => new Uint8(byte));
+    const outputType = this.outputBits != 0 ? Uint1 : Uint8;
+    const res = limbArray.map(byte => new outputType(byte));
     memory.setSlice(dstOffset, res);
 
     memory.assert(memoryOperations);