finitefields 0.0.7 → 0.0.9

package/ellipticcurves.ts

@@ -7,12 +7,16 @@
  *
  */
 
-import type { PrimeField } from "./galois.js";
+import type { GF,PrimeField } from './galois.js';
+import { 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;
+let p256:()=>ECCurve;
 
+𝒪 = nothing();
 log = console.log;
 fail = (...args:any[]): never => {
     console.error(...args);
@@ -21,7 +25,7 @@ fail = (...args:any[]): never => {
     return void 0 as never;
 }
 
-p256 = {
+p256 = ():ECCurve => ({
    '#E': 0xffffffff00000000_ffffffffffffffff_bce6faada7179e84_f3b9cac2fc632551n,
     'θ': 0xffffffff00000001_0000000000000000_00000000ffffffff_ffffffffffffffffn,
     'b': 0x5ac635d8aa3a93e7_b3ebbd55769886bc_651d06b0cc53b0f6_3bce3c3e27d2604bn,
@@ -34,11 +38,19 @@ p256 = {
       [
         0xc97445f45cdef9f0_d3e05e1e585fc297_235b82b5be8ff3ef_ca67c59852018192n,
         0xb28ef557ba31dfcb_dd21ac46e2a91e3c_304f44cb87058ada_2cb815151e610046n
-      ]
-}
+      ],
+      bitlen: 256n,
+      formula: (a:bigint,b:bigint,f:PrimeField)=>(x:bigint,y:bigint) =>
+            f.add(f.add(                // y^2 =
+                f.exp(x, 3n),           //   x^3
+                f.mul(a,x)),            //   + ax
+                b)                      //   + b
+});
 
 type Tuple<a> = readonly [a,a];
+type Coordinate = Maybe<Point>;
 type infinity = false | true;
+type ECformula = (a:bigint,b:bigint,f:GF)=>Function;
 
 interface Tuples {
     'p':    Tuple<bigint>;
@@ -46,8 +58,10 @@ interface Tuples {
 }
 
 interface IECCurve {
-    'θ':    bigint;
-    'b':    bigint;
+    'θ':     bigint;
+    'b':     bigint;
+    bitlen:  bigint;
+    formula: ECformula;
 }
 
 type hashE = {'#E':bigint};
@@ -56,6 +70,8 @@ interface ECCurve extends IECCurve,Tuples,hashE {};
 interface Iellipticcurves<a> {
     backend: a;
     constructor:Function;
+    add:(a:Coordinate,b:Coordinate)=>Coordinate;
+    double:(a:Coordinate)=>Coordinate;
 }
 
 interface Icurve extends IECCurve {
@@ -79,7 +95,7 @@ class Point implements Ipoint {
     constructor(point:Tuple<bigint>) {
         [ this['x'], this['y'], this['∞'] ] = [0n,0n,false];
 
-        switch (point.every((xy:bigint):xy is bigint=>!xy)) {
+        switch (point.every((xy:bigint):xy is bigint=>!!xy)) {
             case true:
                 [ this['x'], this['y'] ] = point;
                 break;
@@ -100,9 +116,10 @@ class Curve<a> implements Icurve {
     public b: bigint;
     public p: Point;
     public q: Point;
-    private object: EllipticCurves<a>;
+    public bitlen: bigint;
+    public formula:ECformula;
     
-    constructor(object:EllipticCurves<a>,curve:ECCurve) {
+    constructor(curve:ECCurve) {
         let m:string;
 
         m = 'argument error (incomplete curve params)' as const;
@@ -112,9 +129,12 @@ class Curve<a> implements Icurve {
             || fail(m);
         this.b = curve.b
             || fail(m);
+        this.bitlen = curve.bitlen
+            || fail(m);
+        this.formula = curve.formula
+            || fail(m);
         this.p = new Point(curve.p);
         this.q = new Point(curve.q);
-        this.object = object;
 
         return this;
     }
@@ -124,14 +144,40 @@ abstract class EllipticCurves<a> implements Iellipticcurves<a> {
     public abstract backend: a;
     private curve: Curve<a>;
 
+    protected addpoints(a:Coordinate,b:Coordinate): Coordinate {
+        return a;
+    }
+
+    protected doublepoint(a:Coordinate): Coordinate {
+        return a;
+    }
+
+    public add(a:Coordinate,b:Coordinate): Coordinate {
+        if ((a === 𝒪) && (b === 𝒪))
+            return <Maybe<Point>>nothing();
+        else if (a === 𝒪)
+            return <Maybe<Point>>just(b as unknown as Point);
+        else if (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);
+    }
+
     constructor(curve:ECCurve) {
-        this.curve = new Curve<a>(this,curve);
+        this.curve = new Curve<a>(curve);
 
         return this;
     }
 }
 
-class ECoverℤp extends EllipticCurves<PrimeField>
+class ecℤp extends EllipticCurves<PrimeField>
     implements Iellipticcurves<PrimeField>
 {
     public backend:PrimeField;
@@ -144,4 +190,4 @@ class ECoverℤp extends EllipticCurves<PrimeField>
     }
 }
 
-export { ECoverℤp };
+export { ecℤp, p256 };

package/galois.ts

@@ -19,15 +19,30 @@ fail = (...args:any[]): never => {
     return void 0 as never;
 }
 
+enum fieldops {
+    $add,
+    $sub,
+    $mul,
+    $inv,
+    $exp
+}
+
+enum methods {
+    SquareAndMultiply,
+    DoubleAndAdd
+}
+
 const arithmeticsℤp = (p:bigint,op:fieldops) =>
     (op==fieldops.$add) ?
             (a:bigint,b:bigint=0n) => (a+b)%p :
     (op==fieldops.$sub) ?
             (a:bigint,b:bigint=0n) => ((a-b)<1)?(a-b+p):(a-b)%p :
     (op==fieldops.$mul) ?
-            (a:bigint,b:bigint=0n) => (a*b)%p :
+            (a:bigint,b:bigint=0n) => (!a||!b)?0n:Util.dblad(a,b,p) :
     (op==fieldops.$inv) ?
             (a:bigint) => (!a)?fail('0 has no inverse'):Util.sqmul(a,(p-2n),p) :
+    (op==fieldops.$exp) ?
+            (a:bigint,b:bigint=0n) => (!a)?0n:(!b)?1n:Util.sqmul(a,b,p) :
         fail('unknown field operation');
 
 Util = {
@@ -44,6 +59,28 @@ Util = {
         let n:number;
         let r:bigint;
         let ret:boolean;
+        // let pow:(x:bigint,e:bigint,p_:bigint)=>bigint;
+
+        // pow = (x:bigint,e:bigint,p_:bigint): bigint => {
+        //     let n_:bigint;
+        //     let v:bigint;
+
+        //     if (e == 1n)
+        //         return (x%p_);
+        //     else if (!e)
+        //         return (1n%p_);
+        //     else if (e<0n)
+        //         return fail("trying to raise to negative power");
+
+        //     n_ = e;
+        //     v = x;
+        //     while (--n_)
+        //         v = (v*v)%p_;
+
+        //     return v;
+        // }
+
+        return true;
 
         if (p<2n)
             return true;
@@ -51,7 +88,8 @@ Util = {
         for (n=0, ret=true; n<s; n++) {
             r = this.rnd(bitlen,(p-1n));
             r += 1n;
-            if (((r**(p-1n))%p) != 1n) {
+            // if (((r**(p-1n))%p) != 1n) {
+            if (this.sqmul(r,(p-1n),p) !== 1n) {
                 ret = false;
                 break;
             }
@@ -92,18 +130,48 @@ Util = {
         return fail('eea() not implemented') as never;
     },
 
-    sqmul(a:bigint,e:bigint,p:bigint): bigint {
+    sqmul: (a:bigint,e:bigint,p:bigint): bigint =>
+        Util.binmethod(a,e,p,methods.SquareAndMultiply),
+    dblad: (a:bigint,e:bigint,p:bigint): bigint =>
+        Util.binmethod(a,e,p,methods.DoubleAndAdd),
+
+    binmethod(a_:bigint,e_:bigint,p:bigint,method:methods): bigint {
         let bitstring:boolean[];
         let bitlen:bigint;
         let n:bigint;
         let val:bigint;
         let mul:(y:bigint,z:bigint,p_:bigint)=>bigint;
         let sq:(y:bigint,p_:bigint)=>bigint;
+        let sign:string;
+        let a:bigint;
+        let e:bigint;
+
+        // sign = (method==methods.SquareAndMultiply) ? '^' : 'x';
+        // log(`${a_}${sign}${e_} (mod ${p}) = `);
+
+        switch (method) {
+            case methods.SquareAndMultiply:
+                sq  = (y:bigint,p_:bigint):bigint           =>
+                    Util.binmethod(y,y,p_,methods.DoubleAndAdd);
+                mul = (y:bigint,z:bigint,p_:bigint):bigint  =>
+                    Util.binmethod(y,z,p_,methods.DoubleAndAdd);
+                a=a_;
+                e=e_;
+                break;
 
-        log(`${a}^${e} (mod ${p}) = `);
+            case methods.DoubleAndAdd:
+                sq  = (y:bigint,p_:bigint):bigint           =>
+                    ((y+y)%p_)
+                mul = (y:bigint,z:bigint,p_:bigint):bigint  =>
+                    ((y+z)%p_);
+                a=e_;
+                e=a_;
+                break;
 
-        mul = (y:bigint,z:bigint,p_:bigint):bigint  => ((y*z)%p_);
-        sq  = (y:bigint,p_:bigint):bigint           => ((y*y)%p_);
+            default:
+                return fail('argument error');
+                break;
+        }
 
         val = a;
         bitlen = this.countbits(e);
@@ -114,12 +182,13 @@ Util = {
             .fill(false,0,Number(bitlen))
             .map((x:boolean,idx:number):boolean =>
                 (((e>>n--)&1n)===1n) && (!!idx));
+        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);
+                sq(val,p);
                 
                 return void 0;
             });
@@ -128,19 +197,14 @@ Util = {
     }
 }
 
-enum fieldops {
-    $add,
-    $sub,
-    $mul,
-    $inv
-}
-
 interface Igalois {
     add: (a:bigint,b:bigint)=>bigint;
     sub: (a:bigint,b:bigint)=>bigint;
     mul: (a:bigint,b:bigint)=>bigint; 
     inv: (a:bigint)=>bigint;
+    exp: (a:bigint,b:bigint)=>bigint; 
     verify:()=>void;
+    get p(): bigint;
     constructor:Function;
 }
 
@@ -149,7 +213,9 @@ interface Iutil {
     countbits: (x:bigint)=>bigint;
     rnd: (bitlen:bigint,max:bigint)=>bigint;
     eea: (x:bigint,p:bigint)=>bigint;
+    binmethod: (a:bigint,e:bigint,p:bigint,method:methods)=>bigint;
     sqmul: (a:bigint,e:bigint,p:bigint)=>bigint;
+    dblad: (a:bigint,e:bigint,p:bigint)=>bigint;
 }
 
 abstract class GF implements Igalois {
@@ -159,9 +225,14 @@ abstract class GF implements Igalois {
     public abstract sub: typeof this.add;
     public abstract mul: typeof this.add;
     public abstract inv: (a:bigint)=>bigint;
+    public abstract exp: typeof this.add;
 
     public abstract verify(): void;
 
+    public get p(): bigint {
+        return this.modulus;
+    }
+
     constructor(field:bigint,bitlen:bigint) {
         this.modulus = field;
         this.bitlen = bitlen;
@@ -177,6 +248,7 @@ class PrimeField extends GF implements Igalois {
     public sub: typeof this.add;
     public mul: typeof this.add;
     public inv: (a:bigint)=>bigint;
+    public exp: typeof this.add;
 
     public verify(): void {
         if (!Util.isprime(this.modulus))
@@ -193,6 +265,7 @@ class PrimeField extends GF implements Igalois {
         this.sub = arithmeticsℤp(this.modulus, fieldops.$sub);
         this.mul = arithmeticsℤp(this.modulus, fieldops.$mul);
         this.inv = arithmeticsℤp(this.modulus, fieldops.$inv);
+        this.exp = arithmeticsℤp(this.modulus, fieldops.$exp);
 
         return this;
     }
@@ -200,3 +273,4 @@ class PrimeField extends GF implements Igalois {
 }
 
 export { Util, PrimeField };
+export type { GF }

package/main.ts

@@ -1,31 +1,23 @@
 /* main.ts */
 import { Polynomial } from './polynomial.js';
 import { Util,PrimeField } from './galois.js';
-import { ECoverℤp } from './ellipticcurves.js';
+import { ecℤp, p256 } 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 p1:Polynomial;
-let p2:Polynomial;
-let p3:Polynomial;
-let x0:bigint;
-let x1:bigint;
-let x2:bigint;
-let x3:bigint;
+let foo:Maybe<string>;
+foo = just(1..toString());
+log(empty(foo));
 
-x0 = BigInt(1);
-x1 = BigInt(0);
-x2 = BigInt(1);
-x3 = BigInt(0);
+// let field:PrimeField;
+// let curve:ecℤp;
 
-p1 = new Polynomial([x0, x1, x2, x3], 2n);
-p2 = new Polynomial({ tobject:0n, x3:1n, x2:0n, x:1n, 1:1n }, 2n);
-// log(p1, " + ", p2, " =");
-// p3 = Polynomial.add(p1,p2);
-p3 = new Polynomial(1n<<254n, 2n);
+// field = new PrimeField(p256().θ, p256().bitlen);
+// log(field);
+// curve = new ecℤp(field, p256());
+// log(curve);
 
-log(p3, p3.eval());
-// log(p3.eval());
-
-export { Polynomial,Util,PrimeField,ECoverℤp };
+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.7",
+  "version": "0.0.9",
   "description": "Galois/Finite field crypto and raw elliptic curves",
   "main": "main.js",
   "scripts": {

package/main.js

@@ -1,26 +0,0 @@
-/* main.ts */
-import { Polynomial } from './polynomial.js';
-import { Util, PrimeField } from './galois.js';
-import { ECoverℤp } from './ellipticcurves.js';
-let log;
-log = console.log;
-let p1;
-let p2;
-let p3;
-let x0;
-let x1;
-let x2;
-let x3;
-x0 = BigInt(1);
-x1 = BigInt(0);
-x2 = BigInt(1);
-x3 = BigInt(0);
-p1 = new Polynomial([x0, x1, x2, x3], 2n);
-p2 = new Polynomial({ tobject: 0n, x3: 1n, x2: 0n, x: 1n, 1: 1n }, 2n);
-// log(p1, " + ", p2, " =");
-// p3 = Polynomial.add(p1,p2);
-p3 = new Polynomial(1n << 254n, 2n);
-log(p3, p3.eval());
-// log(p3.eval());
-export { Polynomial, Util, PrimeField, ECoverℤp };
-//# sourceMappingURL=main.js.map