@aztec/stdlib 0.0.1-commit.e3c1de76 → 0.0.1-commit.e57c76e

package/src/abi/encoder.ts

@@ -1,7 +1,13 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { AbiType, FunctionAbi } from './abi.js';
-import { isAddressStruct, isBoundedVecStruct, isFunctionSelectorStruct, isWrappedFieldStruct } from './utils.js';
+import {
+  isAddressStruct,
+  isBoundedVecStruct,
+  isFunctionSelectorStruct,
+  isOptionStruct,
+  isWrappedFieldStruct,
+} from './utils.js';
 
 /**
  * Encodes arguments for a function call.
@@ -43,6 +49,32 @@ class ArgumentEncoder {
    * @param name - Name.
    */
   private encodeArgument(abiType: AbiType, arg: any, name?: string) {
+    if (isOptionStruct(abiType)) {
+      const optionType = abiType as Extract<AbiType, { kind: 'struct' }>;
+      const [isSomeField, valueField] = optionType.fields;
+
+      if (arg === undefined || arg === null) {
+        this.encodeArgument(isSomeField.type, false, `${name}._is_some`);
+        this.#encodeDefaultValue(valueField.type);
+        return;
+      }
+
+      if (typeof arg === 'object' && '_is_some' in arg) {
+        this.encodeArgument(isSomeField.type, arg._is_some, `${name}._is_some`);
+
+        if (arg._is_some) {
+          this.encodeArgument(valueField.type, arg._value, `${name}._value`);
+        } else {
+          this.#encodeDefaultValue(valueField.type);
+        }
+        return;
+      }
+
+      this.encodeArgument(isSomeField.type, true, `${name}._is_some`);
+      this.encodeArgument(valueField.type, arg, `${name}._value`);
+      return;
+    }
+
     if (arg === undefined || arg == null) {
       throw new Error(`Undefined argument ${name ?? 'unnamed'} of type ${abiType.kind}`);
     }
@@ -74,13 +106,28 @@ class ArgumentEncoder {
         this.flattened.push(new Fr(arg ? 1n : 0n));
         break;
       case 'array':
+        if (!Array.isArray(arg)) {
+          throw new Error(`Expected array for '${name ?? 'unnamed'}' but received ${typeof arg}`);
+        }
+        if (arg.length !== abiType.length) {
+          throw new Error(
+            `Expected array of length ${abiType.length} for '${name ?? 'unnamed'}' but received length ${arg.length}`,
+          );
+        }
         for (let i = 0; i < abiType.length; i += 1) {
           this.encodeArgument(abiType.type, arg[i], `${name}[${i}]`);
         }
         break;
       case 'string':
+        if (typeof arg !== 'string') {
+          throw new Error(`Expected string for '${name ?? 'unnamed'}' but received ${typeof arg}`);
+        }
+        if (arg.length > abiType.length) {
+          throw new Error(
+            `Expected string of max length ${abiType.length} for '${name ?? 'unnamed'}' but received length ${arg.length}`,
+          );
+        }
         for (let i = 0; i < abiType.length; i += 1) {
-          // If the string is shorter than the defined length, pad it with 0s.
           const toInsert = i < arg.length ? BigInt((arg as string).charCodeAt(i)) : 0n;
           this.flattened.push(new Fr(toInsert));
         }
@@ -123,14 +170,33 @@ class ArgumentEncoder {
         }
         break;
       }
-      case 'integer':
-        if (typeof arg === 'string') {
-          const value = BigInt(arg);
+      case 'integer': {
+        const value = BigInt(arg);
+        if (abiType.sign === 'unsigned') {
+          const maxValue = (1n << BigInt(abiType.width)) - 1n;
+          if (value < 0n || value > maxValue) {
+            throw new Error(
+              `Value ${value} does not fit in u${abiType.width} for '${name ?? 'unnamed'}' (valid range: 0 to ${maxValue})`,
+            );
+          }
           this.flattened.push(new Fr(value));
         } else {
-          this.flattened.push(new Fr(arg));
+          const minValue = -(1n << BigInt(abiType.width - 1));
+          const maxValue = (1n << BigInt(abiType.width - 1)) - 1n;
+          if (value < minValue || value > maxValue) {
+            throw new Error(
+              `Value ${value} does not fit in i${abiType.width} for '${name ?? 'unnamed'}' (valid range: ${minValue} to ${maxValue})`,
+            );
+          }
+          if (value < 0n) {
+            const twosComplement = value + (1n << BigInt(abiType.width));
+            this.flattened.push(new Fr(twosComplement));
+          } else {
+            this.flattened.push(new Fr(value));
+          }
         }
         break;
+      }
       default:
         throw new Error(`Unsupported type: ${abiType.kind}`);
     }
@@ -141,6 +207,11 @@ class ArgumentEncoder {
    * @returns The encoded arguments.
    */
   public encode() {
+    if (this.args.length !== this.abi.parameters.length) {
+      throw new Error(
+        `Function '${this.abi.name}' expects ${this.abi.parameters.length} argument(s) but received ${this.args.length}`,
+      );
+    }
     for (let i = 0; i < this.abi.parameters.length; i += 1) {
       const parameterAbi = this.abi.parameters[i];
       this.encodeArgument(parameterAbi.type, this.args[i], parameterAbi.name);
@@ -224,6 +295,14 @@ class ArgumentEncoder {
       this.encodeArgument(lenField.type, arg.length, 'len');
     }
   }
+
+  /**
+   * Appends the flattened zero value for an ABI type.
+   * Option::None still serializes the wrapped value, so we need to zero-fill its footprint.
+   */
+  #encodeDefaultValue(abiType: AbiType) {
+    this.flattened.push(...new Array(ArgumentEncoder.typeSize(abiType)).fill(Fr.ZERO));
+  }
 }
 
 /**

package/src/abi/event_metadata_definition.ts

@@ -1,8 +1,10 @@
 import type { AbiType } from './abi.js';
 import type { EventSelector } from './event_selector.js';
 
+/** Metadata for a contract event, used to decode emitted event logs back into structured data. */
 export type EventMetadataDefinition = {
   eventSelector: EventSelector;
   abiType: AbiType;
+  /** Names of the event's struct members (not serialized Noir Field elements). */
   fieldNames: string[];
 };

package/src/abi/event_selector.ts

@@ -7,16 +7,10 @@ import { BufferReader } from '@aztec/foundation/serialize';
 
 import { Selector } from './selector.js';
 
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-
-/** Event selector branding */
-export interface EventSelector {
-  /** Brand. */
-  _branding: 'EventSelector';
-}
-
 /** An event selector is the first 4 bytes of the hash of an event signature. */
 export class EventSelector extends Selector {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'EventSelector';
   /**
    * Deserializes from a buffer or reader, corresponding to a write in cpp.
    * @param buffer - Buffer  or BufferReader to read from.

package/src/abi/function_call.ts

@@ -1,8 +1,11 @@
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { FieldsOf } from '@aztec/foundation/types';
 
+import { z } from 'zod';
+
 import { AztecAddress } from '../aztec-address/index.js';
-import { type AbiType, FunctionType } from './abi.js';
+import { schemas } from '../schemas/index.js';
+import { type AbiType, AbiTypeSchema, FunctionType } from './abi.js';
 import { FunctionSelector } from './function_selector.js';
 
 /** A request to call a function on a contract. */
@@ -43,12 +46,31 @@ export class FunctionCall {
     return new FunctionCall(...FunctionCall.getFields(fields));
   }
 
+  static get schema() {
+    return z
+      .object({
+        name: z.string(),
+        to: schemas.AztecAddress,
+        selector: schemas.FunctionSelector,
+        type: z.nativeEnum(FunctionType),
+        isStatic: z.boolean(),
+        hideMsgSender: z.boolean(),
+        args: z.array(schemas.Fr),
+        returnTypes: z.array(AbiTypeSchema),
+      })
+      .transform(FunctionCall.from);
+  }
+
+  public isPublicStatic(): boolean {
+    return this.type === FunctionType.PUBLIC && this.isStatic;
+  }
+
   /**
    * Creates an empty function call.
    * @returns an empty function call.
    */
   public static empty() {
-    return {
+    return FunctionCall.from({
       name: '',
       to: AztecAddress.ZERO,
       selector: FunctionSelector.empty(),
@@ -57,6 +79,6 @@ export class FunctionCall {
       isStatic: false,
       args: [],
       returnTypes: [],
-    };
+    });
   }
 }

package/src/abi/function_selector.ts

@@ -3,22 +3,16 @@ import { poseidon2HashBytes } from '@aztec/foundation/crypto/poseidon';
 import { randomBytes } from '@aztec/foundation/crypto/random';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { type ZodFor, hexSchemaFor } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, TypeRegistry } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 
 import type { ABIParameter } from './abi.js';
-import { decodeFunctionSignature } from './decoder.js';
+import { decodeFunctionSignature } from './function_signature_decoder.js';
 import { Selector } from './selector.js';
 
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-
-/** Function selector branding */
-export interface FunctionSelector {
-  /** Brand. */
-  _branding: 'FunctionSelector';
-}
-
 /** A function selector is the first 4 bytes of the hash of a function signature. */
 export class FunctionSelector extends Selector {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'FunctionSelector';
   /**
    * Deserializes from a buffer or reader, corresponding to a write in cpp.
    * @param buffer - Buffer  or BufferReader to read from.
@@ -127,6 +121,3 @@ export class FunctionSelector extends Selector {
     return hexSchemaFor(FunctionSelector);
   }
 }
-
-// For deserializing JSON.
-TypeRegistry.register('FunctionSelector', FunctionSelector);

package/src/abi/function_signature_decoder.ts

@@ -0,0 +1,77 @@
+import type { ABIParameter, ABIVariable, AbiType } from './abi.js';
+
+/**
+ * Decodes the signature of a function from the name and parameters.
+ */
+export class FunctionSignatureDecoder {
+  private separator: string;
+  constructor(
+    private name: string,
+    private parameters: ABIParameter[],
+    private includeNames = false,
+  ) {
+    this.separator = includeNames ? ', ' : ',';
+  }
+
+  /**
+   * Decodes a single function parameter type for the function signature.
+   * @param param - The parameter type to decode.
+   * @returns A string representing the parameter type.
+   */
+  private getParameterType(param: AbiType): string {
+    switch (param.kind) {
+      case 'field':
+        return 'Field';
+      case 'integer':
+        return param.sign === 'signed' ? `i${param.width}` : `u${param.width}`;
+      case 'boolean':
+        return 'bool';
+      case 'array':
+        return `[${this.getParameterType(param.type)};${param.length}]`;
+      case 'string':
+        return `str<${param.length}>`;
+      case 'struct':
+        return `(${param.fields.map(field => `${this.decodeParameter(field)}`).join(this.separator)})`;
+      default:
+        throw new Error(`Unsupported type: ${param.kind}`);
+    }
+  }
+
+  /**
+   * Decodes a single function parameter for the function signature.
+   * @param param - The parameter to decode.
+   * @returns A string representing the parameter type and optionally its name.
+   */
+  private decodeParameter(param: ABIVariable): string {
+    const type = this.getParameterType(param.type);
+    return this.includeNames ? `${param.name}: ${type}` : type;
+  }
+
+  /**
+   * Decodes all the parameters and build the function signature
+   * @returns The function signature.
+   */
+  public decode(): string {
+    return `${this.name}(${this.parameters.map(param => this.decodeParameter(param)).join(this.separator)})`;
+  }
+}
+
+/**
+ * Decodes a function signature from the name and parameters.
+ * @param name - The name of the function.
+ * @param parameters - The parameters of the function.
+ * @returns - The function signature.
+ */
+export function decodeFunctionSignature(name: string, parameters: ABIParameter[]) {
+  return new FunctionSignatureDecoder(name, parameters).decode();
+}
+
+/**
+ * Decodes a function signature from the name and parameters including parameter names.
+ * @param name - The name of the function.
+ * @param parameters - The parameters of the function.
+ * @returns - The user-friendly function signature.
+ */
+export function decodeFunctionSignatureWithParameterNames(name: string, parameters: ABIParameter[]) {
+  return new FunctionSignatureDecoder(name, parameters, true).decode();
+}

package/src/abi/index.ts

@@ -1,6 +1,7 @@
 export * from './abi.js';
 export * from './buffer.js';
 export * from './decoder.js';
+export * from './function_signature_decoder.js';
 export * from './encoder.js';
 export * from './authorization_selector.js';
 export * from './event_metadata_definition.js';

package/src/abi/note_selector.ts

@@ -2,23 +2,17 @@ import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { randomInt } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { hexSchemaFor } from '@aztec/foundation/schemas';
-import { BufferReader, TypeRegistry } from '@aztec/foundation/serialize';
+import { BufferReader } from '@aztec/foundation/serialize';
 
 import { Selector } from './selector.js';
 
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-
-/** Note selector branding */
-export interface NoteSelector {
-  /** Brand. */
-  _branding: 'NoteSelector';
-}
-
 /**
  * A note selector is a 7 bit long value that identifies a note type within a contract.
  * TODO(#10952): Encoding of note type id can be reduced to 7 bits.
  */
 export class NoteSelector extends Selector {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'NoteSelector';
   /**
    * Deserializes from a buffer or reader, corresponding to a write in cpp.
    * @param buffer - Buffer  or BufferReader to read from.
@@ -73,6 +67,3 @@ export class NoteSelector extends Selector {
     return hexSchemaFor(NoteSelector);
   }
 }
-
-// For deserializing JSON.
-TypeRegistry.register('NoteSelector', NoteSelector);

package/src/abi/selector.ts

@@ -4,7 +4,7 @@ import { bufferToHex } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
 
-/** A selector is the first 4 bytes of the hash of a signature. */
+/** A selector is the low 4 bytes of the poseidon2 hash of a signature. */
 export abstract class Selector {
   /** The size of the selector in bytes. */
   public static SIZE = 4;

package/src/abi/utils.ts

@@ -58,11 +58,13 @@ export function isPublicKeysStruct(abiType: AbiType) {
   return (
     abiType.kind === 'struct' &&
     abiType.path === 'aztec::protocol_types::public_keys::PublicKeys' &&
-    abiType.fields.length === 4 &&
-    abiType.fields[0].name === 'npk_m' &&
+    abiType.fields.length === 6 &&
+    abiType.fields[0].name === 'npk_m_hash' &&
     abiType.fields[1].name === 'ivpk_m' &&
-    abiType.fields[2].name === 'ovpk_m' &&
-    abiType.fields[3].name === 'tpk_m'
+    abiType.fields[2].name === 'ovpk_m_hash' &&
+    abiType.fields[3].name === 'tpk_m_hash' &&
+    abiType.fields[4].name === 'mspk_m_hash' &&
+    abiType.fields[5].name === 'fbpk_m_hash'
   );
 }
 
@@ -81,6 +83,31 @@ export function isBoundedVecStruct(abiType: AbiType) {
   );
 }
 
+/**
+ * Returns whether the ABI type is Noir's std::option::Option lowered to a struct.
+ * @param abiType - Type to check.
+ * @returns A boolean indicating whether the ABI type is an Option struct.
+ */
+export function isOptionStruct(abiType: AbiType) {
+  return (
+    abiType.kind === 'struct' &&
+    abiType.path === 'std::option::Option' &&
+    abiType.fields.length === 2 &&
+    abiType.fields[0].name === '_is_some' &&
+    abiType.fields[1].name === '_value'
+  );
+}
+
+/**
+ * Returns whether `null` or `undefined` can be mapped to a valid ABI value for this type.
+ *
+ * @param abiType - Type to check.
+ * @returns A boolean indicating whether nullish values are valid shorthand for this ABI type.
+ */
+export function canBeMappedFromNullOrUndefined(abiType: AbiType) {
+  return isOptionStruct(abiType);
+}
+
 /**
  * Returns a bigint by parsing a serialized 2's complement signed int.
  * @param b - The signed int as a buffer

package/src/auth_witness/auth_witness.ts

@@ -1,4 +1,4 @@
-import { GeneratorIndex } from '@aztec/constants';
+import { DomainSeparator } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -61,7 +61,7 @@ export class AuthWitness {
  * @returns The inner hash for the witness
  */
 export const computeInnerAuthWitHash = (args: Fr[]) => {
-  return poseidon2HashWithSeparator(args, GeneratorIndex.AUTHWIT_INNER);
+  return poseidon2HashWithSeparator(args, DomainSeparator.AUTHWIT_INNER);
 };
 
 /**
@@ -77,5 +77,5 @@ export const computeInnerAuthWitHash = (args: Fr[]) => {
  * @returns The outer hash for the witness
  */
 export const computeOuterAuthWitHash = (consumer: AztecAddress, chainId: Fr, version: Fr, innerHash: Fr) => {
-  return poseidon2HashWithSeparator([consumer.toField(), chainId, version, innerHash], GeneratorIndex.AUTHWIT_OUTER);
+  return poseidon2HashWithSeparator([consumer.toField(), chainId, version, innerHash], DomainSeparator.AUTHWIT_OUTER);
 };

package/src/avm/avm.ts

@@ -130,6 +130,7 @@ export class AvmContractInstanceHint {
     public readonly currentContractClassId: Fr,
     public readonly originalContractClassId: Fr,
     public readonly initializationHash: Fr,
+    public readonly immutablesHash: Fr,
     public readonly publicKeys: PublicKeys,
   ) {}
 
@@ -143,6 +144,7 @@ export class AvmContractInstanceHint {
         currentContractClassId: schemas.Fr,
         originalContractClassId: schemas.Fr,
         initializationHash: schemas.Fr,
+        immutablesHash: schemas.Fr,
         publicKeys: PublicKeys.schema,
       })
       .transform(
@@ -154,6 +156,7 @@ export class AvmContractInstanceHint {
           currentContractClassId,
           originalContractClassId,
           initializationHash,
+          immutablesHash,
           publicKeys,
         }) =>
           new AvmContractInstanceHint(
@@ -164,6 +167,7 @@ export class AvmContractInstanceHint {
             currentContractClassId,
             originalContractClassId,
             initializationHash,
+            immutablesHash,
             publicKeys,
           ),
       );
@@ -188,6 +192,7 @@ export class AvmContractInstanceHint {
       Fr.fromPlainObject(obj.currentContractClassId),
       Fr.fromPlainObject(obj.originalContractClassId),
       Fr.fromPlainObject(obj.initializationHash),
+      Fr.fromPlainObject(obj.immutablesHash),
       PublicKeys.fromPlainObject(obj.publicKeys),
     );
   }

package/src/avm/message_pack.ts

@@ -64,13 +64,22 @@ function setUpMessagePackExtensions() {
   addExtension({
     Class: Point,
     write: (p: Point) => {
-      assert(!p.inf, 'Cannot serialize infinity');
-      // TODO: should these be Frs?
+      // TODO: Now that we use a 2 elt point representation, we should be able to handle infs here.
+      // However this opens possible bad paths with public keys and requires sanitised conversion between
+      // BB's inf representation (see below), and ours/Noir's (0, 0), and empty points from BB, when inf
+      // does not actually pass through.
+      assert(!p.isInfinite, 'Cannot serialize infinity');
       return { x: new Fq(p.x.toBigInt()), y: new Fq(p.y.toBigInt()) };
     },
     read: (data: { x: Fq; y: Fq }) => {
+      // Note: BB encodes infinity as x == y == Buffer of all ones.
+      // Infinity should never pass through here, but for correctness:
+      const ALL_ONES = (1n << 256n) - 1n;
+      if (data.x.toBigInt() === ALL_ONES && data.y.toBigInt() === ALL_ONES) {
+        return Point.INFINITY;
+      }
       // Convert Fq back to Fr for Point constructor
-      return new Point(new Fr(data.x.toBigInt()), new Fr(data.y.toBigInt()), false);
+      return new Point(new Fr(data.x.toBigInt()), new Fr(data.y.toBigInt()));
     },
   });
   // EthAddress is a class that has a buffer in TS, but is itself just a field in C++.

package/src/avm/revert_code.ts

@@ -5,20 +5,17 @@ import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 import { inspect } from 'util';
 import { z } from 'zod';
 
+/** Whether a transaction's public execution reverted. */
 export enum RevertCodeEnum {
+  /** All phases completed successfully; no state was rolled back. */
   OK = 0,
-  APP_LOGIC_REVERTED = 1,
-  TEARDOWN_REVERTED = 2,
-  BOTH_REVERTED = 3,
+  /** One or more revertible phases reverted; their state changes were discarded. */
+  REVERTED = 1,
 }
 
-function isRevertCodeEnum(value: number): value is RevertCodeEnum {
-  return (
-    (value as RevertCodeEnum) === RevertCodeEnum.OK ||
-    (value as RevertCodeEnum) === RevertCodeEnum.APP_LOGIC_REVERTED ||
-    (value as RevertCodeEnum) === RevertCodeEnum.TEARDOWN_REVERTED ||
-    (value as RevertCodeEnum) === RevertCodeEnum.BOTH_REVERTED
-  );
+/** Returns a valid RevertCodeEnum, coercing any value >= 1 to REVERTED. */
+function toRevertCodeEnum(value: number): RevertCodeEnum {
+  return value >= 1 ? RevertCodeEnum.REVERTED : RevertCodeEnum.OK;
 }
 
 /**
@@ -30,9 +27,7 @@ export class RevertCode {
     this.code = e.valueOf();
   }
   static readonly OK: RevertCode = new RevertCode(RevertCodeEnum.OK);
-  static readonly APP_LOGIC_REVERTED: RevertCode = new RevertCode(RevertCodeEnum.APP_LOGIC_REVERTED);
-  static readonly TEARDOWN_REVERTED: RevertCode = new RevertCode(RevertCodeEnum.TEARDOWN_REVERTED);
-  static readonly BOTH_REVERTED: RevertCode = new RevertCode(RevertCodeEnum.BOTH_REVERTED);
+  static readonly REVERTED: RevertCode = new RevertCode(RevertCodeEnum.REVERTED);
 
   public getCode(): RevertCodeEnum {
     return this.code;
@@ -50,12 +45,8 @@ export class RevertCode {
     switch (this.code as RevertCodeEnum) {
       case RevertCodeEnum.OK:
         return 'OK';
-      case RevertCodeEnum.APP_LOGIC_REVERTED:
-        return 'Application logic reverted';
-      case RevertCodeEnum.TEARDOWN_REVERTED:
-        return 'Teardown reverted';
-      case RevertCodeEnum.BOTH_REVERTED:
-        return 'Both reverted';
+      case RevertCodeEnum.REVERTED:
+        return 'Reverted';
       default:
         return `Unknown RevertCode: ${this.code}`;
     }
@@ -66,7 +57,11 @@ export class RevertCode {
   }
 
   static get schema(): ZodFor<RevertCode> {
-    return z.nativeEnum(RevertCodeEnum).transform(value => new RevertCode(value));
+    return z
+      .number()
+      .int()
+      .min(0)
+      .transform(value => new RevertCode(toRevertCodeEnum(value)));
   }
 
   /**
@@ -81,10 +76,10 @@ export class RevertCode {
       return obj;
     }
     const code = typeof obj === 'number' ? obj : (obj.code ?? obj);
-    if (!isRevertCodeEnum(code)) {
+    if (typeof code !== 'number' || code < 0) {
       throw new Error(`Invalid RevertCode: ${code}`);
     }
-    return new RevertCode(code);
+    return new RevertCode(toRevertCodeEnum(code));
   }
 
   /**
@@ -116,10 +111,10 @@ export class RevertCode {
   }
 
   public static fromNumber(code: number): RevertCode {
-    if (!isRevertCodeEnum(code)) {
+    if (code < 0) {
       throw new Error(`Invalid RevertCode: ${code}`);
     }
-    return new RevertCode(code);
+    return new RevertCode(toRevertCodeEnum(code));
   }
 
   public static fromField(field: Fr): RevertCode {
@@ -137,7 +132,7 @@ export class RevertCode {
     return RevertCode.fromNumber(code);
   }
 
-  private static readonly NUM_OPTIONS = 4;
+  private static readonly NUM_OPTIONS = 2;
   static random(): RevertCode {
     return new RevertCode(Math.floor(Math.random() * RevertCode.NUM_OPTIONS));
   }