@aztec/stdlib 0.0.1-commit.c31f2472 → 0.0.1-commit.c52d6e7

package/src/abi/contract_artifact.ts

@@ -12,7 +12,10 @@ import {
 import {
   type ABIParameter,
   type ABIParameterVisibility,
+  ARTIFACT_VERSION_BEFORE_INJECTION,
+  type AbiNamedValue,
   type AbiType,
+  type AbiValue,
   type BasicValue,
   type ContractArtifact,
   ContractArtifactSchema,
@@ -51,6 +54,10 @@ export function contractArtifactFromBuffer(buffer: Buffer): ContractArtifact {
  */
 export function loadContractArtifact(input: NoirCompiledContract): ContractArtifact {
   if (isContractArtifact(input)) {
+    // TODO(F-557): Remove this fallback once pre-version artifacts are no longer tested.
+    if (!(input as unknown as Record<string, unknown>).aztecVersion) {
+      return { ...input, aztecVersion: ARTIFACT_VERSION_BEFORE_INJECTION };
+    }
     return input;
   }
   return generateContractArtifact(input);
@@ -161,9 +168,9 @@ function generateFunctionAbi(fn: NoirCompiledContractFunction, contract: NoirCom
     parameters = parameters.slice(1);
   }
 
-  let returnTypes: AbiType[] = [];
+  let returnType: AbiType | undefined;
   if (functionType === FunctionType.UTILITY) {
-    returnTypes = fn.abi.return_type ? [fn.abi.return_type.abi_type] : returnTypes;
+    returnType = fn.abi.return_type?.abi_type;
   } else {
     const pathToFind = `${contract.name}::${fn.name}_abi`;
     const abiStructs: AbiType[] = contract.outputs.structs['functions'];
@@ -175,10 +182,7 @@ function generateFunctionAbi(fn: NoirCompiledContractFunction, contract: NoirCom
         throw new Error('Could not generate contract function artifact');
       }
 
-      const returnTypeField = returnStruct.fields.find(field => field.name === 'return_type');
-      if (returnTypeField) {
-        returnTypes = [returnTypeField.type];
-      }
+      returnType = returnStruct.fields.find(field => field.name === 'return_type')?.type;
     }
   }
 
@@ -189,7 +193,10 @@ function generateFunctionAbi(fn: NoirCompiledContractFunction, contract: NoirCom
     isStatic,
     isInitializer: fn.custom_attributes.includes(AZTEC_INITIALIZER_ATTRIBUTE),
     parameters,
-    returnTypes,
+    returnType,
+    // Old consumers expect `returnTypes` property, not `returnType`. So we write both down for now, until we can
+    // safely remove the old version.
+    returnTypes: returnType ? [returnType] : [],
     errorTypes: fn.abi.error_types,
     ...(fn.assert_messages ? { assertMessages: fn.assert_messages } : undefined),
   };
@@ -241,20 +248,24 @@ function hasKernelFunctionInputs(params: ABIParameter[]): boolean {
 
 /**
  * Generates a storage layout for the contract artifact.
- * @param input - The compiled noir contract to get storage layout for
+ * @param contractName - The name of the compiled Noir contract.
+ * @param globals - The normalized globals exported by the contract.
  * @returns A storage layout for the contract.
  */
-function getStorageLayout(input: NoirCompiledContract) {
+function getStorageLayout(contractName: string, globals: Record<string, AbiValue[]>) {
   // If another contract is imported by the main contract, its storage layout its going to also show up here.
   // The layout export includes the contract name, so here we can find the one that belongs to the current one and
   // ignore the rest.
-  const storageExports = input.outputs.globals.storage ? (input.outputs.globals.storage as StructValue[]) : [];
-  const storageForContract = storageExports.find(storageExport => {
+  const storageExports = globals.storage ?? [];
+  const storageForContract = storageExports.find((storageExport): storageExport is StructValue => {
+    if (storageExport.kind !== 'struct') {
+      return false;
+    }
     const contractNameField = storageExport.fields.find(field => field.name === 'contract_name')?.value as BasicValue<
       'string',
       string
     >;
-    return contractNameField.value === input.name;
+    return contractNameField.value === contractName;
   });
   const storageFields = storageForContract
     ? ((storageForContract.fields.find(field => field.name == 'fields') as TypedStructFieldValue<StructValue>).value
@@ -275,25 +286,42 @@ function getStorageLayout(input: NoirCompiledContract) {
   }, {});
 }
 
+function isAbiNamedValue(value: AbiNamedValue | AbiValue): value is AbiNamedValue {
+  return 'name' in value;
+}
+
+function normalizeContractOutputs(outputs: NoirCompiledContract['outputs']): ContractArtifact['outputs'] {
+  return {
+    structs: outputs.structs,
+    globals: Object.fromEntries(
+      Object.entries(outputs.globals).map(([tag, values]) => [
+        tag,
+        values.map(value => (isAbiNamedValue(value) ? value.value : value)),
+      ]),
+    ),
+  };
+}
+
 /**
- * Given a Nargo output generates an Aztec-compatible contract artifact.
+ * Given a post-processed Nargo output defined as `contract` generates an Aztec-compatible contract artifact.
+ *
  * Does not include public bytecode, apart from the public_dispatch function.
- * @param compiled - Noir build output.
- * @returns Aztec contract build artifact.
  */
 function generateContractArtifact(contract: NoirCompiledContract): ContractArtifact {
   try {
     if (!contract.transpiled) {
       throw new Error("Contract's public bytecode has not been transpiled");
     }
+    const outputs = normalizeContractOutputs(contract.outputs);
     return ContractArtifactSchema.parse({
       name: contract.name,
+      aztecVersion: contract.aztec_version,
       functions: contract.functions.filter(f => retainBytecode(f)).map(f => generateFunctionArtifact(f, contract)),
       nonDispatchPublicFunctions: contract.functions
         .filter(f => !retainBytecode(f))
         .map(f => generateFunctionAbi(f, contract)),
-      outputs: contract.outputs,
-      storageLayout: getStorageLayout(contract),
+      outputs,
+      storageLayout: getStorageLayout(contract.name, outputs.globals),
       fileMap: contract.file_map,
     });
   } catch (err) {
@@ -302,21 +330,22 @@ function generateContractArtifact(contract: NoirCompiledContract): ContractArtif
 }
 
 /**
- * Given a Nargo output generates an Aztec-compatible contract artifact.
+ * Given a post-processed Nargo output defined as `contract` generates an Aztec-compatible contract artifact.
+ *
  * Retains all public bytecode.
- * @param compiled - Noir build output.
- * @returns Aztec contract build artifact.
  */
 function generateContractArtifactForPublic(contract: NoirCompiledContract): ContractArtifact {
   try {
+    const outputs = normalizeContractOutputs(contract.outputs);
     return ContractArtifactSchema.parse({
       name: contract.name,
+      aztecVersion: contract.aztec_version,
       functions: contract.functions.map(f => generateFunctionArtifact(f, contract)),
       nonDispatchPublicFunctions: contract.functions
         .filter(f => !retainBytecode(f))
         .map(f => generateFunctionAbi(f, contract)),
-      outputs: contract.outputs,
-      storageLayout: getStorageLayout(contract),
+      outputs,
+      storageLayout: getStorageLayout(contract.name, outputs.globals),
       fileMap: contract.file_map,
     });
   } catch (err) {

package/src/abi/decoder.ts

@@ -1,29 +1,45 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
 
 import { AztecAddress } from '../aztec-address/index.js';
-import type { ABIParameter, ABIVariable, AbiType } from './abi.js';
-import { isAztecAddressStruct, parseSignedInt } from './utils.js';
+import type { AbiType } from './abi.js';
+import { FunctionSelector } from './function_selector.js';
+import {
+  isAztecAddressStruct,
+  isEthAddressStruct,
+  isFunctionSelectorStruct,
+  isOptionStruct,
+  isWrappedFieldStruct,
+  parseSignedInt,
+} from './utils.js';
 
 /**
  * The type of our decoded ABI.
  */
-export type AbiDecoded = bigint | boolean | string | AztecAddress | AbiDecoded[] | { [key: string]: AbiDecoded };
+export type AbiDecoded =
+  | bigint
+  | boolean
+  | string
+  | AztecAddress
+  | EthAddress
+  | FunctionSelector
+  | Fr
+  | AbiDecoded[]
+  | { [key: string]: AbiDecoded }
+  | undefined;
 
 /**
  * Decodes values using a provided ABI.
  */
 class AbiDecoder {
-  constructor(
-    private types: AbiType[],
-    private flattened: Fr[],
-  ) {}
+  constructor(private flattened: Fr[]) {}
 
   /**
-   * Decodes a single return value from field to the given type.
-   * @param abiType - The type of the return value.
-   * @returns The decoded return value.
+   * Decodes a single value from field to the given type.
+   * @param abiType - The type of the value.
+   * @returns The decoded value.
    */
-  private decodeNext(abiType: AbiType): AbiDecoded {
+  public decodeNext(abiType: AbiType): AbiDecoded {
     switch (abiType.kind) {
       case 'field':
         return this.getNextField().toBigInt();
@@ -51,6 +67,20 @@ class AbiDecoder {
         if (isAztecAddressStruct(abiType)) {
           return new AztecAddress(this.getNextField().toBuffer());
         }
+        if (isEthAddressStruct(abiType)) {
+          return EthAddress.fromField(this.getNextField());
+        }
+        if (isFunctionSelectorStruct(abiType)) {
+          return FunctionSelector.fromField(this.getNextField());
+        }
+        if (isWrappedFieldStruct(abiType)) {
+          return this.getNextField();
+        }
+        if (isOptionStruct(abiType)) {
+          const isSome = this.decodeNext(abiType.fields[0].type);
+          const value = this.decodeNext(abiType.fields[1].type);
+          return isSome ? value : undefined;
+        }
 
         for (const field of abiType.fields) {
           struct[field.name] = this.decodeNext(field.type);
@@ -88,105 +118,25 @@ class AbiDecoder {
     }
     return field;
   }
-
-  /**
-   * Decodes all the values for the given ABI.
-   * The decided value can be simple types, structs or arrays
-   * @returns The decoded return values.
-   */
-  public decode(): AbiDecoded {
-    if (this.types.length === 1) {
-      return this.decodeNext(this.types[0]);
-    }
-    return this.types.map(type => this.decodeNext(type));
-  }
 }
 
 /**
- * Decodes values in a flattened Field array using a provided ABI.
- * @param abi - The ABI to use as reference.
+ * Decodes the single value a function returns, or undefined if it returns nothing. Multiple return values are expressed
+ * as one `tuple` type, so they decode through here too.
+ * @param type - The type the function returns.
  * @param buffer - The flattened Field array to decode.
- * @returns
- */
-export function decodeFromAbi(typ: AbiType[], buffer: Fr[]) {
-  return new AbiDecoder(typ, buffer.slice()).decode();
-}
-
-/**
- * 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':
-        if (param.sign === 'signed') {
-          throw new Error('Unsupported type: signed integer');
-        }
-        return `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();
+export function decodeFromAbi(type: AbiType | undefined, buffer: Fr[]): AbiDecoded {
+  return type === undefined ? undefined : new AbiDecoder(buffer.slice()).decodeNext(type);
 }
 
 /**
- * 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.
+ * Decodes one value per given type, consumed from the buffer in order. Always returns one decoded value per type, so
+ * callers can index the result positionally. A function's arguments are encoded this way.
+ * @param types - The type of each value, in order.
+ * @param buffer - The flattened Field array to decode.
  */
-export function decodeFunctionSignatureWithParameterNames(name: string, parameters: ABIParameter[]) {
-  return new FunctionSignatureDecoder(name, parameters, true).decode();
+export function decodeEachFromAbi(types: AbiType[], buffer: Fr[]): AbiDecoded[] {
+  const decoder = new AbiDecoder(buffer.slice());
+  return types.map(type => decoder.decodeNext(type));
 }

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, getFunctionReturnType } from './abi.js';
 import { FunctionSelector } from './function_selector.js';
 
 /** A request to call a function on a contract. */
@@ -22,8 +25,8 @@ export class FunctionCall {
     public isStatic: boolean,
     /** The encoded args */
     public args: Fr[],
-    /** The return type for decoding */
-    public returnTypes: AbiType[],
+    /** The type the call returns, for decoding, or undefined if it returns nothing */
+    public returnType?: AbiType,
   ) {}
 
   static getFields(fields: FieldsOf<FunctionCall>) {
@@ -35,7 +38,7 @@ export class FunctionCall {
       fields.hideMsgSender,
       fields.isStatic,
       fields.args,
-      fields.returnTypes,
+      fields.returnType,
     ] as const;
   }
 
@@ -43,12 +46,44 @@ 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),
+        returnType: AbiTypeSchema.optional(),
+        // Old consumers send `returnTypes`, not `returnType`. So we accept both for now, until we can safely remove
+        // the old version.
+        returnTypes: z.array(AbiTypeSchema).optional(),
+      })
+      .transform(({ returnType, returnTypes, ...fields }) =>
+        FunctionCall.from({ ...fields, returnType: getFunctionReturnType({ returnType, returnTypes }) }),
+      );
+  }
+
+  /**
+   * Serializes the deprecated `returnTypes` alongside `returnType`, so that peers that still require the old field can
+   * parse calls sent by this version.
+   */
+  public toJSON() {
+    return { ...this, returnTypes: this.returnType ? [this.returnType] : [] };
+  }
+
+  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(),
@@ -56,7 +91,6 @@ export class FunctionCall {
       hideMsgSender: false,
       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);