@aztec/simulator 0.59.0 → 0.61.0

package/src/avm/opcodes/accrued_substate.ts

@@ -39,11 +39,7 @@ export class NoteHashExists extends Instruction {
     const noteHash = memory.get(noteHashOffset).toFr();
     const leafIndex = memory.get(leafIndexOffset).toFr();
 
-    const exists = await context.persistableState.checkNoteHashExists(
-      context.environment.storageAddress,
-      noteHash,
-      leafIndex,
-    );
+    const exists = await context.persistableState.checkNoteHashExists(context.environment.address, noteHash, leafIndex);
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
 
     memory.assert({ reads: 2, writes: 1, addressing });
@@ -75,7 +71,7 @@ export class EmitNoteHash extends Instruction {
     }
 
     const noteHash = memory.get(noteHashOffset).toFr();
-    context.persistableState.writeNoteHash(context.environment.storageAddress, noteHash);
+    context.persistableState.writeNoteHash(context.environment.address, noteHash);
 
     memory.assert({ reads: 1, addressing });
     context.machineState.incrementPc();
@@ -148,12 +144,12 @@ export class EmitNullifier extends Instruction {
 
     const nullifier = memory.get(nullifierOffset).toFr();
     try {
-      await context.persistableState.writeNullifier(context.environment.storageAddress, nullifier);
+      await context.persistableState.writeNullifier(context.environment.address, nullifier);
     } catch (e) {
       if (e instanceof NullifierCollisionError) {
         // Error is known/expected, raise as InstructionExecutionError that the will lead the simulator to revert this call
         throw new InstructionExecutionError(
-          `Attempted to emit duplicate nullifier ${nullifier} (storage address: ${context.environment.storageAddress}).`,
+          `Attempted to emit duplicate nullifier ${nullifier} (contract address: ${context.environment.address}).`,
         );
       } else {
         throw e;

package/src/avm/opcodes/contract.ts

@@ -1,23 +1,36 @@
-import { Fr } from '@aztec/circuits.js';
-
 import type { AvmContext } from '../avm_context.js';
-import { Field, TypeTag } from '../avm_memory_types.js';
+import { Field, TypeTag, Uint1 } 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';
 
+export enum ContractInstanceMember {
+  DEPLOYER,
+  CLASS_ID,
+  INIT_HASH,
+}
+
 export class GetContractInstance extends Instruction {
   static readonly type: string = 'GETCONTRACTINSTANCE';
   static readonly opcode: Opcode = Opcode.GETCONTRACTINSTANCE;
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect bits
+    OperandType.UINT8, // member enum (immediate)
+    OperandType.UINT16, // addressOffset
+    OperandType.UINT16, // dstOffset
+    OperandType.UINT16, // existsOfsset
   ];
 
-  constructor(private indirect: number, private addressOffset: number, private dstOffset: number) {
+  constructor(
+    private indirect: number,
+    private memberEnum: number,
+    private addressOffset: number,
+    private dstOffset: number,
+    private existsOffset: number,
+  ) {
     super();
   }
 
@@ -25,27 +38,38 @@ export class GetContractInstance extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost());
 
-    const operands = [this.addressOffset, this.dstOffset];
+    if (!(this.memberEnum in ContractInstanceMember)) {
+      throw new InstructionExecutionError(`Invalid GETCONSTRACTINSTANCE member enum ${this.memberEnum}`);
+    }
+
+    const operands = [this.addressOffset, this.dstOffset, this.existsOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [addressOffset, dstOffset] = addressing.resolve(operands, memory);
+    const [addressOffset, dstOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, addressOffset);
 
     const address = memory.get(addressOffset).toFr();
     const instance = await context.persistableState.getContractInstance(address);
+    const exists = instance !== undefined;
 
-    const data = [
-      new Fr(instance.exists),
-      instance.salt,
-      instance.deployer.toField(),
-      instance.contractClassId,
-      instance.initializationHash,
-      // This this okay ?
-      ...instance.publicKeys.toFields(),
-    ].map(f => new Field(f));
+    let memberValue = new Field(0);
+    if (exists) {
+      switch (this.memberEnum as ContractInstanceMember) {
+        case ContractInstanceMember.DEPLOYER:
+          memberValue = new Field(instance.deployer.toField());
+          break;
+        case ContractInstanceMember.CLASS_ID:
+          memberValue = new Field(instance.contractClassId.toField());
+          break;
+        case ContractInstanceMember.INIT_HASH:
+          memberValue = new Field(instance.initializationHash);
+          break;
+      }
+    }
 
-    memory.setSlice(dstOffset, data);
+    memory.set(existsOffset, new Uint1(exists ? 1 : 0));
+    memory.set(dstOffset, memberValue);
 
-    memory.assert({ reads: 1, writes: 17, addressing });
+    memory.assert({ reads: 1, writes: 2, addressing });
     context.machineState.incrementPc();
   }
 }

package/src/avm/opcodes/conversion.ts

@@ -5,9 +5,9 @@ import { Opcode, OperandType } from '../serialization/instruction_serialization.
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
-export class ToRadixLE extends Instruction {
+export class ToRadixBE extends Instruction {
   static type: string = 'TORADIXLE';
-  static readonly opcode: Opcode = Opcode.TORADIXLE;
+  static readonly opcode: Opcode = Opcode.TORADIXBE;
 
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
@@ -44,15 +44,18 @@ export class ToRadixLE extends Instruction {
 
     let value: bigint = memory.get(srcOffset).toBigInt();
     const radix: bigint = memory.get(radixOffset).toBigInt();
+    if (this.numLimbs < 1) {
+      throw new InstructionExecutionError(`ToRadixBE instruction's numLimbs should be > 0 (was ${this.numLimbs})`);
+    }
     if (radix > 256) {
-      throw new InstructionExecutionError(`ToRadixLE instruction's radix should be <= 256 (was ${radix})`);
+      throw new InstructionExecutionError(`ToRadixBE instruction's radix should be <= 256 (was ${radix})`);
     }
     const radixBN: bigint = BigInt(radix);
-    const limbArray = [];
+    const limbArray = new Array(this.numLimbs);
 
-    for (let i = 0; i < this.numLimbs; i++) {
+    for (let i = this.numLimbs - 1; i >= 0; i--) {
       const limb = value % radixBN;
-      limbArray.push(limb);
+      limbArray[i] = limb;
       value /= radixBN;
     }
 

package/src/avm/opcodes/environment_getters.ts

@@ -1,12 +1,12 @@
 import type { AvmContext } from '../avm_context.js';
 import { Field, Uint32, Uint64 } 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';
 
 export enum EnvironmentVariable {
   ADDRESS,
-  STORAGEADDRESS,
   SENDER,
   FUNCTIONSELECTOR,
   TRANSACTIONFEE,
@@ -25,8 +25,6 @@ function getValue(e: EnvironmentVariable, ctx: AvmContext) {
   switch (e) {
     case EnvironmentVariable.ADDRESS:
       return new Field(ctx.environment.address.toField());
-    case EnvironmentVariable.STORAGEADDRESS:
-      return new Field(ctx.environment.storageAddress.toField());
     case EnvironmentVariable.SENDER:
       return new Field(ctx.environment.sender.toField());
     case EnvironmentVariable.FUNCTIONSELECTOR:
@@ -66,7 +64,7 @@ export class GetEnvVar extends Instruction {
     OperandType.UINT16, // dstOffset
   ];
 
-  constructor(private indirect: number, private varEnum: EnvironmentVariable, private dstOffset: number) {
+  constructor(private indirect: number, private varEnum: number, private dstOffset: number) {
     super();
   }
 
@@ -74,11 +72,15 @@ export class GetEnvVar extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost());
 
+    if (!(this.varEnum in EnvironmentVariable)) {
+      throw new InstructionExecutionError(`Invalid GETENVVAR var enum ${this.varEnum}`);
+    }
+
     const operands = [this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
 
-    memory.set(dstOffset, getValue(this.varEnum, context));
+    memory.set(dstOffset, getValue(this.varEnum as EnvironmentVariable, context));
 
     memory.assert({ writes: 1, addressing });
     context.machineState.incrementPc();

package/src/avm/opcodes/external_calls.ts

@@ -1,10 +1,9 @@
-import { FunctionSelector, Gas } from '@aztec/circuits.js';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr, FunctionSelector, Gas, PUBLIC_DISPATCH_SELECTOR } from '@aztec/circuits.js';
 
 import type { AvmContext } from '../avm_context.js';
 import { type AvmContractCallResult } from '../avm_contract_call_result.js';
 import { gasLeftToGas } from '../avm_gas.js';
-import { Field, TypeTag, Uint8 } from '../avm_memory_types.js';
+import { type Field, TypeTag, Uint1 } from '../avm_memory_types.js';
 import { AvmSimulator } from '../avm_simulator.js';
 import { RethrownError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
@@ -21,58 +20,39 @@ abstract class ExternalCall extends Instruction {
     OperandType.UINT16,
     OperandType.UINT16,
     OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
   ];
 
   constructor(
     private indirect: number,
-    private gasOffset: number /* Unused due to no formal gas implementation at this moment */,
+    private gasOffset: number,
     private addrOffset: number,
     private argsOffset: number,
     private argsSizeOffset: number,
-    private retOffset: number,
-    private retSize: number,
     private successOffset: number,
-    // NOTE: Function selector is likely temporary since eventually public contract bytecode will be one
-    // blob containing all functions, and function selector will become an application-level mechanism
-    // (e.g. first few bytes of calldata + compiler-generated jump table)
-    private functionSelectorOffset: number,
   ) {
     super();
   }
 
   public async execute(context: AvmContext) {
     const memory = context.machineState.memory.track(this.type);
-    const operands = [
-      this.gasOffset,
-      this.addrOffset,
-      this.argsOffset,
-      this.argsSizeOffset,
-      this.retOffset,
-      this.successOffset,
-      this.functionSelectorOffset,
-    ];
+    const operands = [this.gasOffset, this.addrOffset, this.argsOffset, this.argsSizeOffset, this.successOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [gasOffset, addrOffset, argsOffset, argsSizeOffset, retOffset, successOffset, functionSelectorOffset] =
-      addressing.resolve(operands, memory);
+    const [gasOffset, addrOffset, argsOffset, argsSizeOffset, successOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, gasOffset, gasOffset + 1);
     memory.checkTag(TypeTag.FIELD, addrOffset);
     memory.checkTag(TypeTag.UINT32, argsSizeOffset);
-    memory.checkTag(TypeTag.FIELD, functionSelectorOffset);
 
     const calldataSize = memory.get(argsSizeOffset).toNumber();
     memory.checkTagsRange(TypeTag.FIELD, argsOffset, calldataSize);
 
     const callAddress = memory.getAs<Field>(addrOffset);
     const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
-    const functionSelector = memory.getAs<Field>(functionSelectorOffset).toFr();
+    const functionSelector = new Fr(PUBLIC_DISPATCH_SELECTOR);
     // If we are already in a static call, we propagate the environment.
     const callType = context.environment.isStaticCall ? 'STATICCALL' : this.type;
 
     // First we consume the gas for this operation.
-    context.machineState.consumeGas(this.gasCost(calldataSize + this.retSize));
+    context.machineState.consumeGas(this.gasCost(calldataSize));
     // Then we consume the gas allocated for the nested call. The excess will be refunded later.
     // Gas allocation is capped by the amount of gas left in the current context.
     // We have to do some dancing here because the gas allocation is a field,
@@ -106,18 +86,12 @@ abstract class ExternalCall extends Instruction {
       throw new RethrownError(nestedCallResults.revertReason.message, nestedCallResults.revertReason);
     }
 
-    // We only take as much data as was specified in the return size and pad with zeroes if the return data is smaller
-    // than the specified size in order to prevent that memory to be left with garbage
-    const returnData = nestedCallResults.output.slice(0, this.retSize);
-    const convertedReturnData = padArrayEnd(
-      returnData.map(f => new Field(f)),
-      new Field(0),
-      this.retSize,
-    );
+    // Save return/revert data for later.
+    const fullReturnData = nestedCallResults.output;
+    context.machineState.nestedReturndata = fullReturnData;
 
-    // Write our return data into memory
-    memory.set(successOffset, new Uint8(success ? 1 : 0));
-    memory.setSlice(retOffset, convertedReturnData);
+    // Write our success flag into memory.
+    memory.set(successOffset, new Uint1(success ? 1 : 0));
 
     // Refund unused gas
     context.machineState.refundGas(gasLeftToGas(nestedContext.machineState));
@@ -132,7 +106,7 @@ abstract class ExternalCall extends Instruction {
       /*avmCallResults=*/ nestedCallResults,
     );
 
-    memory.assert({ reads: calldataSize + 5, writes: 1 + this.retSize, addressing });
+    memory.assert({ reads: calldataSize + 4, writes: 1, addressing });
     context.machineState.incrementPc();
   }
 
@@ -204,22 +178,24 @@ export class Revert extends Instruction {
     OperandType.UINT16,
   ];
 
-  constructor(private indirect: number, private returnOffset: number, private retSize: number) {
+  constructor(private indirect: number, private returnOffset: number, private retSizeOffset: number) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(this.retSize));
 
-    const operands = [this.returnOffset];
+    const operands = [this.returnOffset, this.retSizeOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [returnOffset] = addressing.resolve(operands, memory);
+    const [returnOffset, retSizeOffset] = addressing.resolve(operands, memory);
 
-    const output = memory.getSlice(returnOffset, this.retSize).map(word => word.toFr());
+    memory.checkTag(TypeTag.UINT32, retSizeOffset);
+    const retSize = memory.get(retSizeOffset).toNumber();
+    context.machineState.consumeGas(this.gasCost(retSize));
+    const output = memory.getSlice(returnOffset, retSize).map(word => word.toFr());
 
     context.machineState.revert(output);
-    memory.assert({ reads: this.retSize, addressing });
+    memory.assert({ reads: retSize + 1, addressing });
   }
 }
 

package/src/avm/opcodes/hashing.ts

@@ -1,15 +1,7 @@
-import {
-  keccak256,
-  keccakf1600,
-  pedersenHash,
-  poseidon2Permutation,
-  sha256Compression,
-} from '@aztec/foundation/crypto';
-
-import { strict as assert } from 'assert';
+import { keccakf1600, poseidon2Permutation, sha256Compression } from '@aztec/foundation/crypto';
 
 import { type AvmContext } from '../avm_context.js';
-import { Field, TypeTag, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
+import { Field, TypeTag, Uint32, Uint64 } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -52,52 +44,6 @@ export class Poseidon2 extends Instruction {
   }
 }
 
-export class Keccak extends Instruction {
-  static type: string = 'KECCAK';
-  static readonly opcode: Opcode = Opcode.KECCAK;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
-
-  constructor(
-    private indirect: number,
-    private dstOffset: number,
-    private messageOffset: number,
-    private messageSizeOffset: number,
-  ) {
-    super();
-  }
-
-  // pub fn keccak256(input: [u8], message_size: u32) -> [u8; 32]
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
-    const operands = [this.dstOffset, this.messageOffset, this.messageSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [dstOffset, messageOffset, messageSizeOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.UINT32, messageSizeOffset);
-    const messageSize = memory.get(messageSizeOffset).toNumber();
-    context.machineState.consumeGas(this.gasCost(messageSize));
-
-    memory.checkTagsRange(TypeTag.UINT8, messageOffset, messageSize);
-
-    const messageData = Buffer.concat(memory.getSlice(messageOffset, messageSize).map(word => word.toBuffer()));
-    const hashBuffer = keccak256(messageData);
-
-    // We need to convert the hashBuffer because map doesn't work as expected on an Uint8Array (Buffer).
-    const res = [...hashBuffer].map(byte => new Uint8(byte));
-    memory.setSlice(dstOffset, res);
-
-    memory.assert({ reads: messageSize + 1, writes: 32, addressing });
-    context.machineState.incrementPc();
-  }
-}
-
 export class KeccakF1600 extends Instruction {
   static type: string = 'KECCAKF1600';
   static readonly opcode: Opcode = Opcode.KECCAKF1600;
@@ -108,39 +54,30 @@ export class KeccakF1600 extends Instruction {
     OperandType.UINT8,
     OperandType.UINT16,
     OperandType.UINT16,
-    OperandType.UINT16,
   ];
 
-  constructor(
-    private indirect: number,
-    private dstOffset: number,
-    private stateOffset: number,
-    // This is here for compatibility with the CPP side. Should be removed in both.
-    private stateSizeOffset: number,
-  ) {
+  constructor(private indirect: number, private dstOffset: number, private inputOffset: number) {
     super();
   }
 
   // pub fn keccakf1600(input: [u64; 25]) -> [u64; 25]
   public async execute(context: AvmContext): Promise<void> {
+    const inputSize = 25;
     const memory = context.machineState.memory.track(this.type);
-    const operands = [this.dstOffset, this.stateOffset, this.stateSizeOffset];
+    const operands = [this.dstOffset, this.inputOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [dstOffset, stateOffset, stateSizeOffset] = addressing.resolve(operands, memory);
-    memory.checkTag(TypeTag.UINT32, stateSizeOffset);
-    const stateSize = memory.get(stateSizeOffset).toNumber();
-    assert(stateSize === 25, 'Invalid state size for keccakf1600');
+    const [dstOffset, inputOffset] = addressing.resolve(operands, memory);
     context.machineState.consumeGas(this.gasCost());
 
-    memory.checkTagsRange(TypeTag.UINT64, stateOffset, stateSize);
+    memory.checkTagsRange(TypeTag.UINT64, inputOffset, inputSize);
 
-    const stateData = memory.getSlice(stateOffset, stateSize).map(word => word.toBigInt());
+    const stateData = memory.getSlice(inputOffset, inputSize).map(word => word.toBigInt());
     const updatedState = keccakf1600(stateData);
 
     const res = updatedState.map(word => new Uint64(word));
     memory.setSlice(dstOffset, res);
 
-    memory.assert({ reads: stateSize + 1, writes: 25, addressing });
+    memory.assert({ reads: inputSize, writes: inputSize, addressing });
     context.machineState.incrementPc();
   }
 }
@@ -193,53 +130,3 @@ export class Sha256Compression extends Instruction {
     context.machineState.incrementPc();
   }
 }
-
-export class Pedersen extends Instruction {
-  static type: string = 'PEDERSEN';
-  static readonly opcode: Opcode = Opcode.PEDERSEN;
-
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
-
-  constructor(
-    private indirect: number,
-    private genIndexOffset: number,
-    private dstOffset: number,
-    private messageOffset: number,
-    private messageSizeOffset: number,
-  ) {
-    super();
-  }
-
-  public async execute(context: AvmContext): Promise<void> {
-    const memory = context.machineState.memory.track(this.type);
-    const operands = [this.genIndexOffset, this.dstOffset, this.messageOffset, this.messageSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [genIndexOffset, dstOffset, messageOffset, messageSizeOffset] = addressing.resolve(operands, memory);
-
-    // We hash a set of field elements
-    const genIndex = Number(memory.get(genIndexOffset).toBigInt());
-    memory.checkTag(TypeTag.UINT32, genIndexOffset);
-    const messageSize = Number(memory.get(messageSizeOffset).toBigInt());
-    memory.checkTag(TypeTag.UINT32, messageSizeOffset);
-    const hashData = memory.getSlice(messageOffset, messageSize);
-
-    context.machineState.consumeGas(this.gasCost(messageSize));
-
-    memory.checkTagsRange(TypeTag.FIELD, messageOffset, messageSize);
-
-    // No domain sep for now
-    const hash = pedersenHash(hashData, genIndex);
-    memory.set(dstOffset, new Field(hash));
-
-    memory.assert({ reads: messageSize + 2, writes: 1, addressing });
-    context.machineState.incrementPc();
-  }
-}

package/src/avm/opcodes/index.ts

@@ -13,4 +13,3 @@ export * from './environment_getters.js';
 export * from './accrued_substate.js';
 export * from './hashing.js';
 export * from './ec_add.js';
-export * from './commitment.js';

package/src/avm/opcodes/memory.ts

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { Field, TaggedMemory } from '../avm_memory_types.js';
+import { Field, TaggedMemory, TypeTag, Uint32 } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -179,11 +179,11 @@ export class CalldataCopy extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    // We don't need to check tags here because: (1) the calldata is NOT in memory, and (2) we are the ones writing to destination.
     const operands = [this.cdStartOffset, this.copySizeOffset, this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [cdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
 
+    memory.checkTags(TypeTag.UINT32, cdStartOffset, copySizeOffset);
     const cdStart = memory.get(cdStartOffset).toNumber();
     const copySize = memory.get(copySizeOffset).toNumber();
     context.machineState.consumeGas(this.gasCost(copySize));
@@ -196,3 +196,70 @@ export class CalldataCopy extends Instruction {
     context.machineState.incrementPc();
   }
 }
+
+export class ReturndataSize extends Instruction {
+  static readonly type: string = 'RETURNDATASIZE';
+  static readonly opcode: Opcode = Opcode.RETURNDATASIZE;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
+
+  constructor(private indirect: number, private dstOffset: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory.track(this.type);
+    const operands = [this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [dstOffset] = addressing.resolve(operands, memory);
+    context.machineState.consumeGas(this.gasCost());
+
+    memory.set(dstOffset, new Uint32(context.machineState.nestedReturndata.length));
+
+    memory.assert({ writes: 1, addressing });
+    context.machineState.incrementPc();
+  }
+}
+
+export class ReturndataCopy extends Instruction {
+  static readonly type: string = 'RETURNDATACOPY';
+  static readonly opcode: Opcode = Opcode.RETURNDATACOPY;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+  ];
+
+  constructor(
+    private indirect: number,
+    private rdStartOffset: number,
+    private copySizeOffset: number,
+    private dstOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory.track(this.type);
+    const operands = [this.rdStartOffset, this.copySizeOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [rdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
+
+    memory.checkTags(TypeTag.UINT32, rdStartOffset, copySizeOffset);
+    const rdStart = memory.get(rdStartOffset).toNumber();
+    const copySize = memory.get(copySizeOffset).toNumber();
+    context.machineState.consumeGas(this.gasCost(copySize));
+
+    const transformedData = context.machineState.nestedReturndata
+      .slice(rdStart, rdStart + copySize)
+      .map(f => new Field(f));
+
+    memory.setSlice(dstOffset, transformedData);
+
+    memory.assert({ reads: 2, writes: copySize, addressing });
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/opcodes/storage.ts

@@ -43,7 +43,7 @@ export class SStore extends BaseStorageInstruction {
 
     const slot = memory.get(slotOffset).toFr();
     const value = memory.get(srcOffset).toFr();
-    context.persistableState.writeStorage(context.environment.storageAddress, slot, value);
+    context.persistableState.writeStorage(context.environment.address, slot, value);
 
     memory.assert({ reads: 2, addressing });
     context.machineState.incrementPc();
@@ -68,7 +68,7 @@ export class SLoad extends BaseStorageInstruction {
     memory.checkTag(TypeTag.FIELD, slotOffset);
 
     const slot = memory.get(slotOffset).toFr();
-    const value = await context.persistableState.readStorage(context.environment.storageAddress, slot);
+    const value = await context.persistableState.readStorage(context.environment.address, slot);
     memory.set(dstOffset, new Field(value));
 
     context.machineState.incrementPc();