finitefields 0.0.8 → 0.0.10

package/ellipticcurves.ts

@@ -7,13 +7,16 @@
  *
  */
 
-import type { GF,PrimeField } from './galois.js';
+import { PrimeField, type GF } from './galois.js';
+import { empty, fold, just, nothing, type Maybe, type Nothing } from './maybe.js';
 import { Util } from './galois.js';
 
+let 𝒪:Nothing;
 let log:(...x:any[])=>void;
 let fail:(...x:any[])=>never;
 let p256:()=>ECCurve;
 
+𝒪 = nothing();
 log = console.log;
 fail = (...args:any[]): never => {
     console.error(...args);
@@ -25,6 +28,7 @@ fail = (...args:any[]): never => {
 p256 = ():ECCurve => ({
    '#E': 0xffffffff00000000_ffffffffffffffff_bce6faada7179e84_f3b9cac2fc632551n,
     'θ': 0xffffffff00000001_0000000000000000_00000000ffffffff_ffffffffffffffffn,
+    'a': -3n,
     'b': 0x5ac635d8aa3a93e7_b3ebbd55769886bc_651d06b0cc53b0f6_3bce3c3e27d2604bn,
     'p':
      [
@@ -45,8 +49,10 @@ p256 = ():ECCurve => ({
 });
 
 type Tuple<a> = readonly [a,a];
+type Coordinate = Maybe<Point>;
 type infinity = false | true;
 type ECformula = (a:bigint,b:bigint,f:GF)=>Function;
+type Slope = bigint;
 
 interface Tuples {
     'p':    Tuple<bigint>;
@@ -55,6 +61,7 @@ interface Tuples {
 
 interface IECCurve {
     'θ':     bigint;
+    'a':     bigint;
     'b':     bigint;
     bitlen:  bigint;
     formula: ECformula;
@@ -66,6 +73,10 @@ interface ECCurve extends IECCurve,Tuples,hashE {};
 interface Iellipticcurves<a> {
     backend: a;
     constructor:Function;
+    add:(a:Coordinate,b:Coordinate)=>Coordinate;
+    double:(a:Coordinate)=>Coordinate;
+    get p(): Coordinate;
+    get q(): Coordinate;
 }
 
 interface Icurve extends IECCurve {
@@ -107,6 +118,7 @@ class Point implements Ipoint {
 class Curve<a> implements Icurve {
     #E: bigint;
     public θ: bigint;
+    public a: bigint;
     public b: bigint;
     public p: Point;
     public q: Point;
@@ -121,6 +133,8 @@ class Curve<a> implements Icurve {
             || fail(m);
         this.θ = curve.θ
             || fail(m);
+        this.a = curve.a
+            || fail(m);
         this.b = curve.b
             || fail(m);
         this.bitlen = curve.bitlen
@@ -134,10 +148,148 @@ class Curve<a> implements Icurve {
     }
 }
 
-abstract class EllipticCurves<a> implements Iellipticcurves<a> {
+abstract class EllipticCurves<a extends GF> implements Iellipticcurves<a> {
     public abstract backend: a;
     private curve: Curve<a>;
 
+    private eq(p:Point,q:Point): boolean {
+        return (
+            (!p || !q) ?
+                fail() :
+            (p['∞'] && q['∞']) ?
+                true :
+            (p['∞'] && !q['∞']) ?
+                false :
+            (!p['∞'] && q['∞']) ?
+                false :
+            ((p.x === q.x) && (p.y === q.y))
+        );
+    }
+
+    private isprimefield(f:GF): f is PrimeField {
+        return (f instanceof PrimeField);
+    }
+
+    private slope(p_:Point,q_:Point): (a:bigint,p:bigint)=>bigint {
+        let f:a;
+        const { x:x1,y:y1 } = p_;
+        const { x:x2,y:y2 } = q_;
+
+        if (!this.isprimefield(this.backend))
+            return fail();
+        else
+            f = this.backend;
+
+        return (this.eq(p_,q_)) ?
+                (a:bigint,p:bigint): bigint =>
+                    (f.mul(
+                        f.add(a,
+                            f.mul(3n, f.exp(x1, 2n))
+                        ),
+                        f.inv(f.mul(y1, 2n))
+                    ) % p) :
+                (a:bigint,p:bigint): bigint =>
+                    (f.mul(
+                        f.sub(y2, y1),
+                        f.inv(f.sub(x2, x1))
+                    ) % p);
+    }
+
+    private isinfinity(p:Point): infinity {
+        return false;
+    }
+
+    protected addpoints(p:Coordinate,q:Coordinate): Coordinate {
+        let s:Slope;
+        let p_:Point;
+        let q_:Point;
+        let x:bigint;
+        let y:bigint;
+        let t:Point;
+        let mt:Coordinate;
+        let Δx:bigint, Δy:bigint;
+        let f:a;
+
+        if (!this.isprimefield(this.backend))
+            return fail();
+        else
+            f = this.backend;
+
+        if (empty(p) && empty(q))
+            return <Maybe<Point>>nothing();
+        else if (empty(p))
+            return <Maybe<Point>>just(q as unknown as Point);
+        else if (empty(q))
+            return <Maybe<Point>>just(p as unknown as Point);
+        else
+            [p_, q_] = [fold(p), fold(q)];
+
+        const { x:x1,y:y1 } = p_;
+        const { x:x2,y:y2 } = q_;
+
+        s = this.slope(p_, q_)(this.curve.a, this.backend.p);
+        Δx = f.sub(x1, x2);
+        x = (f.sub(s, f.mul(s, s)) % this.backend.p);
+        Δy = f.sub(x1, x);
+        y = (f.sub(
+            f.mul(s, Δy),
+            y1
+        ) % this.backend.p);
+
+        t = new Point([x,y]);
+        if (this.isinfinity(t))
+            mt = nothing();
+        else
+            mt = just(t);
+
+        return mt;
+    }
+
+    protected doublepoint(a:Coordinate): Coordinate {
+        return this.add(a, a);
+    }
+
+    public add(a:Coordinate,b:Coordinate): Coordinate {
+        if (empty(a) && empty(b))
+            return <Maybe<Point>>nothing();
+        else if (empty(a))
+            return <Maybe<Point>>just(b as unknown as Point);
+        else if (empty(b))
+            return <Maybe<Point>>just(a as unknown as Point);
+        else
+            return <Maybe<Point>>this.addpoints(a,b);
+    }
+
+    public double(a:Coordinate): Coordinate {
+        if (a === 𝒪)
+            return nothing();
+        else
+            return this.doublepoint(a);
+    }
+
+    public get p(): Coordinate {
+        let p:Point;
+        let mp:Coordinate;
+
+        p = this.curve.p;
+        mp = (p['∞']) ?
+                nothing() :
+            just(p);
+        
+        return mp;
+    }
+    public get q(): Coordinate {
+        let q:Point;
+        let mq:Coordinate;
+
+        q = this.curve.q;
+        mq = (q['∞']) ?
+                nothing() :
+            just(q);
+        
+        return mq;
+    }
+
     constructor(curve:ECCurve) {
         this.curve = new Curve<a>(curve);
 
@@ -159,3 +311,4 @@ class ecℤp extends EllipticCurves<PrimeField>
 }
 
 export { ecℤp, p256 };
+export type { Point, Coordinate };

package/galois.ts

@@ -146,8 +146,8 @@ Util = {
         let a:bigint;
         let e:bigint;
 
-        sign = (method==methods.SquareAndMultiply) ? '^' : 'x';
-        log(`${a_}${sign}${e_} (mod ${p}) = `);
+        // sign = (method==methods.SquareAndMultiply) ? '^' : 'x';
+        // log(`${a_}${sign}${e_} (mod ${p}) = `);
 
         switch (method) {
             case methods.SquareAndMultiply:
@@ -161,10 +161,8 @@ Util = {
 
             case methods.DoubleAndAdd:
                 sq  = (y:bigint,p_:bigint):bigint           =>
-                    // Util.binmethod(y,2n,p_,DoubleAndAdd)
                     ((y+y)%p_)
                 mul = (y:bigint,z:bigint,p_:bigint):bigint  =>
-                    // Util.binmethod(y,z,p_,DoubleAndAdd)
                     ((y+z)%p_);
                 a=e_;
                 e=a_;
@@ -184,18 +182,13 @@ Util = {
             .fill(false,0,Number(bitlen))
             .map((x:boolean,idx:number):boolean =>
                 (((e>>n--)&1n)===1n) && (!!idx));
-        // if (method === methods.DoubleAndAdd)
-            bitstring.shift();
+        bitstring.shift();
         // log(bitstring.map((x:boolean):number => (x)?1:0));
         bitstring
             .forEach((x:boolean):void => {
-                // val = (x) ?
-                //     mul(a,sq(val,p),p) :
-                // sq(a,p);
                 val = (x) ?
                     mul(a,sq(val,p),p) :
                 sq(val,p);
-                // log(val);
                 
                 return void 0;
             });

package/main.ts

@@ -1,17 +1,39 @@
 /* main.ts */
 import { Polynomial } from './polynomial.js';
 import { Util,PrimeField } from './galois.js';
-import { ecℤp, p256 } from './ellipticcurves.js';
+import { ecℤp, p256, type Coordinate, type Point } from './ellipticcurves.js';
+import { empty, fold, just, nothing } from './maybe.js';
+import type { Maybe, Just, Nothing } from './maybe.js';
 
 let log:(...x:any[])=>void;
 log = console.log;
 
 let field:PrimeField;
 let curve:ecℤp;
+let mp:Coordinate;
+let p:Point;
+let q:Point;
 
 field = new PrimeField(p256().θ, p256().bitlen);
-log(field);
+// log(field);
 curve = new ecℤp(field, p256());
-log(curve);
+// log(curve);
+
+// mp = curve.add(curve.p, curve.q);
+mp = curve.q;
+q = fold(mp);
+p = fold(curve.p);
+do {
+    mp = curve.double(mp);
+    if (empty(mp)) {
+        log(mp);
+        break;
+    }
+    else {
+        p = fold(mp);
+        log(p);
+    }
+} while (p.x !== q.x);
+log(q);
 
 export { Polynomial,Util,PrimeField,ecℤp,p256 };

package/maybe.ts

@@ -0,0 +1,40 @@
+/*
+ * maybe datatype
+ *
+ * finitefields package by @dr-Jonas-Birch
+ *
+ * 2026
+ *
+ */
+
+let log:(...args:any[])=>void;
+let fail:(...args:any[])=>never;
+
+log = console.log;
+fail = (...args:any[]): never => {
+    console.error(...args);
+    throw new Error(args.toString());
+
+    return void 0 as never;
+}
+
+type Nothing = readonly [];
+type Just<a> = readonly [a];
+type Maybe<a> =
+    | Nothing
+    | Just<a>;
+
+let empty:<a>(x:Maybe<a>)=>boolean;
+let nothing:()=>Nothing;
+let just:<a>(x:a)=>Just<a>;
+let fold:<a>(x:Maybe<a>)=>a|never;
+let x:Function;
+
+nothing = (): Nothing => [] as Nothing;
+just = <a>(x:a): Just<a> => [x] as Just<a>;
+empty = <a>(x:Maybe<a>): x is Nothing => !(x&&x.length);
+fold = <a>(x:Maybe<a>): a|never =>
+    (!empty(x))?x[0] as a:fail("folding nothing") as never;
+
+export type { Maybe, Just, Nothing };
+export { nothing, just, empty, fold };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "finitefields",
   "type": "module",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Galois/Finite field crypto and raw elliptic curves",
   "main": "main.js",
   "scripts": {