@andy-liquid-labs/lighter-ts-sdk 1.0.0

package/src/crypto/goldilocks.ts

@@ -0,0 +1,136 @@
+/**
+ * Goldilocks Prime Field implementation
+ * Field modulus: p = 2^64 - 2^32 + 1
+ */
+
+export const GOLDILOCKS_MODULUS = 0xffffffff00000001n;
+
+export function toCanonicalUint64(x: bigint): bigint {
+  return x >= GOLDILOCKS_MODULUS ? x - GOLDILOCKS_MODULUS : x;
+}
+
+/**
+ * Goldilocks field element
+ */
+export class GoldilocksElement {
+  readonly value: bigint;
+
+  constructor(value: bigint) {
+    this.value = mod(value, GOLDILOCKS_MODULUS);
+  }
+
+  add(other: GoldilocksElement): GoldilocksElement {
+    return new GoldilocksElement(this.value + other.value);
+  }
+
+  sub(other: GoldilocksElement): GoldilocksElement {
+    return new GoldilocksElement(this.value - other.value + GOLDILOCKS_MODULUS);
+  }
+
+  mul(other: GoldilocksElement): GoldilocksElement {
+    return new GoldilocksElement(this.value * other.value);
+  }
+
+  square(): GoldilocksElement {
+    return this.mul(this);
+  }
+
+  static fromUint32(value: number): GoldilocksElement {
+    return new GoldilocksElement(BigInt(value >>> 0));
+  }
+
+  static fromInt64(value: bigint): GoldilocksElement {
+    // Handle signed values
+    if (value < 0n) {
+      return new GoldilocksElement(value + GOLDILOCKS_MODULUS);
+    }
+    return new GoldilocksElement(value);
+  }
+
+  static fromUint64(value: bigint): GoldilocksElement {
+    return new GoldilocksElement(value & 0xffffffffffffffffn);
+  }
+
+  static zero(): GoldilocksElement {
+    return new GoldilocksElement(0n);
+  }
+
+  static one(): GoldilocksElement {
+    return new GoldilocksElement(1n);
+  }
+
+  toLittleEndianBytes(): Uint8Array {
+    const bytes = new Uint8Array(8);
+    let val = this.value;
+    for (let i = 0; i < 8; i++) {
+      bytes[i] = Number(val & 0xffn);
+      val >>= 8n;
+    }
+    return bytes;
+  }
+
+  static fromLittleEndianBytes(bytes: Uint8Array): GoldilocksElement {
+    let value = 0n;
+    for (let i = bytes.length - 1; i >= 0; i--) {
+      value = (value << 8n) | BigInt(bytes[i]);
+    }
+    return new GoldilocksElement(value);
+  }
+}
+
+/**
+ * Modular reduction
+ */
+function mod(a: bigint, m: bigint): bigint {
+  const result = a % m;
+  return result >= 0n ? result : result + m;
+}
+
+/**
+ * Convert bytes to Goldilocks field elements
+ * Each element holds up to 7 bytes of data
+ */
+export function bytesToFieldElements(bytes: Uint8Array): GoldilocksElement[] {
+  const elements: GoldilocksElement[] = [];
+  const bytesPerElement = 7;
+
+  for (let i = 0; i < bytes.length; i += bytesPerElement) {
+    const chunk = bytes.slice(i, Math.min(i + bytesPerElement, bytes.length));
+    let value = 0n;
+    for (let j = chunk.length - 1; j >= 0; j--) {
+      value = (value << 8n) | BigInt(chunk[j]);
+    }
+    elements.push(new GoldilocksElement(value));
+  }
+
+  return elements;
+}
+
+/**
+ * Convert bytes to Goldilocks field elements using canonical little-endian
+ * 8-byte chunks, matching ArrayFromCanonicalLittleEndianBytes in Go.
+ */
+export function bytesToFieldElementsCanonicalLE(
+  bytes: Uint8Array,
+): GoldilocksElement[] {
+  const elements: GoldilocksElement[] = [];
+  const bytesPerElement = 8;
+
+  for (let i = 0; i < bytes.length; i += bytesPerElement) {
+    const chunk = bytes.slice(i, Math.min(i + bytesPerElement, bytes.length));
+    let value = 0n;
+    for (let j = chunk.length - 1; j >= 0; j--) {
+      value = (value << 8n) | BigInt(chunk[j]);
+    }
+
+    if (value >= GOLDILOCKS_MODULUS) {
+      throw new Error(
+        `Non-canonical Goldilocks element from bytes: ${value.toString(16)}`,
+      );
+    }
+
+    elements.push(new GoldilocksElement(value));
+  }
+
+  return elements;
+}