functionalscript 0.0.549 → 0.0.550

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.549",
+  "version": "0.0.550",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/prime_field/module.f.cjs

@@ -1,39 +1,54 @@
-/**
- * @typedef {{
- *  readonly p: bigint
- *  readonly a: bigint
- *  readonly b: bigint
- *  readonly g: readonly[bigint, bigint]
- *  readonly n: bigint
- * }} Curve
- */
+const op = require('../types/function/operator/module.f.cjs')
+
+/** @typedef {op.Reduce<bigint>} Reduce */
+
+/** @typedef {op.Unary<bigint, bigint>} Unary*/
 
 /**
  * @typedef {{
+ *  readonly p: bigint
  *  readonly middle: bigint
  *  readonly max: bigint
- *  readonly neg: (a: bigint) => bigint
- *  readonly sub: (a: bigint) => (b: bigint) => bigint
- *  readonly add: (a: bigint) => (b: bigint) => bigint
- *  readonly abs: (a: bigint) => bigint
- *  readonly mul: (a: bigint) => (b: bigint) => bigint
- *  readonly reciprocal: (a: bigint) => bigint
- *  readonly div: (a: bigint) => (b: bigint) => bigint
- *  readonly pow: (a: bigint) => (b: bigint) => bigint
- *  readonly sqrt: (a: bigint) => bigint|null
+ *  readonly neg: Unary
+ *  readonly sub: Reduce
+ *  readonly add: Reduce
+ *  readonly abs: Unary
+ *  readonly mul: Reduce
+ *  readonly reciprocal: Unary
+ *  readonly div: Reduce
+ *  readonly pow: Reduce
+ *  readonly pow2: Unary
+ *  readonly pow3: Unary
  * }} PrimeField
  */
 
+/** @type {<T>(zero: T, add: op.Reduce<T>) => (a: T) => (n: bigint) => T} */
+const scalar_mul = (zero, add) => a => n => {
+    let ai = a
+    let ni = n
+    let result = zero
+    while (true) {
+        if ((ni & 1n) === 1n) {
+            result = add(result)(ai)
+        }
+        ni >>= 1n
+        if (ni === 0n) {
+            return result
+        }
+        ai = add(ai)(ai)
+    }
+}
+
 /** @type {(p: bigint) => PrimeField} */
 const prime_field = p => {
-    /** @type {(a: bigint) => (b: bigint) => bigint} */
+    /** @type {Reduce} */
     const sub = a => b => {
         const r = a - b
         return r < 0 ? r + p : r
     }
-    /** @type {(a: bigint) => (b: bigint) => bigint} */
+    /** @type {Reduce} */
     const mul = a => b => a * b % p
-    /** @type {(a: bigint) => bigint} */
+    /** @type {Unary} */
     const reciprocal = a => {
         if (a === 0n) { throw '1/0' }
         let a1 = a
@@ -52,23 +67,12 @@ const prime_field = p => {
         return f1
     }
     const middle = p >> 1n
-    if ((p & 3n) !== 3n) { throw 'sqrt' }
-    const sqrt_k = (p + 1n) >> 2n
-    /** @type {(a: bigint) => (n: bigint) => bigint} */
-    const pow = a => n => {
-        let result = 1n
-        while (true) {
-            if ((n & 1n) === 1n) {
-                result = mul(result)(a)
-            }
-            n >>= 1n
-            if (n === 0n) {
-                return result
-            }
-            a = mul(a)(a)
-        }
-    }
+    /** @type {Unary} */
+    const pow2 = a => mul(a)(a)
+    /** @type {Reduce} */
+    const pow = scalar_mul(1n, mul)
     return {
+        p,
         middle,
         max: p - 1n,
         neg: a => a === 0n ? 0n : p - a,
@@ -82,13 +86,21 @@ const prime_field = p => {
         reciprocal,
         div: a => b => mul(a)(reciprocal(b)),
         pow,
-        sqrt: a => {
-            const result = pow(a)(sqrt_k)
-            return mul(result)(result) === a ? result : null
-        }
+        pow2,
+        pow3: a => mul(a)(pow2(a))
     }
 }
 
 module.exports = {
-    prime_field
+    scalar_mul,
+    prime_field,
+    /** @type {(f: PrimeField) => (a: bigint) => bigint|null} */
+    sqrt: ({p, mul, pow }) => {
+        if ((p & 3n) !== 3n) { throw 'sqrt' }
+        const sqrt_k = (p + 1n) >> 2n
+        return a => {
+            const result = pow(a)(sqrt_k)
+            return mul(result)(result) === a ? result : null
+        }
+    }
 }

package/prime_field/test.f.cjs

@@ -1,9 +1,10 @@
-const { prime_field } = require('./module.f.cjs')
+const { prime_field, sqrt } = require('./module.f.cjs')
 
 module.exports = {
     prime_field_test: () => {
         const p = 0xffffffff_ffffffff_ffffffff_ffffffff_ffffffff_ffffffff_fffffffe_fffffc2fn;
         const f = prime_field(p)
+        const sqrt_f = sqrt(f)
         return {
             neg: () => {
                 if (f.neg(0n) !== 0n) { throw '-0' }
@@ -41,7 +42,7 @@ module.exports = {
                     // a^(p-1) % p = 1
                     if (f.abs(f.pow(a)(f.middle)) !== 1n) { throw '**middle' }
                     if (f.pow(a)(f.sub(f.max)(1n)) !== f.reciprocal(a)) { throw '**(max-1)' }
-                    if (f.pow(a)(f.max) !== 1n) { throw '**max-1' }
+                    if (f.pow(a)(f.max) !== 1n) { throw '**max' }
                 }
                 // 0
                 if (f.pow(0n)(0n) !== 1n) { throw '0**0'}
@@ -70,7 +71,7 @@ module.exports = {
                 /** @type {(a: bigint) => void} */
                 const test = a => {
                     const a2 = f.mul(a)(a)
-                    const s = f.sqrt(a2)
+                    const s = sqrt_f(a2)
                     if (s !== null && f.abs(s) !== f.abs(a)) { throw 'sqrt' }
                 }
                 let i = 1n

package/secp/module.f.cjs

@@ -0,0 +1,119 @@
+const op = require('../types/function/operator/module.f.cjs')
+const pf = require('../prime_field/module.f.cjs')
+const { scalar_mul, prime_field, sqrt } = pf
+
+/** @typedef {readonly[bigint, bigint]} Point2D */
+
+/** @typedef {Point2D|null} Point */
+
+/**
+ * @typedef {{
+ *  readonly p: bigint
+ *  readonly a: readonly[bigint, bigint]
+ *  readonly g: readonly[bigint, bigint]
+ *  readonly n: bigint
+ * }} Init
+ */
+
+/**
+ * @typedef {{
+ *  readonly pf: pf.PrimeField
+ *  readonly nf: pf.PrimeField
+ *  readonly y2: (x: bigint) => bigint
+ *  readonly y: (x: bigint) => bigint|null
+ *  readonly neg: (a: Point) => Point
+ *  readonly add: op.Reduce<Point>
+ *  readonly mul: (a: Point) => (n: bigint) => Point
+ * }} Curve
+ */
+
+/** @type {(i: Init) => Curve} */
+const curve = ({ p, a: [a0, a1], n }) => {
+    const pf = prime_field(p)
+    const { pow2, pow3, sub, add, mul, neg, div } = pf
+    const mul3 = mul(3n)
+    const mul2 = mul(2n)
+    const addA1 = add(a1)
+    const mulA1 = mul(a1)
+    const addA0 = add(a0)
+    // y**2 = a1*x**3 + a0
+    /** @type {(x: bigint) => bigint} */
+    const y2 = x => addA0(add(pow3(x))(mulA1(x)))
+    /** @type {op.Reduce<Point>} */
+    const addPoint = p => q => {
+        if (p === null) {
+            return q
+        }
+        if (q === null) {
+            return p
+        }
+        const [px, py] = p
+        const [qx, qy] = q
+        const md = px === qx
+            // (3 * px ** 2 + a1) / (2 * py)
+            ? py !== qy || py === 0n ? null : [addA1(mul3(pow2(px))), mul2(py)]
+            // (py - qy) / (px - qx)
+            : [sub(py)(qy), sub(px)(qx)]
+        if (md === null) {
+            return null
+        }
+        const [ma, mb] = md
+        const m = div(ma)(mb)
+        // m ** 2 - px - qx
+        const rx = sub(pow2(m))(add(px)(qx))
+        // [rx, m * (px - rx) - py]
+        return [rx, sub(mul(m)(sub(px)(rx)))(py)]
+    }
+    const sqrt_p = sqrt(pf)
+    return {
+        pf,
+        nf: prime_field(n),
+        y2,
+        y: x => sqrt_p(y2(x)),
+        neg: p => {
+            if (p === null) {
+                return null
+            }
+            const [x, y] = p
+            return [x, neg(y)]
+        },
+        add: addPoint,
+        mul: scalar_mul(null, addPoint)
+    }
+}
+
+module.exports = {
+    curve,
+    /** @type {(a: Point) => (b: Point) => boolean} */
+    eq: a => b => {
+        if (a === null || b === null) {
+            return a === b
+        }
+        const [ax, ay] = a
+        const [bx, by] = b
+        return ax === bx && ay === by
+    },
+    /** @type {Init} */
+    secp256k1: {
+        p: 0xffffffff_ffffffff_ffffffff_ffffffff_ffffffff_ffffffff_fffffffe_fffffc2fn,
+        a: [7n, 0n],
+        g: [
+            0x79be667e_f9dcbbac_55a06295_ce870b07_029bfcdb_2dce28d9_59f2815b_16f81798n,
+            0x483ada77_26a3c465_5da4fbfc_0e1108a8_fd17b448_a6855419_9c47d08f_fb10d4b8n
+        ],
+        n: 0xffffffff_ffffffff_ffffffff_fffffffe_baaedce6_af48a03b_bfd25e8c_d0364141n,
+    },
+    /** @type {Init} */
+    secp192r1: {
+        p: 0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_ffffffffn,
+        a: [
+            0x64210519_e59c80e7_0fa7e9ab_72243049_feb8deec_c146b9b1n,
+            0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_fffffffcn
+        ],
+        g: [
+            0x188da80e_b03090f6_7cbf20eb_43a18800_f4ff0afd_82ff1012n,
+            0x07192b95_ffc8da78_631011ed_6b24cdd5_73f977a1_1e794811n
+        ],
+        n: 0xffffffff_ffffffff_ffffffff_99def836_146bc9b1_b4d22831n,
+    },
+}

package/secp/test.f.cjs

@@ -0,0 +1,48 @@
+const m = require('./module.f.cjs')
+const { curve, secp256k1, secp192r1, eq } = m
+
+module.exports = {
+    test: () => {
+        /** @type {(c: m.Init) => void} */
+        const test_curve = c => {
+            const { g } = c
+            const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c)
+            /** @type {(p: m.Point) => void} */
+            const point_check = p => {
+                if (p === null) { throw 'null' }
+                const [x, y] = p
+                const ye = yf(x)
+                if (ye === null) { throw 'null' }
+                if (abs(ye) !== abs(y)) { throw 'ye' }
+            }
+            point_check(g)
+            point_check(neg(g))
+            /** @type {(p: m.Point) => void} */
+            const test_mul = p => {
+                if (mul(p)(0n) !== null) { throw 'O' }
+                if (mul(p)(1n) !== p) { throw 'p' }
+                if (mul(p)(n) !== null) { throw 'n' }
+                const pn = neg(p)
+                if (!eq(mul(p)(n - 1n))(pn)) { throw 'n - 1' }
+                /** @type {(s: bigint) => void} */
+                const f = s => {
+                    const r = mul(p)(s)
+                    point_check(r)
+                    const rn = mul(pn)(s)
+                    point_check(rn)
+                    if (!eq(r)(neg(rn))) { throw 'r != -rn' }
+                }
+                f(2n)
+                f(3n)
+                f(4n << 128n)
+                f((5n << 128n) + 6n)
+                f(7n << 128n)
+                f((8n << 128n) + 9n)
+            }
+            test_mul(g)
+            test_mul(neg(g))
+        }
+        test_curve(secp256k1)
+        test_curve(secp192r1)
+    }
+}