@aztec/simulator 0.0.1-commit.2f68f620 → 0.0.1-commit.3100065

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

@@ -0,0 +1,103 @@
+import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+import { mock } from 'jest-mock-extended';
+
+import type { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
+import type { PublicSideEffectTraceInterface } from '../../side_effect_trace_interface.js';
+import { NullifierManager } from '../../state_manager/nullifiers.js';
+import { PublicStorage } from '../../state_manager/public_storage.js';
+import { PublicPersistableStateManager } from '../../state_manager/state_manager.js';
+import { AvmContext } from '../avm_context.js';
+import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
+import { AvmMachineState } from '../avm_machine_state.js';
+import { AvmSimulator } from '../avm_simulator.js';
+import { CallDataArray } from '../calldata.js';
+import { DEFAULT_TIMESTAMP } from './utils.js';
+
+/**
+ * Create a new AVM context with default values.
+ */
+export function initContext(overrides?: {
+  persistableState?: PublicPersistableStateManager;
+  env?: AvmExecutionEnvironment;
+  machineState?: AvmMachineState;
+}): AvmContext {
+  const ctx = new AvmContext(
+    overrides?.persistableState || initPersistableStateManager(),
+    overrides?.env || initExecutionEnvironment(),
+    overrides?.machineState || initMachineState(),
+  );
+  ctx.provideSimulator = AvmSimulator.build;
+  return ctx;
+}
+
+/** Creates an empty state manager with mocked host storage. */
+export function initPersistableStateManager(overrides?: {
+  treesDB?: PublicTreesDB;
+  contractsDB?: PublicContractsDB;
+  trace?: PublicSideEffectTraceInterface;
+  publicStorage?: PublicStorage;
+  nullifiers?: NullifierManager;
+  firstNullifier?: Fr;
+  timestamp?: UInt64;
+}): PublicPersistableStateManager {
+  const treesDB = overrides?.treesDB || mock<PublicTreesDB>();
+  return new PublicPersistableStateManager(
+    treesDB,
+    overrides?.contractsDB || mock<PublicContractsDB>(),
+    overrides?.trace || mock<PublicSideEffectTraceInterface>(),
+    overrides?.firstNullifier || new Fr(27),
+    overrides?.timestamp || DEFAULT_TIMESTAMP,
+    /*doMerkleOperations=*/ false,
+  );
+}
+
+/**
+ * Create an empty instance of the Execution Environment where all values are zero, unless overridden in the overrides object
+ */
+export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnvironment>): AvmExecutionEnvironment {
+  return new AvmExecutionEnvironment(
+    overrides?.address ?? AztecAddress.zero(),
+    overrides?.sender ?? AztecAddress.zero(),
+    overrides?.contractCallDepth ?? Fr.zero(),
+    overrides?.transactionFee ?? Fr.zero(),
+    overrides?.globals ?? GlobalVariables.empty(),
+    overrides?.isStaticCall ?? false,
+    overrides?.calldata ?? new CallDataArray([]),
+    overrides?.config ?? PublicSimulatorConfig.empty(),
+  );
+}
+
+/**
+ * Create an empty instance of the Execution Environment where all values are zero, unless overridden in the overrides object
+ */
+export function initGlobalVariables(overrides?: Partial<GlobalVariables>): GlobalVariables {
+  return new GlobalVariables(
+    overrides?.chainId ?? Fr.zero(),
+    overrides?.version ?? Fr.zero(),
+    overrides?.blockNumber ?? BlockNumber.ZERO,
+    overrides?.slotNumber ?? SlotNumber.ZERO,
+    overrides?.timestamp ?? 0n,
+    overrides?.coinbase ?? EthAddress.ZERO,
+    overrides?.feeRecipient ?? AztecAddress.zero(),
+    overrides?.gasFees ?? GasFees.empty(),
+  );
+}
+
+/**
+ * Create an empty instance of the Machine State where all values are set to a large enough amount, unless overridden in the overrides object
+ */
+export function initMachineState(overrides?: Partial<AvmMachineState>): AvmMachineState {
+  return AvmMachineState.fromState({
+    l2GasLeft: overrides?.l2GasLeft ?? AVM_MAX_PROCESSABLE_L2_GAS,
+    daGasLeft: overrides?.daGasLeft ?? 1e8,
+  });
+}

package/src/public/avm/{testing → fixtures}/utils.ts

@@ -14,6 +14,7 @@ import {
   type ContractInstanceWithAddress,
   computeInitializationHash,
 } from '@aztec/stdlib/contract';
+import { isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
 import { siloNullifier } from '@aztec/stdlib/hash';
 import { deriveKeys } from '@aztec/stdlib/keys';
 import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/stdlib/testing';
@@ -22,6 +23,10 @@ import type { UInt64 } from '@aztec/stdlib/types';
 import { strict as assert } from 'assert';
 import merge from 'lodash.merge';
 
+import { resolveAssertionMessageFromRevertData, traverseCauseChain } from '../../../common/index.js';
+import { Field, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
+import type { AvmRevertReason } from '../errors.js';
+
 export const PUBLIC_DISPATCH_FN_NAME = 'public_dispatch';
 export const DEFAULT_TIMESTAMP: UInt64 = 99833n;
 export const DEFAULT_BLOCK_NUMBER = BlockNumber(42);
@@ -33,6 +38,22 @@ export function allSameExcept(original: any, overrides: any): any {
   return merge({}, original, overrides);
 }
 
+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)));
+}
+
+export function randomMemoryFields(length: number): Field[] {
+  return [...Array(length)].map(_ => new Field(Fr.random()));
+}
+
 export function getFunctionSelector(
   functionName: string,
   contractArtifact: ContractArtifact,
@@ -60,6 +81,24 @@ export function getContractFunctionAbi(
   );
 }
 
+export function resolveContractAssertionMessage(
+  functionName: string,
+  revertReason: AvmRevertReason,
+  output: Fr[],
+  contractArtifact: ContractArtifact,
+): string | undefined {
+  traverseCauseChain(revertReason, cause => {
+    revertReason = cause as AvmRevertReason;
+  });
+
+  const functionArtifact = getAllFunctionAbis(contractArtifact).find(f => f.name === functionName);
+  if (!functionArtifact || !revertReason.noirCallStack || !isNoirCallStackUnresolved(revertReason.noirCallStack)) {
+    return undefined;
+  }
+
+  return resolveAssertionMessageFromRevertData(output, functionArtifact);
+}
+
 /**
  * Create a contract class and instance given constructor args, artifact, etc.
  * NOTE: This is useful for testing real-ish contract class registration and instance deployment TXs (via logs)
@@ -107,7 +146,7 @@ export async function createContractClassAndInstance(
         });
 
   const contractAddressNullifier = await siloNullifier(
-    AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
+    AztecAddress.fromNumberUnsafe(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
     contractInstance.address.toField(),
   );
 

package/src/public/avm/index.ts

@@ -0,0 +1 @@
+export * from './avm_simulator.js';

package/src/public/avm/opcodes/accrued_substate.ts

@@ -0,0 +1,285 @@
+import { MAX_ETH_ADDRESS_VALUE } from '@aztec/constants';
+
+import { NullifierCollisionError } from '../../side_effect_errors.js';
+import type { AvmContext } from '../avm_context.js';
+import { TypeTag, Uint1 } from '../avm_memory_types.js';
+import { InstructionExecutionError, StaticCallAlterationError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class NoteHashExists extends Instruction {
+  static type: string = 'NOTEHASHEXISTS';
+  static readonly opcode: Opcode = Opcode.NOTEHASHEXISTS;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+  ];
+
+  constructor(
+    private addressingMode: number,
+    private noteHashOffset: number,
+    private leafIndexOffset: number,
+    private existsOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+    const operands = [this.noteHashOffset, this.leafIndexOffset, this.existsOffset];
+    const [noteHashOffset, leafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
+    memory.checkTag(TypeTag.FIELD, noteHashOffset);
+    memory.checkTag(TypeTag.UINT64, leafIndexOffset);
+
+    // Note that this instruction accepts any type in memory, and converts to Field.
+    const noteHash = memory.get(noteHashOffset).toFr();
+    const leafIndex = memory.get(leafIndexOffset).toBigInt();
+
+    const exists = await context.persistableState.checkNoteHashExists(context.environment.address, noteHash, leafIndex);
+    memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
+  }
+}
+
+export class EmitNoteHash extends Instruction {
+  static type: string = 'EMITNOTEHASH';
+  static readonly opcode: Opcode = Opcode.EMITNOTEHASH;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
+
+  constructor(
+    private addressingMode: number,
+    private noteHashOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    const operands = [this.noteHashOffset];
+    const [noteHashOffset] = addressing.resolve(operands, memory);
+    memory.checkTag(TypeTag.FIELD, noteHashOffset);
+
+    if (context.environment.isStaticCall) {
+      throw new StaticCallAlterationError();
+    }
+
+    const noteHash = memory.get(noteHashOffset).toFr();
+    await context.persistableState.writeNoteHash(context.environment.address, noteHash);
+  }
+}
+
+export class NullifierExists extends Instruction {
+  static type: string = 'NULLIFIEREXISTS';
+  static readonly opcode: Opcode = Opcode.NULLIFIEREXISTS;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
+
+  constructor(
+    private addressingMode: number,
+    private siloedNullifierOffset: number,
+    private existsOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    const operands = [this.siloedNullifierOffset, this.existsOffset];
+    const [siloedNullifierOffset, existsOffset] = addressing.resolve(operands, memory);
+    memory.checkTag(TypeTag.FIELD, siloedNullifierOffset);
+
+    const siloedNullifier = memory.get(siloedNullifierOffset).toFr();
+    const exists = await context.persistableState.checkSiloedNullifierExists(siloedNullifier);
+
+    memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
+  }
+}
+
+export class EmitNullifier extends Instruction {
+  static type: string = 'EMITNULLIFIER';
+  static readonly opcode: Opcode = Opcode.EMITNULLIFIER;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
+
+  constructor(
+    private addressingMode: number,
+    private nullifierOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    if (context.environment.isStaticCall) {
+      throw new StaticCallAlterationError();
+    }
+
+    const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    const operands = [this.nullifierOffset];
+    const [nullifierOffset] = addressing.resolve(operands, memory);
+    memory.checkTag(TypeTag.FIELD, nullifierOffset);
+
+    const nullifier = memory.get(nullifierOffset).toFr();
+    try {
+      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} (contract address: ${context.environment.address}).`,
+        );
+      } else {
+        throw e;
+      }
+    }
+  }
+}
+
+export class L1ToL2MessageExists extends Instruction {
+  static type: string = 'L1TOL2MSGEXISTS';
+  static readonly opcode: Opcode = Opcode.L1TOL2MSGEXISTS;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+  ];
+
+  constructor(
+    private addressingMode: number,
+    private msgHashOffset: number,
+    private msgLeafIndexOffset: number,
+    private existsOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    const operands = [this.msgHashOffset, this.msgLeafIndexOffset, this.existsOffset];
+    const [msgHashOffset, msgLeafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
+
+    memory.checkTag(TypeTag.FIELD, msgHashOffset);
+    memory.checkTag(TypeTag.UINT64, msgLeafIndexOffset);
+
+    const msgHash = memory.get(msgHashOffset).toFr();
+    const msgLeafIndex = memory.get(msgLeafIndexOffset).toFr();
+    const exists = await context.persistableState.checkL1ToL2MessageExists(msgHash, msgLeafIndex);
+    memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
+  }
+}
+
+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];
+
+  constructor(
+    private addressingMode: number,
+    private logSizeOffset: number,
+    private logOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    if (context.environment.isStaticCall) {
+      throw new StaticCallAlterationError();
+    }
+
+    const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    const operands = [this.logSizeOffset, this.logOffset];
+    const [logSizeOffset, logOffset] = addressing.resolve(operands, memory);
+    memory.checkTag(TypeTag.UINT32, logSizeOffset);
+    const logSize = memory.get(logSizeOffset).toNumber();
+
+    const contractAddress = context.environment.address;
+
+    context.machineState.consumeGas(this.dynamicGasCost(logSize));
+    memory.checkTagsRange(TypeTag.FIELD, logOffset, logSize);
+    const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
+    context.persistableState.writePublicLog(contractAddress, log);
+  }
+}
+
+export class SendL2ToL1Message extends Instruction {
+  static type: string = 'SENDL2TOL1MSG';
+  static readonly opcode: Opcode = Opcode.SENDL2TOL1MSG;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
+
+  constructor(
+    private addressingMode: number,
+    private recipientOffset: number,
+    private contentOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    if (context.environment.isStaticCall) {
+      throw new StaticCallAlterationError();
+    }
+
+    const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.addressingMode);
+
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
+    const operands = [this.recipientOffset, this.contentOffset];
+    const [recipientOffset, contentOffset] = addressing.resolve(operands, memory);
+    memory.checkTags(TypeTag.FIELD, recipientOffset, contentOffset);
+
+    const recipient = memory.get(recipientOffset).toFr();
+
+    if (recipient.toBigInt() > MAX_ETH_ADDRESS_VALUE) {
+      throw new InstructionExecutionError(`SENDL2TOL1MSG: Recipient address is too large`);
+    }
+    const content = memory.get(contentOffset).toFr();
+    context.persistableState.writeL2ToL1Message(context.environment.address, recipient, content);
+  }
+}

package/src/public/avm/opcodes/addressing_mode.ts

@@ -0,0 +1,111 @@
+import { AVM_MAX_OPERANDS } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import type { Tuple } from '@aztec/foundation/serialize';
+
+import { strict as assert } from 'assert';
+
+import { MemoryValue, TaggedMemory, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
+import { RelativeAddressOutOfRangeError, TagCheckError } from '../errors.js';
+
+export enum AddressingMode {
+  DIRECT = 0,
+  INDIRECT = 1,
+  RELATIVE = 2,
+  INDIRECT_RELATIVE = 3,
+}
+
+/** A class to represent the addressing mode of an instruction. */
+export class Addressing {
+  public constructor(
+    /** The addressing mode for each possible operand. */
+    private readonly modePerOperand: Tuple<AddressingMode, typeof AVM_MAX_OPERANDS>,
+  ) {}
+
+  public static fromModes(modes: AddressingMode[]): Addressing {
+    assert(modes.length <= AVM_MAX_OPERANDS, 'Too many operands for addressing mode');
+    return new Addressing(padArrayEnd(modes, AddressingMode.DIRECT, AVM_MAX_OPERANDS));
+  }
+
+  public static fromWire(wireModes: number): Addressing {
+    // The modes are stored in the wire format as one or two bytes, with each two bits representing the modes for an operand.
+    // Even bits are indirect, odd bits are relative.
+    const modes = new Array<AddressingMode>(AVM_MAX_OPERANDS);
+    for (let i = 0; i < AVM_MAX_OPERANDS; i++) {
+      modes[i] =
+        (((wireModes >> (i * 2)) & 1) * AddressingMode.INDIRECT) |
+        (((wireModes >> (i * 2 + 1)) & 1) * AddressingMode.RELATIVE);
+    }
+    // Casting the array to tuple since it should be more performant than using makeTuple
+    return new Addressing(modes as Tuple<AddressingMode, typeof AVM_MAX_OPERANDS>);
+  }
+
+  public toWire(): number {
+    // The modes are stored in the wire format as a byte, with each bit representing the mode for an operand.
+    // The least significant bit represents the zeroth operand, and the least significant bit represents the last operand.
+    let wire: number = 0;
+    for (let i = 0; i < this.modePerOperand.length; i++) {
+      if (this.modePerOperand[i] & AddressingMode.INDIRECT) {
+        wire |= 1 << (i * 2);
+      }
+      if (this.modePerOperand[i] & AddressingMode.RELATIVE) {
+        wire |= 1 << (i * 2 + 1);
+      }
+    }
+    return wire;
+  }
+
+  public indirectOperandsCount(): number {
+    return this.modePerOperand.filter(mode => mode & AddressingMode.INDIRECT).length;
+  }
+
+  public relativeOperandsCount(): number {
+    return this.modePerOperand.filter(mode => mode & AddressingMode.RELATIVE).length;
+  }
+
+  /**
+   * Resolves the offsets using the addressing mode.
+   * @param offsets The offsets to resolve.
+   * @param mem The memory to use for resolution.
+   * @returns The resolved offsets. The length of the returned array is the same as the length of the input array and the resolved offsets are guaranteed to be valid addresses.
+   * @throws An error if any step failed. Should be treated as a black box.
+   */
+  public resolve(offsets: number[], mem: TaggedMemoryInterface): number[] {
+    const resolved: number[] = new Array(offsets.length);
+    // These will be read (once) if we have any relative operands.
+    let baseAddr: MemoryValue | undefined;
+
+    for (const [i, offset] of offsets.entries()) {
+      const mode = this.modePerOperand[i];
+      // The given offsets are assumed to be valid addresses.
+      resolved[i] = offset;
+      if (mode & AddressingMode.RELATIVE) {
+        if (!baseAddr) {
+          baseAddr = mem.get(0);
+          const baseAddrTag = baseAddr.getTag();
+          if (!TaggedMemory.isValidMemoryAddressTag(baseAddrTag!)) {
+            throw TagCheckError.forBaseAddress(TypeTag[baseAddrTag!]);
+          }
+        }
+        // Here we know that resolved[i] is at most 32 bits and baseAddr is at most 32 bits.
+        // Therefore, the addition is safe since the `number` type fits more than 33 bits.
+        resolved[i] += Number(baseAddr.toBigInt());
+        if (resolved[i] >= TaggedMemory.MAX_MEMORY_SIZE) {
+          throw new RelativeAddressOutOfRangeError(Number(baseAddr.toBigInt()), offset);
+        }
+      }
+      if (mode & AddressingMode.INDIRECT) {
+        // At this point we know that resolved[i] is a valid memory address.
+        const resolvedValue = mem.get(resolved[i]);
+        const resolvedTag = resolvedValue.getTag();
+
+        // Final check.
+        if (!TaggedMemory.isValidMemoryAddressTag(resolvedTag)) {
+          throw TagCheckError.forIndirectAddress(resolved[i], TypeTag[resolvedTag]);
+        }
+
+        resolved[i] = Number(resolvedValue.toBigInt());
+      }
+    }
+    return resolved;
+  }
+}