@helios-lang/effect 0.1.15 → 0.2.0

package/types/Crypto/Curve.d.ts

@@ -0,0 +1,161 @@
+import { type Field } from "./Field.js";
+/**
+ * Data container for affine points
+ */
+export type Point2<T> = {
+    x: T;
+    y: T;
+};
+export type Point2I = Point2<bigint>;
+export type Point2C = Point2<[bigint, bigint]>;
+/**
+ * Data container for projected points (much faster to do curve operations on than affine)
+ */
+export type Point3<T> = {
+    x: T;
+    y: T;
+    z: T;
+};
+export type Point3I = Point3<bigint>;
+export type Point3C = Point3<[bigint, bigint]>;
+/**
+ * Data container for extended points (much faster to operate on than affine points)
+ */
+export type Point4<T> = {
+    x: T;
+    y: T;
+    z: T;
+    t: T;
+};
+/**
+ * Abstraction of an additive group
+ *   * ZERO: additive identity
+ *   * add two points to form a new point
+ *   * scale: add a point to itself
+ *   * equals: compares two points
+ *   * isValidPoint: returns true if point lies on curve
+ *
+ * For scale we'll always be using the double-and-add algorithm
+ */
+export interface Curve<T, Tc> {
+    ZERO: T;
+    add: (a: T, b: T) => T;
+    negate: (a: T) => T;
+    equals: (a: T, b: T) => boolean;
+    isValidPoint: (p: T) => boolean;
+    toAffine: (point: T) => Point2<Tc>;
+    fromAffine: (point: Point2<Tc>) => T;
+}
+export declare class CurveHelper<T, Tc> implements Curve<T, Tc> {
+    protected readonly curve: Curve<T, Tc>;
+    /**
+     * @param curve
+     */
+    constructor(curve: Curve<T, Tc>);
+    get ZERO(): T;
+    /**
+     * @param point
+     * @returns
+     */
+    isZero(point: T): boolean;
+    /**
+     * @param point
+     * @returns
+     */
+    isValidPoint(point: T): boolean;
+    /**
+     * @param a
+     * @param b
+     * @returns
+     */
+    equals(a: T, b: T): boolean;
+    /**
+     * @param a
+     * @param b
+     * @returns
+     */
+    add(a: T, b: T): T;
+    /**
+     * @param a
+     * @param b
+     * @returns
+     */
+    subtract(a: T, b: T): T;
+    /**
+     * @param a
+     * @returns
+     */
+    negate(a: T): T;
+    /**
+     * Double-and-add algorithm
+     * Seems to have acceptable performance.
+     * Not constant-time, but for the signing algorithms this scalar is always a random private number
+     * @param point
+     * @param s
+     * @returns
+     */
+    scale(point: T, s: bigint): T;
+    toAffine(point: T): Point2<Tc>;
+    fromAffine(point: Point2<Tc>): T;
+}
+export interface ShortAffineCurve<T> extends Curve<Point2<T>, T> {
+    F: Field<T>;
+    b: T;
+    double(point: Point2<T>): Point2<T>;
+}
+export interface AffineCurve1 {
+    b: bigint;
+    ZERO: Point2I;
+    add(a: Point2I, b: Point2I): Point2I;
+    negate(a: Point2I): Point2I;
+    equals(a: Point2I, b: Point2I): boolean;
+    isValidPoint(p: Point2I): boolean;
+    isZero(point: Point2I): boolean;
+    subtract(a: Point2I, b: Point2I): Point2I;
+    scale(point: Point2I, s: bigint): Point2I;
+    toAffine(point: Point2I): Point2I;
+    fromAffine(point: Point2I): Point2I;
+}
+export interface AffineCurve2 {
+    b: [bigint, bigint];
+    ZERO: Point2C;
+    add(a: Point2C, b: Point2C): Point2C;
+    negate(a: Point2C): Point2C;
+    equals(a: Point2C, b: Point2C): boolean;
+    isValidPoint(p: Point2C): boolean;
+    isZero(point: Point2C): boolean;
+    subtract(a: Point2C, b: Point2C): Point2C;
+    scale(point: Point2C, s: bigint): Point2C;
+    toAffine(point: Point2C): Point2C;
+    fromAffine(point: Point2C): Point2C;
+}
+export interface ProjectedCurve1 {
+    ZERO: Point3I;
+    add(a: Point3I, b: Point3I): Point3I;
+    negate(a: Point3I): Point3I;
+    equals(a: Point3I, b: Point3I): boolean;
+    isValidPoint(p: Point3I): boolean;
+    isZero(point: Point3I): boolean;
+    subtract(a: Point3I, b: Point3I): Point3I;
+    scale(point: Point3I, s: bigint): Point3I;
+    toAffine(point: Point3I): Point2I;
+    fromAffine(point: Point2I): Point3I;
+    clearCofactor(point: Point3I): Point3I;
+}
+export interface ProjectedCurve2 {
+    ZERO: Point3C;
+    add(a: Point3C, b: Point3C): Point3C;
+    negate(a: Point3C): Point3C;
+    equals(a: Point3C, b: Point3C): boolean;
+    isValidPoint(p: Point3C): boolean;
+    isZero(point: Point3C): boolean;
+    subtract(a: Point3C, b: Point3C): Point3C;
+    scale(point: Point3C, s: bigint): Point3C;
+    toAffine(point: Point3C): Point2C;
+    fromAffine(point: Point2C): Point3C;
+    scalex(point: Point3C): Point3C;
+    psi(point: Point3C): Point3C;
+    psi2(point: Point3C): Point3C;
+    clearCofactor(point: Point3C): Point3C;
+}
+//# sourceMappingURL=Curve.d.ts.map

package/types/Crypto/Curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Curve.d.ts","sourceRoot":"","sources":["../../src/Crypto/Curve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvC;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI;IACtB,CAAC,EAAE,CAAC,CAAA;IACJ,CAAC,EAAE,CAAC,CAAA;CACL,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;AACpC,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;AAE9C;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI;IACtB,CAAC,EAAE,CAAC,CAAA;IACJ,CAAC,EAAE,CAAC,CAAA;IACJ,CAAC,EAAE,CAAC,CAAA;CACL,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;AACpC,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;AAE9C;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI;IACtB,CAAC,EAAE,CAAC,CAAA;IACJ,CAAC,EAAE,CAAC,CAAA;IACJ,CAAC,EAAE,CAAC,CAAA;IACJ,CAAC,EAAE,CAAC,CAAA;CACL,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,EAAE,EAAE;IAC1B,IAAI,EAAE,CAAC,CAAA;IACP,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAA;IACtB,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAA;IACnB,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;IAC/B,YAAY,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;IAC/B,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,EAAE,CAAC,CAAA;IAClC,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAA;CACrC;AAED,qBAAa,WAAW,CAAC,CAAC,EAAE,EAAE,CAAE,YAAW,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;IACrD,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IAEtC;;OAEG;gBACS,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;IAI/B,IAAI,IAAI,IAAI,CAAC,CAEZ;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAIzB;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAI/B;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO;IAI3B;;;;OAIG;IACH,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC;IAIlB;;;;OAIG;IACH,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC;IAIvB;;;OAGG;IACH,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC;IAIf;;;;;;;OAOG;IACH,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC;IAqB7B,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC;IAI9B,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC;CAGjC;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC,CAAE,SAAQ,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC9D,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;IACX,CAAC,EAAE,CAAC,CAAA;IACJ,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,CAAC,EAAE,MAAM,CAAA;IACT,IAAI,EAAE,OAAO,CAAA;IACb,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACpC,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IAC3B,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACvC,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACjC,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IAC/B,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACzC,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACzC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IACjC,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnB,IAAI,EAAE,OAAO,CAAA;IACb,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACpC,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IAC3B,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACvC,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACjC,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IAC/B,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACzC,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACzC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IACjC,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;CACpC;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,CAAA;IACb,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACpC,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IAC3B,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACvC,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACjC,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IAC/B,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACzC,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACzC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IACjC,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IACnC,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;CACvC;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,CAAA;IACb,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACpC,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IAC3B,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACvC,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACjC,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IAC/B,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IACzC,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACzC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IACjC,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IACnC,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IAC/B,GAAG,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IAC5B,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;IAC7B,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAA;CACvC"}

package/types/Crypto/Ed25519.d.ts

@@ -0,0 +1,155 @@
+import { Either, Encoding } from "effect";
+import { type Curve, type Point2I, type Point4 } from "./Curve.js";
+import { BadPrivateKeyLength, BadPublicKeyLength, BadSignatureLength } from "./EdDSA.js";
+/**
+ * @param bytes
+ * @param truncate
+ * Force `bytes` to 32 bytes long, applying special padding to first and 32nd byte
+ * @returns
+ * A DecodeException if `bytes` is empty
+ */
+export declare function decodeScalar(bytes: Uint8Array, truncate?: boolean): Either.Either<bigint, Encoding.DecodeException>;
+/**
+ * @param bytes
+ * @returns
+ * A DecodeException if `bytes` is empty
+ */
+export declare function decodePrivateKey(bytes: Uint8Array): Either.Either<bigint, Encoding.DecodeException>;
+/**
+ * @param x
+ * @returns
+ */
+export declare function encodeScalar(x: bigint): Uint8Array;
+/**
+ * The formula for the twisted Edwards curve is:
+ *    -x^2 + y^2 = 1 - d*x^2*y^2
+ * Calculating x from this we get (only y is stored in the encoded point):
+ *    y^2 - 1 = x^2*(1 - d*y^2)
+ *    x = sqrt((y^2 - 1)/(1 - d*y^2))
+ * @param bytes
+ * @returns
+ * A DecodeException if `bytes` isn't exactly 32 long
+ */
+export declare const decodePoint: (bytes: Uint8Array) => Either.Either<Point2I, Encoding.DecodeException>;
+/**
+ * @param point
+ * @returns
+ */
+export declare function encodePoint(point: Point2I): Uint8Array;
+export declare const P = 57896044618658097711785492504343953926634992332820282019728792003956564819949n;
+export declare const N = 7237005577332262213973186563042994240857116359379907606001950938285454250989n;
+export declare const D: bigint;
+export declare const G: {
+    x: bigint;
+    y: bigint;
+};
+declare class AffineCurve implements Curve<Point2I, bigint> {
+    constructor();
+    get ZERO(): Point2I;
+    /**
+     * @param a
+     * @param b
+     * @returns
+     */
+    equals(a: Point2I, b: Point2I): boolean;
+    /**
+     * @param point
+     * @returns
+     */
+    negate(point: Point2I): Point2I;
+    /**
+     * @param point
+     * @returns
+     */
+    isValidPoint(point: Point2I): boolean;
+    /**
+     * @param a
+     * @param b
+     * @returns
+     */
+    add(a: Point2I, b: Point2I): Point2I;
+    /**
+     * @param point
+     * @returns
+     */
+    fromAffine(point: Point2I): Point2I;
+    /**
+     * @param point
+     * @returns
+     */
+    toAffine(point: Point2I): Point2I;
+}
+export declare const affineCurve: AffineCurve;
+declare class ExtendedCurve implements Curve<Point4<bigint>, bigint> {
+    constructor();
+    get ZERO(): Point4<bigint>;
+    /**
+     * @param point
+     * @returns
+     */
+    isValidPoint(point: Point4<bigint>): boolean;
+    /**
+     * @param a
+     * @param b
+     * @returns
+     */
+    equals(a: Point4<bigint>, b: Point4<bigint>): boolean;
+    /**
+     * @param point
+     * @returns
+     */
+    negate(point: Point4<bigint>): Point4<bigint>;
+    /**
+     * @param point1
+     * @param point2
+     * @returns
+     */
+    add(point1: Point4<bigint>, point2: Point4<bigint>): Point4<bigint>;
+    /**
+     * @param point
+     * @returns
+     */
+    toAffine(point: Point4<bigint>): Point2I;
+    /**
+     * @param point
+     * @returns
+     */
+    fromAffine(point: Point2I): Point4<bigint>;
+}
+export declare const extendedCurve: ExtendedCurve;
+/**
+ * @param privateKey
+ * Must be 64 bytes long
+ * @param hashPrivateKey
+ * Defaults to true, set to false when used in Bip32 algorithm
+ * @returns
+ * 32 byte public key, or BadPrivateKeyLength if private key isn't 64 bytes long
+ */
+export declare function derivePublicKey(privateKey: Uint8Array, hashPrivateKey?: boolean): Either.Either<Uint8Array, BadPrivateKeyLength>;
+/**
+ * Sign the message.
+ * Even though this implementation isn't constant time, it isn't vulnerable to a timing attack (see detailed notes in EdDSA implementation)
+ * @param message
+ * @param privateKeyBytes
+ * @param hashPrivateKey
+ * Defaults to true, Bip32 passes this as false
+ * @returns
+ * 64 byte signature, or BadPrivateKeyLength if private key isn't 64 bytes long
+ */
+export declare function sign(message: Uint8Array, privateKey: Uint8Array, hashPrivateKey?: boolean): Either.Either<Uint8Array, BadPrivateKeyLength>;
+/**
+ * @param signature
+ * @param message
+ * @param publicKey
+ * @returns
+ *   - `true` if the signature is correct.
+ *   - `false`:
+ *     - if the signature is incorrect
+ *     - if the signature doesn't lie on the curve,
+ *     - if the publicKey doesn't lie on the curve
+ *   - BadPublicKeyLength if publicKey isn't 32 bytes long
+ *   - BadSignatureLength if signature isn't 64 bytes long
+ */
+export declare function verify(signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): Either.Either<boolean, BadSignatureLength | BadPublicKeyLength>;
+export {};
+//# sourceMappingURL=Ed25519.d.ts.map

package/types/Crypto/Ed25519.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ed25519.d.ts","sourceRoot":"","sources":["../../src/Crypto/Ed25519.ts"],"names":[],"mappings":"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"}

package/types/Crypto/EdDSA.d.ts

@@ -0,0 +1,159 @@
+import { Either, Encoding } from "effect";
+import { type Curve, type Point2I } from "./Curve.js";
+import { Field } from "./Field.js";
+declare const BadPrivateKeyLength_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Crypto.EdDSA.BadPrivateKeyLength";
+} & Readonly<A>;
+export declare class BadPrivateKeyLength extends BadPrivateKeyLength_base<{
+    message: string;
+}> {
+    constructor(privateKey: Uint8Array);
+}
+declare const BadSignatureLength_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Crypto.EdDSA.BadSignatureLength";
+} & Readonly<A>;
+export declare class BadSignatureLength extends BadSignatureLength_base<{
+    message: string;
+}> {
+    constructor(signature: Uint8Array);
+}
+declare const BadPublicKeyLength_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Crypto.EdDSA.BadPublicKeyLength";
+} & Readonly<A>;
+export declare class BadPublicKeyLength extends BadPublicKeyLength_base<{
+    message: string;
+}> {
+    constructor(publicKey: Uint8Array);
+}
+/**
+ * Implementation of point/scalar codec is left up to Ed25519
+ */
+export type Codec = {
+    decodePoint(bytes: Uint8Array): Either.Either<Point2I, Encoding.DecodeException>;
+    encodePoint(point: Point2I): Uint8Array;
+    decodePrivateKey(bytes: Uint8Array): Either.Either<bigint, Encoding.DecodeException>;
+    decodeScalar(bytes: Uint8Array): Either.Either<bigint, Encoding.DecodeException>;
+    encodeScalar(x: bigint): Uint8Array;
+};
+/**
+ *  Edwards Digital Signing Algorithm
+ *
+ * Symbols based on the book "Elliptic Curves in Cryptography" by I.F. Blake, G. Seroussi and N.P. Smart
+ * See page 4 for an overview of the DSA algorithm.
+ * This book along with the first few sections of "Cryptography: An Introduction" by N.P. Smart are
+ *   recommended reads in order to understand better the concepts of "scalars" and "CurvePoint" and
+ *   their arithmatic over finite fields.
+ *
+ * Notation:
+ *   privateKey: 64 bytes, first 32 bytes form the scalar integer `x`, the latter bytes are used for private nonce generation
+ *   publicKey: 32 bytes
+ *   x: bigint scalar representation of privateKey
+ *   g: generator BASE point
+ *   h: CurvePoint representation of publicKey
+ *   m: (hashed) message, kept as bytes
+ *   k: a practically random number, created by applying a one-way function to the message and part of the private key
+ *   a: first part of signature
+ *   b: second part of signature
+ *   `*`: group multiplication of a CurvePoint by a scalar integer, or multiplication of 2 scalars (depending on context)
+ *   `+`: CurvePoint addition or scalar addition depending on context
+ *   `.`: byte concatenation
+ *   `[n:N]`: slice bytes
+ *   `f(a,h,m)`: a one-way function for publicy known information
+ *   `mod()`: take modulo of a scalar wrt. the order of the Curve
+ *   `hash()`: Sha512 hash function
+ *   `encodeScalar`: turn a scalar integer into bytes
+ *   `decodeScalar`: turn bytes into a scalar integer
+ *   `encodePoint`: turn a CurvePoint into bytes
+ *   `decodePoint`: turn bytes into a CurvePoint
+ *
+ * The algorithm below is approached from an additive perspective.
+ *
+ * 1. Generate 64 random private key bytes
+ *      privateKey = random(64)
+ * 2. Generate the associated scalar `x`:
+ *      x = decodeScalar(privateKey[0:32])
+ * 3. Generate public key CurvePoint:
+ *      h = g*x
+ * 4. Encode public key:
+ *      publicKey = encodePoint(h)
+ * 5. Create first part of a signature:
+ *      k = decodeScalar(hash(privateKey[32:64] . m))
+ *      a = g*k
+ *      signature[0:32] = encodePoint(a)
+ * 6. Create second part of a signature:
+ *      f(a,h,m) = decodeScalar(hash(signature[0:32] . publicKey . m))
+ *      b = mod(k + f(a,h,m)*x)
+ *      signature[32:64] = encodeScalar(b)
+ * 7. Verify a signature:
+ *      a = decodePoint(signature[0:32])
+ *      b = decodeScalar(signature[32:64])
+ *      h = decodePoint(publicKey)
+ *      f(a,h,m) = decodeScalar(hash(signature[0:32] . publicKey . m))
+ *      g*b === a + h*f(a,h,m)
+ *
+ * We can show that this works by substituting the private calculations done upon signing (the arithmatic takes care of the mod() operator):
+ *      g*(k + f(a,h,m)*x) === g*k + h*f(a,h,m)
+ *      g*k + g*x*f(a,h,m) === g*k + h*f(a,h,m)
+ *
+ * We know that `g*x == h`, QED.
+ *
+ * The arithmatic details are handled by the CurvePoint class
+ */
+export declare class EdDSA<T> {
+    readonly curve: Curve<T, bigint>;
+    readonly G: {
+        x: bigint;
+        y: bigint;
+    };
+    readonly Z: Field<bigint>;
+    readonly codec: Codec;
+    /**
+     * @param curve
+     */
+    constructor(curve: Curve<T, bigint>, G: {
+        x: bigint;
+        y: bigint;
+    }, Z: Field<bigint>, pointCodec: Codec);
+    /**
+     * Combination hash and decodeCurveInt
+     * @param bytes
+     * @returns
+     */
+    private oneWay;
+    /**
+     * @param privateKeyBytes
+     * @param hashPrivateKey
+     * Defaults to true, set to false
+     * when used in Bip32 algorithm
+     * @returns 32 byte public key.
+     */
+    derivePublicKey(privateKeyBytes: Uint8Array, hashPrivateKey?: boolean): Either.Either<Uint8Array, BadPrivateKeyLength>;
+    /**
+     * Sign the message.
+     * Even though this implementation isn't constant time, it isn't vulnerable to a timing attack (see detailed notes in implementation below)
+     * @param message
+     * @param privateKeyBytes
+     * @param hashPrivateKey
+     * Defaults to true, Bip32 passes this as false
+     * @returns
+     * 64 byte signature.
+     */
+    sign(message: Uint8Array, privateKeyBytes: Uint8Array, hashPrivateKey?: boolean): Either.Either<Uint8Array, BadPrivateKeyLength>;
+    /**
+     * Returns `true` if the signature is correct.
+     * Returns `false`:
+     *   * if the signature is incorrect
+     *   * if the signature doesn't lie on the curve,
+     *   * if the publicKey doesn't lie on the curve
+     * Throw an error:
+     *   * signature isn't 64 bytes long
+     *   * publickey isn't 32 bytes long (asserted inside `decodePoint()`)
+     * @param signature
+     * @param message
+     * @param publicKey
+     * @returns
+     */
+    verify(signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): Either.Either<boolean, BadSignatureLength | BadPublicKeyLength>;
+}
+export {};
+//# sourceMappingURL=EdDSA.d.ts.map

package/types/Crypto/EdDSA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EdDSA.d.ts","sourceRoot":"","sources":["../../src/Crypto/EdDSA.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,MAAM,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAC/C,OAAO,EAAE,KAAK,KAAK,EAAe,KAAK,OAAO,EAAE,MAAM,YAAY,CAAA;AAElE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;;;;AAElC,qBAAa,mBAAoB,SAAQ,yBAEvC;IACA,OAAO,EAAE,MAAM,CAAA;CAChB,CAAC;gBACY,UAAU,EAAE,UAAU;CAKnC;;;;AAED,qBAAa,kBAAmB,SAAQ,wBAEtC;IACA,OAAO,EAAE,MAAM,CAAA;CAChB,CAAC;gBACY,SAAS,EAAE,UAAU;CAGlC;;;;AAED,qBAAa,kBAAmB,SAAQ,wBAEtC;IACA,OAAO,EAAE,MAAM,CAAA;CAChB,CAAC;gBACY,SAAS,EAAE,UAAU;CAGlC;AAED;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB,WAAW,CACT,KAAK,EAAE,UAAU,GAChB,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;IACnD,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;IACvC,gBAAgB,CACd,KAAK,EAAE,UAAU,GAChB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;IAClD,YAAY,CACV,KAAK,EAAE,UAAU,GAChB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;IAClD,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;CACpC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,KAAK,CAAC,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;IAChC,QAAQ,CAAC,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACpC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IAErB;;OAEG;gBAED,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,EACvB,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EAC3B,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,EAChB,UAAU,EAAE,KAAK;IAQnB;;;;OAIG;IACH,OAAO,CAAC,MAAM;IAcd;;;;;;OAMG;IACH,eAAe,CACb,eAAe,EAAE,UAAU,EAC3B,cAAc,GAAE,OAAc,GAC7B,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,mBAAmB,CAAC;IA2BjD;;;;;;;;;OASG;IACH,IAAI,CACF,OAAO,EAAE,UAAU,EACnB,eAAe,EAAE,UAAU,EAC3B,cAAc,GAAE,OAAc,GAC7B,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,mBAAmB,CAAC;IAsDjD;;;;;;;;;;;;;OAaG;IACH,MAAM,CACJ,SAAS,EAAE,UAAU,EACrB,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,UAAU,GACpB,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,kBAAkB,GAAG,kBAAkB,CAAC;CAsCnE"}