feat(avm-simulator): add to_radix_le instruction

avm-transpiler/src/opcodes.rs

@@ -69,6 +69,8 @@ pub enum AvmOpcode {
     POSEIDON2,
     SHA256,   // temp - may be removed, but alot of contracts rely on it
     PEDERSEN, // temp - may be removed, but alot of contracts rely on it
+    // Conversions
+    TORADIXLE,
 }
 
 impl AvmOpcode {
@@ -155,6 +157,8 @@ impl AvmOpcode {
             AvmOpcode::POSEIDON2 => "POSEIDON2",
             AvmOpcode::SHA256 => "SHA256 ",
             AvmOpcode::PEDERSEN => "PEDERSEN",
+            // Conversions
+            AvmOpcode::TORADIXLE => "TORADIXLE",
         }
     }
 }

barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_opcode.hpp

@@ -96,6 +96,9 @@ enum class OpCode : uint8_t {
     KECCAK,
     POSEIDON2,
 
+    // Conversions
+    TORADIXLE,
+
     // Sentinel
     LAST_OPCODE_SENTINEL,
 };

docs/src/preprocess/InstructionSet/InstructionSet.js

@@ -1537,6 +1537,39 @@ halt
     "Tag checks": "",
     "Tag updates": "",
   },
+  {
+    id: "to_radix_le",
+    Name: "`TORADIXLE`",
+    Category: "Conversions",
+    Flags: [{ name: "indirect", description: INDIRECT_FLAG_DESCRIPTION }],
+    Args: [
+      {
+        name: "srcOffset",
+        description: "memory offset of word to convert.",
+      },
+      {
+        name: "dstOffset",
+        description: "memory offset specifying where the first limb of the radix-conversion result is stored.",
+      },
+      {
+        name: "radix",
+        description: "the maximum bit-size of each limb.",
+        mode: "immediate",
+        type: "u32",
+      },
+      {
+        name: "numLimbs",
+        description: "the number of limbs the word will be converted into.",
+        type: "u32",
+        mode: "immediate",
+      }
+    ],
+
+    Expression: `TBD: Storage of limbs and if T[dstOffset] is constrained to U8`,
+    Summary: "Convert a word to an array of limbs in little-endian radix form",
+    Details: "The limbs will be stored in a contiguous memory block starting at `dstOffset`.",
+    "Tag checks": "`T[srcOffset] == field`",
+  }
 ];
 const INSTRUCTION_SET = INSTRUCTION_SET_RAW.map((instr) => {
   instr["Bit-size"] = instructionSize(instr);

yarn-project/simulator/src/avm/avm_gas.ts

@@ -123,6 +123,8 @@ export const GasCosts: Record<Opcode, Gas | typeof DynamicGasCost> = {
   [Opcode.POSEIDON2]: TemporaryDefaultGasCost,
   [Opcode.SHA256]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,
   [Opcode.PEDERSEN]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,t
+  // Conversions
+  [Opcode.TORADIXLE]: TemporaryDefaultGasCost,
 };
 
 /** Returns the fixed base gas cost for a given opcode, or throws if set to dynamic. */

yarn-project/simulator/src/avm/opcodes/conversion.test.ts

@@ -0,0 +1,90 @@
+import { type AvmContext } from '../avm_context.js';
+import { Field, type Uint8, Uint32 } from '../avm_memory_types.js';
+import { initContext } from '../fixtures/index.js';
+import { Addressing, AddressingMode } from './addressing_mode.js';
+import { ToRadixLE } from './conversion.js';
+
+describe('Conversion Opcodes', () => {
+  let context: AvmContext;
+
+  beforeEach(async () => {
+    context = initContext();
+  });
+
+  describe('To Radix LE', () => {
+    it('Should (de)serialize correctly', () => {
+      const buf = Buffer.from([
+        ToRadixLE.opcode, // opcode
+        1, // indirect
+        ...Buffer.from('12345678', 'hex'), // inputStateOffset
+        ...Buffer.from('23456789', 'hex'), // outputStateOffset
+        ...Buffer.from('00000002', 'hex'), // radix
+        ...Buffer.from('00000100', 'hex'), // numLimbs
+      ]);
+      const inst = new ToRadixLE(
+        /*indirect=*/ 1,
+        /*srcOffset=*/ 0x12345678,
+        /*dstOffset=*/ 0x23456789,
+        /*radix=*/ 2,
+        /*numLimbs=*/ 256,
+      );
+
+      expect(ToRadixLE.deserialize(buf)).toEqual(inst);
+      expect(inst.serialize()).toEqual(buf);
+    });
+
+    it('Should decompose correctly - direct', async () => {
+      const arg = new Field(0b1011101010100n);
+      const indirect = 0;
+      const srcOffset = 0;
+      const radix = 2; // Bit decomposition
+      const numLimbs = 10; // only the first 10 bits
+      const dstOffset = 20;
+      context.machineState.memory.set(srcOffset, arg);
+
+      await new ToRadixLE(indirect, srcOffset, dstOffset, radix, numLimbs).execute(context);
+
+      const resultBuffer: Buffer = Buffer.concat(
+        context.machineState.memory.getSliceAs<Uint8>(dstOffset, numLimbs).map(byte => byte.toBuffer()),
+      );
+      // The expected result is the first 10 bits of the input, reversed
+      const expectedResults = '1011101010100'.split('').reverse().slice(0, numLimbs).map(Number);
+      for (let i = 0; i < numLimbs; i++) {
+        expect(resultBuffer.readUInt8(i)).toEqual(expectedResults[i]);
+      }
+    });
+
+    it('Should decompose correctly - indirect', async () => {
+      const arg = new Field(Buffer.from('1234567890abcdef', 'hex'));
+      const indirect = new Addressing([
+        /*srcOffset=*/ AddressingMode.INDIRECT,
+        /*dstOffset*/ AddressingMode.INDIRECT,
+      ]).toWire();
+      const srcOffset = 0;
+      const srcOffsetReal = 10;
+      const dstOffset = 2;
+      const dstOffsetReal = 30;
+      context.machineState.memory.set(srcOffset, new Uint32(srcOffsetReal));
+      context.machineState.memory.set(dstOffset, new Uint32(dstOffsetReal));
+      context.machineState.memory.set(srcOffsetReal, arg);
+
+      const radix = 1 << 8; // Byte decomposition
+      const numLimbs = 32; // 256-bit decomposition
+      await new ToRadixLE(indirect, srcOffset, dstOffset, radix, numLimbs).execute(context);
+
+      const resultBuffer: Buffer = Buffer.concat(
+        context.machineState.memory.getSliceAs<Uint8>(dstOffsetReal, numLimbs).map(byte => byte.toBuffer()),
+      );
+      // The expected result is the input (padded to 256 bits),and reversed
+      const expectedResults = '1234567890abcdef'
+        .padStart(64, '0')
+        .split('')
+        .reverse()
+        .map(a => parseInt(a, 16));
+      // Checking the value in each byte of the buffer is correct
+      for (let i = 0; i < numLimbs; i++) {
+        expect(resultBuffer.readUInt8(i)).toEqual(expectedResults[2 * i] + expectedResults[2 * i + 1] * 16);
+      }
+    });
+  });
+});

yarn-project/simulator/src/avm/opcodes/conversion.ts

@@ -0,0 +1,58 @@
+import { assert } from '../../../../foundation/src/json-rpc/js_utils.js';
+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();
+  }
+}

yarn-project/simulator/src/avm/serialization/instruction_serialization.ts

@@ -74,6 +74,8 @@ export enum Opcode {
   POSEIDON2,
   SHA256, // temp - may be removed, but alot of contracts rely on it
   PEDERSEN, // temp - may be removed, but alot of contracts rely on it
+  // Conversion
+  TORADIXLE,
 }
 
 // Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.