@aztec/foundation 0.0.0-test.0

package/src/eth-signature/eth_signature.ts

@@ -0,0 +1,128 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+import { hasHexPrefix, hexToBuffer } from '../string/index.js';
+
+/**Viem Signature
+ *
+ * A version of the Signature class that uses `0x${string}` values for r and s rather than
+ * Buffer32s
+ */
+export type ViemSignature = {
+  r: `0x${string}`;
+  s: `0x${string}`;
+  v: number;
+  isEmpty: boolean;
+};
+
+/**
+ * Signature
+ *
+ * Contains a signature split into it's primary components (r,s,v)
+ */
+export class Signature {
+  // Cached values
+  private size: number | undefined;
+
+  constructor(
+    /** The r value of the signature */
+    public readonly r: Buffer32,
+    /** The s value of the signature */
+    public readonly s: Buffer32,
+    /** The v value of the signature */
+    public readonly v: number,
+    /** Does this struct store an empty signature */
+    public readonly isEmpty: boolean = false,
+  ) {}
+
+  static fromBuffer(buf: Buffer | BufferReader): Signature {
+    const reader = BufferReader.asReader(buf);
+
+    const r = reader.readObject(Buffer32);
+    const s = reader.readObject(Buffer32);
+    const v = reader.readNumber();
+
+    const isEmpty = r.isZero() && s.isZero();
+
+    return new Signature(r, s, v, isEmpty);
+  }
+
+  static isValidString(sig: `0x${string}`): boolean {
+    return /^0x[0-9a-f]{129,}$/i.test(sig);
+  }
+
+  /**
+   * A seperate method exists for this as when signing locally with viem, as when
+   * parsing from viem, we can expect the v value to be a u8, rather than our
+   * default serialization of u32
+   */
+  static fromString(sig: `0x${string}`): Signature {
+    const buf = hexToBuffer(sig);
+    const reader = BufferReader.asReader(buf);
+    const r = reader.readObject(Buffer32);
+    const s = reader.readObject(Buffer32);
+    const v = parseInt(sig.slice(2 + 64 * 2), 16);
+
+    const isEmpty = r.isZero() && s.isZero();
+
+    return new Signature(r, s, v, isEmpty);
+  }
+
+  static random(): Signature {
+    return new Signature(Buffer32.random(), Buffer32.random(), Math.floor(Math.random() * 2), false);
+  }
+
+  static empty(): Signature {
+    return new Signature(Buffer32.ZERO, Buffer32.ZERO, 0, true);
+  }
+
+  equals(other: Signature): boolean {
+    return this.r.equals(other.r) && this.s.equals(other.s) && this.v === other.v && this.isEmpty === other.isEmpty;
+  }
+
+  toBuffer(): Buffer {
+    const buffer = serializeToBuffer([this.r, this.s, this.v]);
+    this.size = buffer.length;
+    return buffer;
+  }
+
+  getSize(): number {
+    // We cache size to avoid recalculating it
+    if (this.size) {
+      return this.size;
+    }
+
+    this.size = this.toBuffer().length;
+    return this.size;
+  }
+
+  toString(): `0x${string}` {
+    return `0x${this.r.buffer.toString('hex')}${this.s.buffer.toString('hex')}${this.v.toString(16)}`;
+  }
+
+  /**
+   * Return the signature with `0x${string}` encodings for r and s
+   */
+  toViemSignature(): ViemSignature {
+    return {
+      r: this.r.toString(),
+      s: this.s.toString(),
+      v: this.v,
+      isEmpty: this.isEmpty,
+    };
+  }
+
+  toJSON() {
+    return this.toString();
+  }
+
+  static get schema() {
+    return z
+      .string()
+      .refine(hasHexPrefix, 'No hex prefix')
+      .refine(Signature.isValidString, 'Not a valid Ethereum signature')
+      .transform(Signature.fromString);
+  }
+}

package/src/eth-signature/index.ts

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

package/src/fields/coordinate.ts

@@ -0,0 +1,104 @@
+import { toBigIntBE } from '../bigint-buffer/index.js';
+import type { Tuple } from '../serialize/types.js';
+import { Fr } from './fields.js';
+
+/**
+ * Class to wrap a single point coordinate.
+ * This class handles the complexities of representing point coordinates as 32 byte buffers as well as fields.
+ * The coordinate value is split across 2 fields to ensure that the max size of a field is not breached.
+ * This is achieved by placing the most significant byte of the lower field into the least significant byte of the higher field.
+ * Calls to 'toBuffer' or 'toBigInt' undo this change and simply return the original 32 byte value.
+ * Calls to 'toFieldsBuffer' will return a 64 bytes buffer containing the serialized fields.
+ */
+export class Coordinate {
+  static ZERO = new Coordinate([Fr.ZERO, Fr.ZERO]);
+
+  constructor(
+    /**
+     * The fields of the coordinate value. Least significant limb at index 0.
+     */
+    public fields: Tuple<Fr, 2>,
+  ) {}
+
+  /**
+   * Converts the coordinate data into a tuple of fields
+   * @returns A tuple of the coordinate fields
+   */
+  toFields(): Tuple<Fr, 2> {
+    return this.fields;
+  }
+
+  /**
+   * Generates a random coordinate value
+   * @returns The random coordinate
+   */
+  static random(): Coordinate {
+    return this.fromField(Fr.random());
+  }
+
+  /**
+   * serializes the object to buffer of 2 fields.
+   * @returns A buffer serialization of the object.
+   */
+  toFieldsBuffer(): Buffer {
+    return Buffer.concat([this.fields[0].toBuffer(), this.fields[1].toBuffer()]);
+  }
+
+  /**
+   * serializes the coordinate to a single 32 byte buffer.
+   * @returns A buffer serialization of the object.
+   */
+  toBuffer(): Buffer {
+    const buf0 = this.fields[0].toBuffer();
+    const buf1 = this.fields[1].toBuffer();
+    buf0[0] = buf1[31];
+    return buf0;
+  }
+
+  /**
+   * Returns true if this coordinate is equal to the one provided
+   * @param other - The coordinate against which to compare
+   * @returns True if the coordinates are the same, false otherwise
+   */
+  equals(other: Coordinate): boolean {
+    return this.toBigInt() === other.toBigInt();
+  }
+
+  /**
+   * Returns the coordinate's value as a bigint
+   * @returns The coordinate value as a bigint
+   */
+  toBigInt(): bigint {
+    return toBigIntBE(this.toBuffer());
+  }
+
+  /**
+   * Creates a coordinate object from a 32 byte coordinate value
+   * @param coordinate - A buffer containing the 32 byte coordinate value
+   * @returns The new coordinate object
+   */
+  static fromBuffer(coordinate: Buffer) {
+    if (coordinate.length != 32) {
+      throw new Error(`Invalid size of coordinate buffer`);
+    }
+    const buf0 = Buffer.alloc(32);
+    coordinate.copy(buf0, 0, 0, 32);
+    const buf1 = Buffer.alloc(32);
+    buf1[31] = buf0[0];
+    buf0[0] = 0;
+    return new Coordinate([Fr.fromBuffer(buf0), Fr.fromBuffer(buf1)]);
+  }
+
+  /**
+   * Creates a coordinate object from a field
+   * @param coordinate - The field containing the coordinate
+   * @returns The new coordinate object
+   */
+  static fromField(coordinate: Fr) {
+    const buf0 = coordinate.toBuffer();
+    const buf1 = Buffer.alloc(32);
+    buf1[31] = buf0[0];
+    buf0[0] = 0;
+    return new Coordinate([Fr.fromBuffer(buf0), Fr.fromBuffer(buf1)]);
+  }
+}