functionalscript 0.0.548 → 0.0.550

package/package.json

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

package/prime_field/module.f.cjs

@@ -0,0 +1,106 @@
+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: 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 {Reduce} */
+    const sub = a => b => {
+        const r = a - b
+        return r < 0 ? r + p : r
+    }
+    /** @type {Reduce} */
+    const mul = a => b => a * b % p
+    /** @type {Unary} */
+    const reciprocal = a => {
+        if (a === 0n) { throw '1/0' }
+        let a1 = a
+        let a0 = p
+        let f0 = 0n
+        let f1 = 1n
+        while (a1 !== 1n) {
+            const q = a0 / a1
+            const a2 = a0 % a1
+            a0 = a1
+            a1 = a2
+            const f2 = sub(f0)(mul(f1)(q))
+            f0 = f1
+            f1 = f2
+        }
+        return f1
+    }
+    const middle = p >> 1n
+    /** @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,
+        sub,
+        add: a => b => {
+            const r = a + b
+            return r < p ? r : r - p
+        },
+        abs: a => middle < a ? p - a : a,
+        mul,
+        reciprocal,
+        div: a => b => mul(a)(reciprocal(b)),
+        pow,
+        pow2,
+        pow3: a => mul(a)(pow2(a))
+    }
+}
+
+module.exports = {
+    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

@@ -0,0 +1,87 @@
+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' }
+                if (f.neg(1n) !== p - 1n) { throw '-1' }
+            },
+            sub: () => {
+                if (f.sub(10n)(4n) !== 6n) { throw '10 - 4'}
+                if (f.sub(11n)(14n) !== p - 3n) { throw '11 - 14' }
+            },
+            add: () => {
+                if (f.add(13n)(24n) !== 37n) { throw '13 + 24' }
+                if (f.add(77n)(f.neg(12n)) !== 65n) { throw '77 + (-12)' }
+            },
+            mul: () => {
+                if (f.mul(100n)(0n) !== 0n) { throw '100 * 0' }
+                if (f.mul(101n)(205n) !== 20_705n) { throw '101 * 205' }
+                if (f.mul(304n)(f.neg(1n)) !== f.neg(304n)) { throw '304 * -1' }
+                if (f.mul(f.neg(507n))(609n) !== f.neg(308_763n)) { throw '-507 * 609' }
+                if (f.mul(f.neg(713n))(f.neg(825n)) !== 588_225n) { throw '-713 * -825' }
+            },
+            reciprocal: () => {
+                let i = 1n
+                while (i < 10_000n) {
+                    const x = f.reciprocal(i)
+                    if (f.mul(x)(i) !== 1n) { throw i }
+                    ++i
+                }
+            },
+            pow: () => {
+                /** @type {(a: bigint) => void} */
+                const test = a => {
+                    if (f.pow(a)(0n) !== 1n) { throw '**0'}
+                    if (f.pow(a)(1n) !== a) { throw '**1' }
+                    // https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
+                    // 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' }
+                }
+                // 0
+                if (f.pow(0n)(0n) !== 1n) { throw '0**0'}
+                if (f.pow(0n)(f.max) !== 0n) { throw '0**max' }
+                // 1
+                test(1n)
+                // 2
+                test(2n)
+                if (f.pow(2n)(2n) !== 4n) { throw '2**2' }
+                if (f.pow(2n)(3n) !== 8n) { throw '2**3' }
+                if (f.pow(2n)(128n) !== 1n << 128n) { throw '2**128' }
+                // 3
+                test(3n)
+                if (f.pow(3n)(2n) !== 9n) { throw '3**2' }
+                if (f.pow(3n)(3n) !== 27n) { throw '3**3' }
+                if (f.pow(3n)(100n) !== 3n ** 100n) { throw '3**100' }
+                if (f.pow(3n)(110n) !== 3n ** 110n) { throw '3**110' }
+                if (f.pow(3n)(120n) !== 3n ** 120n) { throw '3**120' }
+                if (f.pow(3n)(121n) !== 3n ** 121n) { throw '3**121' }
+                //
+                test(f.middle)
+                test(f.max - 1n)
+                test(f.max)
+            },
+            sqrt: () => {
+                /** @type {(a: bigint) => void} */
+                const test = a => {
+                    const a2 = f.mul(a)(a)
+                    const s = sqrt_f(a2)
+                    if (s !== null && f.abs(s) !== f.abs(a)) { throw 'sqrt' }
+                }
+                let i = 1n
+                while (i < 1000n) {
+                    test(i)
+                    ++i;
+                }
+                test(f.middle);
+                test(f.max);
+            }
+        }
+    }
+}

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)
+    }
+}