@tideorg/js 0.13.19

package/dist/Cryptide/Components/BaseComponent.js

@@ -0,0 +1,176 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+import { base64ToBytes, Bytes2Hex, bytesToBase64, ConcatUint8Arrays, getBytesFromInt16, Hex2Bytes } from "../Serialization";
+import { Registery } from "./ComponentRegistry";
+import { SchemeType } from "./Schemes/SchemeRegistry";
+export class BaseComponent {
+    constructor() { }
+    Add(component) {
+        if (component.Scheme == this.Scheme) {
+            let res = this.AddComponent(component);
+            if (res instanceof BaseComponent && res.Scheme == this.Scheme)
+                return res;
+        }
+        throw Error("Mismatch between components");
+    }
+    Multiply(component) {
+        if (component.Scheme == this.Scheme) {
+            let res = this.MultiplyComponent(component);
+            if (res instanceof BaseComponent && res.Scheme == this.Scheme)
+                return res;
+        }
+        throw Error("Mismatch between components");
+    }
+    Minus(component) {
+        if (component.Scheme == this.Scheme) {
+            let res = this.MinusComponent(component);
+            if (res instanceof BaseComponent && res.Scheme == this.Scheme)
+                return res;
+        }
+        throw Error("Mismatch between components");
+    }
+    Equals(component) {
+        if (component.Scheme == this.Scheme) {
+            let res = this.EqualsComponent(component);
+            if (typeof res == "boolean")
+                return res;
+        }
+        throw Error("Mismatch between components");
+    }
+    Mod() {
+        let res = this.ModComponent();
+        if (res instanceof BaseComponent && res.Scheme == this.Scheme)
+            return res;
+        throw Error("Mismatch between components");
+    }
+    ModInv() {
+        let res = this.ModInvComponent();
+        if (res instanceof BaseComponent && res.Scheme == this.Scheme)
+            return res;
+        throw Error("Mismatch between components");
+    }
+    AddComponent(component) { throw Error("Add not implemented"); }
+    MultiplyComponent(component) { throw Error("Multiply not implemented"); }
+    MinusComponent(component) { throw Error("Minus not implemented"); }
+    EqualsComponent(component) { throw Error("Equals not implemented"); }
+    ModComponent() { throw Error("Mod not implemented"); }
+    ModInvComponent() { throw Error("Mod inv not implemented"); }
+    SerializeComponent() { throw Error("Serialize not implemented"); }
+    /**@returns {BaseScheme} */
+    get Scheme() { throw Error("Not implemented"); }
+    /**@returns {string} */
+    get ComponentType() { throw Error("Not implemented"); }
+    Serialize() {
+        let raw = this.SerializeComponent();
+        let schemeInt = SchemeType.indexOf(this.Scheme);
+        let componentTypeInt = ComponentKeyType.indexOf(this.ComponentType);
+        if (schemeInt == -1 || componentTypeInt == -1)
+            throw Error("Could not find scheme or component type in registries");
+        let schemeBytes = getBytesFromInt16(schemeInt);
+        let header = ConcatUint8Arrays([new Uint8Array([componentTypeInt << 4]), schemeBytes]); // shift to the left (for when we have version, but all versions are 0 for now)
+        return new SerializedComponent(ConcatUint8Arrays([header, raw]), this.ComponentType);
+    }
+    static DeserializeComponent(serialized) {
+        let b = [];
+        if (!(serialized instanceof Uint8Array)) {
+            try {
+                try {
+                    b = Hex2Bytes(serialized);
+                }
+                catch {
+                    b = base64ToBytes(serialized);
+                }
+            }
+            catch {
+                throw Error("Unable to deserialize component");
+            }
+        }
+        else
+            b = serialized;
+        let scheme = SchemeType[toInt16(b.slice(1, 3), 0)];
+        let k = (b[0] >> 4) & 0x0F;
+        let keyType = ComponentKeyType[k];
+        let component = Registery[scheme.Name][keyType];
+        return component.Create(b.slice(3));
+    }
+}
+BaseComponent.Name = () => { throw Error("Name not implemented"); };
+BaseComponent.Version = () => { throw Error("Version not implemented"); };
+export class BaseSeedComponent extends BaseComponent {
+    get ComponentType() { return Seed; }
+    static New() { throw Error("Not implemented"); }
+    GetPublic() { throw Error("Not implemented"); }
+    GetPrivate() { throw Error("Not implemented"); }
+    get rawBytes() { throw Error("Not implemented"); }
+}
+export class BasePrivateComponent extends BaseComponent {
+    get ComponentType() { return Private; }
+    static New() { throw Error("Not implemented"); }
+    GetPublic() { throw Error("Not implemented"); }
+    get priv() { throw Error("Not implemented"); }
+    get rawBytes() { throw Error("Not implemented"); }
+}
+export class BasePublicComponent extends BaseComponent {
+    get ComponentType() { return Public; }
+    get public() { throw Error("Not implemented"); }
+}
+export class SerializedComponent {
+    constructor(bytes, compentType) {
+        this.Bytes = bytes;
+        this.ComponentType = compentType;
+    }
+    ToBytes() {
+        return this.Bytes;
+    }
+    ToString() {
+        switch (this.ComponentType) {
+            case Seed:
+                return bytesToBase64(this.Bytes);
+            case Private:
+                return bytesToBase64(this.Bytes);
+            case Public:
+                return Bytes2Hex(this.Bytes);
+            case Symmetric:
+                return bytesToBase64(this.Bytes);
+            case QuantumPrivate:
+                throw Error("Not implemented yet");
+            case QuantumPublic:
+                throw Error("Not implemented yet");
+            default:
+                throw Error("Unknown component type");
+        }
+    }
+}
+function toInt16(bytes, offset = 0) {
+    const buffer = bytes.buffer;
+    const view = new DataView(buffer);
+    return view.getInt16(offset, true); // 'true' for little-endian, set to 'false' for big-endian
+}
+export const Seed = "Seed";
+export const Private = "Private";
+export const Public = "Public";
+export const Symmetric = "Symmetric";
+export const QuantumPrivate = "QuantumPrivate";
+export const QuantumPublic = "QuantumPublic";
+const ComponentKeyType = [
+    Seed, // 0
+    Private, // 1
+    Public, // 2
+    Symmetric, // 3
+    QuantumPrivate, // 4
+    QuantumPublic // 5
+];

package/dist/Cryptide/Components/ComponentRegistry.d.ts

@@ -0,0 +1,18 @@
+import { Ed25519PrivateComponent, Ed25519PublicComponent, Ed25519SeedComponent } from "./Schemes/Ed25519/Ed25519Components";
+export declare class Ed25519PublicComponentFactory {
+    static Create(b: any): Ed25519PublicComponent;
+}
+export declare class Ed25519PrivateComponentFactory {
+    static Create(b: any): Ed25519PrivateComponent;
+}
+export declare class Ed25519SeedComponentFactory {
+    static Create(b: any): Ed25519SeedComponent;
+}
+export declare const Registery: {
+    Ed25519Scheme: {
+        Public: typeof Ed25519PublicComponentFactory;
+        Private: typeof Ed25519PrivateComponentFactory;
+        Seed: typeof Ed25519SeedComponentFactory;
+    };
+};
+//# sourceMappingURL=ComponentRegistry.d.ts.map

package/dist/Cryptide/Components/ComponentRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentRegistry.d.ts","sourceRoot":"","sources":["../../../Cryptide/Components/ComponentRegistry.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAG,uBAAuB,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAE7H,qBAAa,6BAA6B;IACtC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAA;CAGlB;AAED,qBAAa,8BAA8B;IACvC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAA;CAGlB;AAED,qBAAa,2BAA2B;IACpC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAA;CAGlB;AAED,eAAO,MAAM,SAAS;;;;;;CAMrB,CAAC"}

package/dist/Cryptide/Components/ComponentRegistry.js

@@ -0,0 +1,39 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+import { Ed25519PrivateComponent, Ed25519PublicComponent, Ed25519SeedComponent } from "./Schemes/Ed25519/Ed25519Components";
+export class Ed25519PublicComponentFactory {
+    static Create(b) {
+        return new Ed25519PublicComponent(b);
+    }
+}
+export class Ed25519PrivateComponentFactory {
+    static Create(b) {
+        return new Ed25519PrivateComponent(b);
+    }
+}
+export class Ed25519SeedComponentFactory {
+    static Create(b) {
+        return new Ed25519SeedComponent(b);
+    }
+}
+export const Registery = {
+    Ed25519Scheme: {
+        Public: Ed25519PublicComponentFactory,
+        Private: Ed25519PrivateComponentFactory,
+        Seed: Ed25519SeedComponentFactory
+    }
+};

package/dist/Cryptide/Components/Schemes/AES/AESScheme.d.ts

@@ -0,0 +1,5 @@
+import BaseScheme from "../BaseScheme";
+export default class AESScheme extends BaseScheme {
+    static get Name(): string;
+}
+//# sourceMappingURL=AESScheme.d.ts.map

package/dist/Cryptide/Components/Schemes/AES/AESScheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AESScheme.d.ts","sourceRoot":"","sources":["../../../../../Cryptide/Components/Schemes/AES/AESScheme.ts"],"names":[],"mappings":"AAiBA,OAAO,UAAU,MAAM,eAAe,CAAC;AAEvC,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,UAAU;IAC7C,MAAM,KAAK,IAAI,WAA2B;CAC7C"}

package/dist/Cryptide/Components/Schemes/AES/AESScheme.js

@@ -0,0 +1,20 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+import BaseScheme from "../BaseScheme";
+export default class AESScheme extends BaseScheme {
+    static get Name() { return "AESScheme"; }
+}

package/dist/Cryptide/Components/Schemes/AES/index.d.ts

@@ -0,0 +1,2 @@
+export { default as AESScheme } from './AESScheme';
+//# sourceMappingURL=index.d.ts.map

package/dist/Cryptide/Components/Schemes/AES/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../Cryptide/Components/Schemes/AES/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/dist/Cryptide/Components/Schemes/AES/index.js

@@ -0,0 +1,17 @@
+//
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+//
+// This program is free software and is subject to the terms of
+// the Tide Community Open Code License as published by the
+// Tide Foundation Limited. You may modify it and redistribute
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind,
+// including without any implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+export { default as AESScheme } from './AESScheme';

package/dist/Cryptide/Components/Schemes/BaseScheme.d.ts

@@ -0,0 +1,7 @@
+export default class BaseScheme {
+    static get Name(): string;
+    static GetVerifyingFunction: () => any;
+    static GetSigningFunction: () => any;
+    static GetEncryptingFunction: () => any;
+}
+//# sourceMappingURL=BaseScheme.d.ts.map

package/dist/Cryptide/Components/Schemes/BaseScheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseScheme.d.ts","sourceRoot":"","sources":["../../../../Cryptide/Components/Schemes/BaseScheme.ts"],"names":[],"mappings":"AAiBA,MAAM,CAAC,OAAO,OAAO,UAAU;IAC3B,MAAM,KAAK,IAAI,IAAI,MAAM,CAAyC;IAClE,MAAM,CAAC,oBAAoB,QAAO,GAAG,CAA0D;IAC/F,MAAM,CAAC,kBAAkB,QAAO,GAAG,CAAwD;IAC3F,MAAM,CAAC,qBAAqB,QAAO,GAAG,CAA2D;CACpG"}

package/dist/Cryptide/Components/Schemes/BaseScheme.js

@@ -0,0 +1,23 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+class BaseScheme {
+    static get Name() { throw Error("Name not implemented"); }
+}
+BaseScheme.GetVerifyingFunction = () => { throw Error("Verifying function not implemented"); };
+BaseScheme.GetSigningFunction = () => { throw Error("Signing function not implemented"); };
+BaseScheme.GetEncryptingFunction = () => { throw Error("Encrypting function not implemented"); };
+export default BaseScheme;

package/dist/Cryptide/Components/Schemes/Ed25519/Ed25519Components.d.ts

@@ -0,0 +1,52 @@
+import { BaseSeedComponent, BasePrivateComponent, BasePublicComponent } from "../../BaseComponent";
+import Ed25519Scheme from "./Ed25519Scheme";
+export declare class Ed25519PublicComponent extends BasePublicComponent {
+    static Name: string;
+    static Version: string;
+    get Scheme(): typeof Ed25519Scheme;
+    get ComponentType(): string;
+    /**@type {Uint8Array} */
+    pb: any;
+    /**@type {Point} */
+    p: any;
+    constructor(rawData: any);
+    get public(): any;
+    get rawBytes(): any;
+    AddComponent(component: any): Ed25519PublicComponent;
+    MultiplyComponent(component: any): Ed25519PublicComponent;
+    MinusComponent(component: any): Ed25519PublicComponent;
+    EqualsComponent(component: any): any;
+    SerializeComponent(): any;
+}
+export declare class Ed25519PrivateComponent extends BasePrivateComponent {
+    static Name: string;
+    static Version: string;
+    get Scheme(): typeof Ed25519Scheme;
+    get ComponentType(): string;
+    /**@type {bigint} */
+    p: any;
+    /**@type {Uint8Array} */
+    rB: any;
+    get priv(): any;
+    get rawBytes(): any;
+    constructor(rawData: any);
+    SerializeComponent(): any;
+    GetPublic(): Ed25519PublicComponent;
+    static New(): Ed25519PrivateComponent;
+}
+export declare class Ed25519SeedComponent extends BaseSeedComponent {
+    static Name: string;
+    static Version: string;
+    get Scheme(): typeof Ed25519Scheme;
+    get ComponentType(): string;
+    /**@type {Uint8Array} */
+    rB: any;
+    get rawBytes(): any;
+    constructor(rawData: any);
+    SerializeComponent(): any;
+    static GenerateSeed(): Uint8Array<any>;
+    GetPrivate(): Ed25519PrivateComponent;
+    GetPublic(): Ed25519PublicComponent;
+    static New(): Ed25519SeedComponent;
+}
+//# sourceMappingURL=Ed25519Components.d.ts.map

package/dist/Cryptide/Components/Schemes/Ed25519/Ed25519Components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ed25519Components.d.ts","sourceRoot":"","sources":["../../../../../Cryptide/Components/Schemes/Ed25519/Ed25519Components.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAyB,iBAAiB,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1H,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAE5C,qBAAa,sBAAuB,SAAQ,mBAAmB;IAC3D,MAAM,CAAC,IAAI,SAA4B;IACvC,MAAM,CAAC,OAAO,SAAO;IACrB,IAAI,MAAM,yBAA4B;IACtC,IAAI,aAAa,WAAoB;IAErC,wBAAwB;IACxB,EAAE,MAAa;IACf,mBAAmB;IACnB,CAAC,MAAa;gBACF,OAAO,KAAA;IAQnB,IAAI,MAAM,QAIT;IAED,IAAI,QAAQ,QAIX;IAED,YAAY,CAAC,SAAS,KAAA;IAMtB,iBAAiB,CAAC,SAAS,KAAA;IAM3B,cAAc,CAAC,SAAS,KAAA;IAMxB,eAAe,CAAC,SAAS,KAAA;IAMzB,kBAAkB;CAGrB;AAED,qBAAa,uBAAwB,SAAQ,oBAAoB;IAC7D,MAAM,CAAC,IAAI,SAA6B;IACxC,MAAM,CAAC,OAAO,SAAO;IACrB,IAAI,MAAM,yBAA4B;IACtC,IAAI,aAAa,WAAqB;IAEtC,oBAAoB;IACpB,CAAC,MAAa;IACd,wBAAwB;IACxB,EAAE,MAAa;IAEf,IAAI,IAAI,QAIP;IAED,IAAI,QAAQ,QAIX;gBAEW,OAAO,KAAA;IAQnB,kBAAkB;IAGlB,SAAS;IAGT,MAAM,CAAC,GAAG;CAGb;AAED,qBAAa,oBAAqB,SAAQ,iBAAiB;IACvD,MAAM,CAAC,IAAI,SAA0B;IACrC,MAAM,CAAC,OAAO,SAAO;IACrB,IAAI,MAAM,yBAA4B;IACtC,IAAI,aAAa,WAAkB;IAEnC,wBAAwB;IACxB,EAAE,MAAa;IAEf,IAAI,QAAQ,QAEX;gBAEW,OAAO,KAAA;IAOnB,kBAAkB;IAIlB,MAAM,CAAC,YAAY;IAQnB,UAAU;IAIV,SAAS;IAGT,MAAM,CAAC,GAAG;CAGb"}

package/dist/Cryptide/Components/Schemes/Ed25519/Ed25519Components.js

@@ -0,0 +1,171 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+import { etc, Point } from "../../../Ed25519";
+import { mod, } from "../../../Math";
+import { BigIntFromByteArray, BigIntToByteArray } from "../../../Serialization";
+import { Public, Private, Seed, BaseSeedComponent, BasePrivateComponent, BasePublicComponent } from "../../BaseComponent";
+import Ed25519Scheme from "./Ed25519Scheme";
+export class Ed25519PublicComponent extends BasePublicComponent {
+    get Scheme() { return Ed25519Scheme; }
+    get ComponentType() { return Public; }
+    ;
+    constructor(rawData) {
+        super();
+        /**@type {Uint8Array} */
+        this.pb = undefined;
+        /**@type {Point} */
+        this.p = undefined;
+        if (rawData instanceof Point) {
+            this.p = rawData;
+        }
+        else if (rawData instanceof Uint8Array) {
+            this.pb = rawData;
+        }
+        else {
+            throw Error("unexpected type;");
+        }
+    }
+    get public() {
+        if (!this.p && this.pb)
+            this.p = Point.fromBytes(this.pb);
+        else if (!this.p && !this.pb)
+            throw Error("empty object");
+        return this.p;
+    }
+    get rawBytes() {
+        if (!this.pb && this.p)
+            this.pb = this.p.toRawBytes();
+        else if (!this.pb && !this.p)
+            throw Error("empty object");
+        return this.pb;
+    }
+    AddComponent(component) {
+        if (component instanceof Ed25519PublicComponent) {
+            return new Ed25519PublicComponent(this.public.add(component.public));
+        }
+        throw Error("Mismatch with components");
+    }
+    MultiplyComponent(component) {
+        if (component instanceof Ed25519PrivateComponent) {
+            return new Ed25519PublicComponent(this.public.mul(component.priv));
+        }
+        throw Error("Mismatch with components");
+    }
+    MinusComponent(component) {
+        if (component instanceof Ed25519PublicComponent) {
+            return new Ed25519PublicComponent(this.public.add(component.public.negate()));
+        }
+        throw Error("Mismatch with components");
+    }
+    EqualsComponent(component) {
+        if (component instanceof Ed25519PublicComponent) {
+            return this.public.equals(component.public);
+        }
+        throw Error("Mismatch with components");
+    }
+    SerializeComponent() {
+        return this.rawBytes.slice();
+    }
+}
+Ed25519PublicComponent.Name = "Ed25519PublicComponent";
+Ed25519PublicComponent.Version = "1";
+export class Ed25519PrivateComponent extends BasePrivateComponent {
+    get Scheme() { return Ed25519Scheme; }
+    get ComponentType() { return Private; }
+    ;
+    get priv() {
+        if (!this.p && this.rB)
+            this.p = BigIntFromByteArray(this.rB);
+        else if (!this.p && !this.rB)
+            throw Error("Empty object");
+        return this.p;
+    }
+    get rawBytes() {
+        if (!this.rB && this.p)
+            this.rB = BigIntToByteArray(this.p);
+        else if (!this.rB && !this.p)
+            throw Error("Empty object");
+        return this.rB;
+    }
+    constructor(rawData) {
+        super();
+        /**@type {bigint} */
+        this.p = undefined;
+        /**@type {Uint8Array} */
+        this.rB = undefined;
+        if (typeof rawData == "bigint") {
+            this.p = rawData;
+        }
+        else if (rawData instanceof Uint8Array) {
+            this.rB = rawData;
+        }
+        else {
+            throw Error("unexpected type;");
+        }
+    }
+    SerializeComponent() {
+        return this.rawBytes.slice();
+    }
+    GetPublic() {
+        return new Ed25519PublicComponent(Point.BASE.mul(this.priv));
+    }
+    static New() {
+        return Ed25519SeedComponent.New().GetPrivate();
+    }
+}
+Ed25519PrivateComponent.Name = "Ed25519PrivateComponent";
+Ed25519PrivateComponent.Version = "1";
+export class Ed25519SeedComponent extends BaseSeedComponent {
+    get Scheme() { return Ed25519Scheme; }
+    get ComponentType() { return Seed; }
+    ;
+    get rawBytes() {
+        return this.rB;
+    }
+    constructor(rawData) {
+        super();
+        /**@type {Uint8Array} */
+        this.rB = undefined;
+        if (rawData instanceof Uint8Array)
+            this.rB = rawData.slice();
+        else if (!rawData)
+            this.rB = Ed25519SeedComponent.GenerateSeed(); // if nothing provided - self instanciate
+        else
+            throw Error("Expecting Uint8Array or nothing for constructor");
+    }
+    SerializeComponent() {
+        return this.rB.slice();
+    }
+    static GenerateSeed() {
+        const head = etc.randomBytes(32);
+        head[0] &= 248; // Clamp bits: 0b1111_1000,
+        head[31] &= 127; // 0b0111_1111,
+        head[31] |= 64; // 0b0100_0000
+        return head;
+    }
+    GetPrivate() {
+        return new Ed25519PrivateComponent(mod(BigIntFromByteArray(this.rawBytes)));
+    }
+    GetPublic() {
+        return this.GetPrivate().GetPublic();
+    }
+    static New() {
+        return new Ed25519SeedComponent(this.GenerateSeed());
+    }
+}
+Ed25519SeedComponent.Name = "Ed25519SeedComponent";
+Ed25519SeedComponent.Version = "1";

package/dist/Cryptide/Components/Schemes/Ed25519/Ed25519Scheme.d.ts

@@ -0,0 +1,13 @@
+import BaseScheme from "../BaseScheme";
+export default class Ed25519Scheme extends BaseScheme {
+    static get Name(): string;
+    /**
+     * WITHOUT DETERMINISM. Prefix is generated via randomisation.
+     * @returns
+     */
+    static GetSigningFunction: () => (msg: any, component: any) => Promise<any>;
+    static GetVerifyingFunction: () => (msg: any, signature: any, component: any) => Promise<void>;
+    static GetEncryptingFunction: () => (msg: any, component: any) => Promise<Uint8Array<ArrayBuffer>>;
+    static GetDecryptingFunction: () => (cipher: any, component: any) => Promise<Uint8Array<ArrayBuffer>>;
+}
+//# sourceMappingURL=Ed25519Scheme.d.ts.map

package/dist/Cryptide/Components/Schemes/Ed25519/Ed25519Scheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ed25519Scheme.d.ts","sourceRoot":"","sources":["../../../../../Cryptide/Components/Schemes/Ed25519/Ed25519Scheme.ts"],"names":[],"mappings":"AAmBA,OAAO,UAAU,MAAM,eAAe,CAAC;AAGvC,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU;IACjD,MAAM,KAAK,IAAI,WAA8B;IAC7C;;;OAGG;IACH,MAAM,CAAC,kBAAkB,mDAQxB;IACD,MAAM,CAAC,oBAAoB,oEAS1B;IACD,MAAM,CAAC,qBAAqB,uEAQ3B;IACD,MAAM,CAAC,qBAAqB,0EAQ3B;CACJ"}

package/dist/Cryptide/Components/Schemes/Ed25519/Ed25519Scheme.js

@@ -0,0 +1,71 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+var _a;
+import { signNonDeterministicAsync, verifyAsync } from "../../../Ed25519";
+import ElGamal from "../../../Encryption/ElGamal";
+import BaseScheme from "../BaseScheme";
+import { Ed25519PrivateComponent, Ed25519PublicComponent } from "./Ed25519Components";
+class Ed25519Scheme extends BaseScheme {
+    static get Name() { return "Ed25519Scheme"; }
+}
+_a = Ed25519Scheme;
+/**
+ * WITHOUT DETERMINISM. Prefix is generated via randomisation.
+ * @returns
+ */
+Ed25519Scheme.GetSigningFunction = () => {
+    const signingFunc = (msg, component) => {
+        if (msg instanceof Uint8Array && component instanceof Ed25519PrivateComponent) {
+            return signNonDeterministicAsync(msg, component.priv);
+        }
+        throw Error("Mismatch of expected types (Uint8Array, Ed25519PrivateComponent)");
+    };
+    return signingFunc;
+};
+Ed25519Scheme.GetVerifyingFunction = () => {
+    const verifyingFunc = async (msg, signature, component) => {
+        if (msg instanceof Uint8Array && signature instanceof Uint8Array && component instanceof Ed25519PublicComponent) {
+            const valid = await verifyAsync(signature, msg, component.rawBytes);
+            if (!valid)
+                throw Error("Signature validation failed");
+        }
+        else
+            throw Error("Mismatch of expected types (Uint8Array, Uint8Array, Ed25519PublicComponent)");
+    };
+    return verifyingFunc;
+};
+Ed25519Scheme.GetEncryptingFunction = () => {
+    const encryptingFunc = async (msg, component) => {
+        if (msg instanceof Uint8Array && component instanceof Ed25519PublicComponent) {
+            return await ElGamal.encryptDataRaw(msg, component.public);
+        }
+        else
+            throw Error("Mismatch between expected types (Uint8Array, Ed25519PublicComponent)");
+    };
+    return encryptingFunc;
+};
+Ed25519Scheme.GetDecryptingFunction = () => {
+    const decryptingFunc = async (cipher, component) => {
+        if (cipher instanceof Uint8Array && component instanceof Ed25519PrivateComponent) {
+            return await ElGamal.decryptDataRaw(cipher, component.priv);
+        }
+        else
+            throw Error("Mismatch between expected types (Uint8Array, Ed25519PrivateComponent)");
+    };
+    return decryptingFunc;
+};
+export default Ed25519Scheme;

package/dist/Cryptide/Components/Schemes/Ed25519/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Ed25519Components';
+export { default as Ed25519Scheme } from './Ed25519Scheme';
+//# sourceMappingURL=index.d.ts.map

package/dist/Cryptide/Components/Schemes/Ed25519/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../Cryptide/Components/Schemes/Ed25519/index.ts"],"names":[],"mappings":"AAiBA,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC"}