functionalscript 0.1.609 → 0.2.1

package/{prime_field → out/prime_field}/module.f.d.mts

@@ -1,25 +1,3 @@
-declare namespace _default {
-    export { prime_field };
-    export let sqrt: (f: PrimeField) => (a: bigint) => bigint | null;
-}
-export default _default;
-export type Reduce = Operator.Reduce<bigint>;
-export type Unary = Operator.Unary<bigint, bigint>;
-export type PrimeField = {
-    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;
-};
 /** @typedef {Operator.Reduce<bigint>} Reduce */
 /** @typedef {Operator.Unary<bigint, bigint>} Unary*/
 /**
@@ -40,5 +18,24 @@ export type PrimeField = {
  * }} PrimeField
  */
 /** @type {(p: bigint) => PrimeField} */
-declare const prime_field: (p: bigint) => PrimeField;
+export const prime_field: (p: bigint) => PrimeField;
+/** @type {(f: PrimeField) => (a: bigint) => bigint|null} */
+export const sqrt: (f: PrimeField) => (a: bigint) => bigint | null;
+export type Reduce = Operator.Reduce<bigint>;
+export type Unary = Operator.Unary<bigint, bigint>;
+export type PrimeField = {
+    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;
+};
 import * as Operator from '../types/function/operator/module.f.mjs';

package/out/prime_field/module.f.mjs

@@ -0,0 +1,87 @@
+// @ts-self-types="./module.f.d.mts"
+import * as Operator from '../types/function/operator/module.f.mjs';
+import * as bi from '../types/bigint/module.f.mjs';
+const { scalar_mul } = bi;
+/** @typedef {Operator.Reduce<bigint>} Reduce */
+/** @typedef {Operator.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 {(p: bigint) => PrimeField} */
+export 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({ 0: 1n, add: 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))
+    };
+};
+/** @type {(f: PrimeField) => (a: bigint) => bigint|null} */
+export const 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/out/prime_field/test.f.mjs

@@ -0,0 +1,145 @@
+import * as _ from './module.f.mjs';
+const { prime_field, sqrt } = _;
+export default {
+    prime_field_test: () => {
+        const p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
+        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) !== 20705n) {
+                    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(308763n)) {
+                    throw '-507 * 609';
+                }
+                if (f.mul(f.neg(713n))(f.neg(825n)) !== 588225n) {
+                    throw '-713 * -825';
+                }
+            },
+            reciprocal: () => {
+                let i = 1n;
+                while (i < 10000n) {
+                    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 → out/secp}/module.f.d.mts

@@ -1,27 +1,3 @@
-declare namespace _default {
-    export { curve };
-    export let eq: (a: Point) => (b: Point) => boolean;
-    export let secp256k1: Init;
-    export let secp192r1: Init;
-}
-export default _default;
-export type Point2D = readonly [bigint, bigint];
-export type Point = Point2D | null;
-export type Init = {
-    readonly p: bigint;
-    readonly a: readonly [bigint, bigint];
-    readonly g: readonly [bigint, bigint];
-    readonly n: bigint;
-};
-export type Curve = {
-    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: Operator.Reduce<Point>;
-    readonly mul: (a: Point) => (n: bigint) => Point;
-};
 /** @typedef {readonly[bigint, bigint]} Point2D */
 /** @typedef {Point2D|null} Point */
 /**
@@ -34,8 +10,8 @@ export type Curve = {
  */
 /**
  * @typedef {{
- *  readonly pf: Pf.PrimeField
- *  readonly nf: Pf.PrimeField
+ *  readonly pf: pf.PrimeField
+ *  readonly nf: pf.PrimeField
  *  readonly y2: (x: bigint) => bigint
  *  readonly y: (x: bigint) => bigint|null
  *  readonly neg: (a: Point) => Point
@@ -44,6 +20,29 @@ export type Curve = {
  * }} Curve
  */
 /** @type {(i: Init) => Curve} */
-declare const curve: (i: Init) => Curve;
-import * as Pf from '../prime_field/module.f.mjs';
+export const curve: (i: Init) => Curve;
+/** @type {(a: Point) => (b: Point) => boolean} */
+export const eq: (a: Point) => (b: Point) => boolean;
+/** @type {Init} */
+export const secp256k1: Init;
+/** @type {Init} */
+export const secp192r1: Init;
+export type Point2D = readonly [bigint, bigint];
+export type Point = Point2D | null;
+export type Init = {
+    readonly p: bigint;
+    readonly a: readonly [bigint, bigint];
+    readonly g: readonly [bigint, bigint];
+    readonly n: bigint;
+};
+export type Curve = {
+    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: Operator.Reduce<Point>;
+    readonly mul: (a: Point) => (n: bigint) => Point;
+};
+import * as pf from '../prime_field/module.f.mjs';
 import * as Operator from '../types/function/operator/module.f.mjs';

package/out/secp/module.f.mjs

@@ -0,0 +1,113 @@
+// @ts-self-types="./module.f.d.mts"
+import * as Operator from '../types/function/operator/module.f.mjs';
+import * as pf from '../prime_field/module.f.mjs';
+import * as bi from '../types/bigint/module.f.mjs';
+const { scalar_mul } = bi;
+const { 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: Operator.Reduce<Point>
+ *  readonly mul: (a: Point) => (n: bigint) => Point
+ * }} Curve
+ */
+/** @type {(i: Init) => Curve} */
+export 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 {Operator.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({ 0: null, add: addPoint })
+    };
+};
+/** @type {(a: Point) => (b: Point) => boolean} */
+export const 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} */
+export const secp256k1 = {
+    p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn,
+    a: [7n, 0n],
+    g: [
+        0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n,
+        0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n
+    ],
+    n: 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n,
+};
+/** @type {Init} */
+export const secp192r1 = {
+    p: 0xfffffffffffffffffffffffffffffffeffffffffffffffffn,
+    a: [
+        0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1n,
+        0xfffffffffffffffffffffffffffffffefffffffffffffffcn
+    ],
+    g: [
+        0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012n,
+        0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811n
+    ],
+    n: 0xffffffffffffffffffffffff99def836146bc9b1b4d22831n,
+};

package/out/secp/test.f.mjs

@@ -0,0 +1,63 @@
+import * as _ from './module.f.mjs';
+const { curve, secp256k1, secp192r1, eq } = _;
+export default {
+    test: () => {
+        /** @type {(c: _.Init) => void} */
+        const test_curve = c => {
+            const { g } = c;
+            const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c);
+            /** @type {(p: _.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: _.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);
+    }
+};

package/out/sha2/module.f.d.mts

@@ -0,0 +1,15 @@
+/** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
+export const padding: (input: readonly number[]) => (bits: number) => HashInput;
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+export const computeSha256: (input: readonly number[]) => (bitsCount: number) => Hash8;
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+export const computeSha224: (input: readonly number[]) => (bitsCount: number) => Hash8;
+export const compress256: (data: Array16) => Hash8;
+export const compress224: (data: Array16) => Hash8;
+export type HashInput = {
+    readonly f: (i: number) => number;
+    readonly length: number;
+};
+export type Hash8 = arrayT.Array8<number>;
+export type Array16 = arrayT.Array16<number>;
+import * as arrayT from '../types/array/module.f.mjs';