@tidecloak/js 0.9.11

package/dist/types/modules/tide-js/Clients/PollingClient.d.ts

@@ -0,0 +1,22 @@
+export default class PollingClient extends ClientBase {
+    constructor(url: any);
+    stopPolling: boolean;
+    /**
+    * @param {string[]} ids
+    */
+    EstablishHttpTunnel(uid: any, ids: string[]): Promise<string>;
+    /**
+    * @param {bigint} channelId
+    */
+    pollServer(channelId: bigint, uiUpdateCallback: any, signal: any): Promise<{
+        status: string;
+        encRequests?: undefined;
+        bitwise?: undefined;
+    } | {
+        encRequests: any;
+        bitwise: any[];
+        status: string;
+    }>;
+    stop(): void;
+}
+import ClientBase from "./ClientBase.js";

package/dist/types/modules/tide-js/Clients/VoucherClient.d.ts

@@ -0,0 +1,12 @@
+export default class VoucherClient extends ClientBase {
+    /**
+     *
+     * @param {Point[]} blurPORKi
+     * @param {string} actionRequest
+     * @param {Point} blurerK
+     */
+    GetVouchers(blurPORKi: Point[], actionRequest: string, blurerK: Point): Promise<VoucherResponse>;
+}
+import ClientBase from "./ClientBase.js";
+import { Point } from "../Cryptide/Ed25519.js";
+import VoucherResponse from "../Models/Responses/Vendor/VoucherResponse.js";

package/dist/types/modules/tide-js/Cryptide/Components/BaseComponent.d.ts

@@ -0,0 +1,59 @@
+export class BaseComponent {
+    static Name: () => never;
+    static Version: () => never;
+    /**
+    * @param {Uint8Array|string} serialized
+    * @returns {BaseComponent}
+    */
+    static DeserializeComponent(serialized: Uint8Array | string): BaseComponent;
+    Add(component: any): void & BaseComponent;
+    Multiply(component: any): void & BaseComponent;
+    Minus(component: any): void & BaseComponent;
+    Equals(component: any): never;
+    Mod(): void & BaseComponent;
+    ModInv(): void & BaseComponent;
+    AddComponent(component: any): void;
+    MultiplyComponent(component: any): void;
+    MinusComponent(component: any): void;
+    EqualsComponent(component: any): void;
+    ModComponent(): void;
+    ModInvComponent(): void;
+    SerializeComponent(): void;
+    /**@returns {BaseScheme} */
+    get Scheme(): BaseScheme;
+    /**@returns {string} */
+    get ComponentType(): string;
+    /**
+     *
+     * @returns {SerializedComponent}
+     */
+    Serialize(): SerializedComponent;
+}
+export class BaseSeedComponent extends BaseComponent {
+    static New(): void;
+    GetPublic(): void;
+    GetPrivate(): void;
+    get rawBytes(): void;
+}
+export class BasePrivateComponent extends BaseComponent {
+    static New(): void;
+    GetPublic(): void;
+    get priv(): void;
+}
+export class BasePublicComponent extends BaseComponent {
+    get public(): void;
+}
+export class SerializedComponent {
+    constructor(bytes: any, compentType: any);
+    Bytes: any;
+    ComponentType: any;
+    ToBytes(): any;
+    ToString(): string;
+}
+export const Seed: "Seed";
+export const Private: "Private";
+export const Public: "Public";
+export const Symmetric: "Symmetric";
+export const QuantumPrivate: "QuantumPrivate";
+export const QuantumPublic: "QuantumPublic";
+import BaseScheme from "./Schemes/BaseScheme.js";

package/dist/types/modules/tide-js/Cryptide/Components/ComponentRegistry.d.ts

@@ -0,0 +1,19 @@
+export class Ed25519PublicComponentFactory {
+    static Create(b: any): Ed25519PublicComponent;
+}
+export class Ed25519PrivateComponentFactory {
+    static Create(b: any): Ed25519PrivateComponent;
+}
+export class Ed25519SeedComponentFactory {
+    static Create(b: any): Ed25519SeedComponent;
+}
+export namespace Registery {
+    namespace Ed25519Scheme {
+        export { Ed25519PublicComponentFactory as Public };
+        export { Ed25519PrivateComponentFactory as Private };
+        export { Ed25519SeedComponentFactory as Seed };
+    }
+}
+import { Ed25519PublicComponent } from "./Schemes/Ed25519/Ed25519Components.js";
+import { Ed25519PrivateComponent } from "./Schemes/Ed25519/Ed25519Components.js";
+import { Ed25519SeedComponent } from "./Schemes/Ed25519/Ed25519Components.js";

package/dist/types/modules/tide-js/Cryptide/Components/Schemes/AES/AESScheme.d.ts

@@ -0,0 +1,4 @@
+export default class AESScheme extends BaseScheme {
+    static get Name(): string;
+}
+import BaseScheme from "../BaseScheme.js";

package/dist/types/modules/tide-js/Cryptide/Components/Schemes/BaseScheme.d.ts

@@ -0,0 +1,10 @@
+export default class BaseScheme {
+    static get Name(): void;
+    /**@returns {(msg: Uint8Array, signature: Uint8Array, pub: BasePublicComponent) => Promise<(boolean)>} */
+    static GetVerifyingFunction: () => (msg: Uint8Array, signature: Uint8Array, pub: BasePublicComponent) => Promise<(boolean)>;
+    /**@returns {(msg: Uint8Array, priv: BasePrivateComponent) => Promise<(Uint8Array)>} */
+    static GetSigningFunction: () => (msg: Uint8Array, priv: BasePrivateComponent) => Promise<(Uint8Array)>;
+    static GetEncryptingFunction: () => never;
+}
+import { BasePublicComponent } from "../BaseComponent.js";
+import { BasePrivateComponent } from "../BaseComponent.js";

package/dist/types/modules/tide-js/Cryptide/Components/Schemes/Ed25519/Ed25519Components.d.ts

@@ -0,0 +1,51 @@
+export class Ed25519PublicComponent extends BasePublicComponent {
+    static Name: string;
+    static Version: string;
+    constructor(rawData: any);
+    get Scheme(): typeof Ed25519Scheme;
+    /**@type {Uint8Array} */
+    pb: Uint8Array;
+    /**@type {Point} */
+    p: Point;
+    get public(): Point;
+    get rawBytes(): Uint8Array<ArrayBufferLike>;
+    AddComponent(component: any): Ed25519PublicComponent;
+    MultiplyComponent(component: any): Ed25519PublicComponent;
+    MinusComponent(component: any): Ed25519PublicComponent;
+    EqualsComponent(component: any): boolean;
+    SerializeComponent(): Uint8Array<ArrayBuffer>;
+}
+export class Ed25519PrivateComponent extends BasePrivateComponent {
+    static Name: string;
+    static Version: string;
+    static New(): any;
+    constructor(rawData: any);
+    get Scheme(): typeof Ed25519Scheme;
+    /**@type {bigint} */
+    p: bigint;
+    /**@type {Uint8Array} */
+    rB: Uint8Array;
+    get priv(): bigint;
+    get rawBytes(): Uint8Array<ArrayBufferLike>;
+    SerializeComponent(): Uint8Array<ArrayBuffer>;
+    GetPublic(): Ed25519PublicComponent;
+}
+export class Ed25519SeedComponent extends BaseSeedComponent {
+    static Name: string;
+    static Version: string;
+    static GenerateSeed(): bigint;
+    static New(): Promise<Ed25519SeedComponent>;
+    constructor(rawData: any);
+    get Scheme(): typeof Ed25519Scheme;
+    /**@type {Uint8Array} */
+    rB: Uint8Array;
+    get rawBytes(): Uint8Array<ArrayBufferLike>;
+    SerializeComponent(): Uint8Array<ArrayBuffer>;
+    GetPrivate(): Ed25519PrivateComponent;
+    GetPublic(): Ed25519PublicComponent;
+}
+import { BasePublicComponent } from "../../BaseComponent.js";
+import Ed25519Scheme from "./Ed25519Scheme.js";
+import { Point } from "../../../Ed25519.js";
+import { BasePrivateComponent } from "../../BaseComponent.js";
+import { BaseSeedComponent } from "../../BaseComponent.js";

package/dist/types/modules/tide-js/Cryptide/Components/Schemes/Ed25519/Ed25519Scheme.d.ts

@@ -0,0 +1,10 @@
+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>;
+}
+import BaseScheme from "../BaseScheme.js";

package/dist/types/modules/tide-js/Cryptide/Components/Schemes/SchemeRegistry.d.ts

@@ -0,0 +1,3 @@
+export const SchemeType: (typeof AESScheme | typeof Ed25519Scheme)[];
+import AESScheme from "./AES/AESScheme.js";
+import Ed25519Scheme from "./Ed25519/Ed25519Scheme.js";

package/dist/types/modules/tide-js/Cryptide/Ed25519.d.ts

@@ -0,0 +1,114 @@
+export namespace CURVE {
+    export let a: bigint;
+    export { _d as d };
+    export { P as p };
+    export { N as n };
+    export let h: number;
+    export { Gx };
+    export { Gy };
+}
+export namespace etc {
+    export { b2h as bytesToHex };
+    export { h2b as hexToBytes };
+    export { concatB as concatBytes };
+    export { M as mod };
+    export { invert };
+    export function randomBytes(len?: number): Uint8Array<any>;
+    export function sha512Async(...messages: any[]): Promise<Uint8Array<any>>;
+    export let sha512Sync: undefined;
+    export { n2b_32LE as bigIntToBytes };
+    export { b2n_LE as bytesToBigInt };
+}
+/** Point in xyzt extended coordinates. */
+export class Point {
+    static fromAffine(p: any): Point;
+    /** RFC8032 5.1.3: hex / Uint8Array to Point. */
+    static fromHex(hex: any): Point;
+    static fromBase64(b64string: any): Point | undefined;
+    static fromBytes(bytes: any, zip215?: boolean): Point;
+    constructor(ex: any, ey: any, ez: any, et: any);
+    ex: bigint;
+    ey: bigint;
+    ez: bigint;
+    et: bigint;
+    get x(): bigint;
+    get y(): bigint;
+    assertValidity(): boolean;
+    equals(other: any): boolean;
+    is0(): boolean;
+    negate(): Point;
+    /** Point doubling. Complete formula. */
+    double(): Point;
+    /** Point addition. Complete formula. */
+    add(other: any): Point;
+    mul(n: any, safe?: boolean): Point;
+    multiply(scalar: any): Point;
+    divide(scalar: any): Point;
+    clearCofactor(): Point;
+    isSmallOrder(): boolean;
+    isTorsionFree(): boolean;
+    /** converts point to 2d xy affine point. (x, y, z, t) ∋ (x=x/z, y=y/z, t=xy). */
+    toAffine(): {
+        x: bigint;
+        y: bigint;
+    };
+    toRawBytes(): Uint8Array<any>;
+    toHex(): string;
+    toBase64(): string;
+    hash(): Promise<bigint>;
+}
+export namespace Point {
+    let BASE: Point;
+    let ZERO: Point;
+}
+/** Creates 32-byte ed25519 public key from 32-byte private key. To use, set `etc.sha512Sync` first. */
+export function getPublicKey(priv: any): Uint8Array<any>;
+/** Creates 32-byte ed25519 public key from 32-byte private key. Async. */
+export function getPublicKeyAsync(priv: any): Promise<Uint8Array<any>>;
+/** Signs message (NOT message hash) using private key. To use, set `etc.sha512Sync` first. */
+export function sign(msg: any, privKey: any): any;
+/** Signs message (NOT message hash) using private key. Async. */
+export function signAsync(msg: any, privKey: any): Promise<any>;
+/** Signs message (NOT message hash) using private key without determinism. Async. */
+export function signNonDeterministicAsync(msg: any, privKey: any): Promise<any>;
+export namespace utils {
+    export { getExtendedPublicKeyAsync };
+    export { getExtendedPublicKey };
+    export function randomPrivateKey(): Uint8Array<any>;
+    export function precompute(w?: number, p?: Point): Point;
+}
+/** Verifies signature on message and public key. To use, set `etc.sha512Sync` first. */
+export function verify(s: any, m: any, p: any, opts?: {
+    zip215: boolean;
+}): any;
+/** Verifies signature on message and public key. Async. */
+export function verifyAsync(s: any, m: any, p: any, opts?: {
+    zip215: boolean;
+}): Promise<any>;
+declare const _d: 37095705934669439343138083508754565189542113879843219016388785533085940283555n;
+declare const P: bigint;
+declare const N: bigint;
+declare const Gx: 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an;
+declare const Gy: 0x6666666666666666666666666666666666666666666666666666666666666658n;
+declare function b2h(b: any): string;
+declare function h2b(hex: any): Uint8Array<any>;
+declare function concatB(...arrs: any[]): Uint8Array<any>;
+declare function M(a: any, b?: bigint): bigint;
+declare function invert(num: any, md: any): bigint;
+declare function n2b_32LE(num: any): Uint8Array<any>;
+declare function b2n_LE(b: any): any;
+declare function getExtendedPublicKeyAsync(priv: any): Promise<{
+    head: any;
+    prefix: any;
+    scalar: bigint;
+    point: Point;
+    pointBytes: Uint8Array<any>;
+}>;
+declare function getExtendedPublicKey(priv: any): {
+    head: any;
+    prefix: any;
+    scalar: bigint;
+    point: Point;
+    pointBytes: Uint8Array<any>;
+};
+export {};

package/dist/types/modules/tide-js/Cryptide/Encryption/AES.d.ts

@@ -0,0 +1,30 @@
+/**
+ *
+ * @param {Uint8Array} rawKey
+ * @param {Iterable} keyUsage
+ * @returns
+ */
+export function createAESKey(rawKey: Uint8Array, keyUsage: Iterable<any>): Promise<CryptoKey>;
+/**
+ * @param {string|Uint8Array} secretData
+ * @param {Uint8Array|bigint|string} key
+ * @returns
+ */
+export function encryptData(secretData: string | Uint8Array, key: Uint8Array | bigint | string): Promise<string>;
+/**
+ * @param {Uint8Array} encodedData
+ * @param {Uint8Array} aesKey
+ * @returns
+ */
+export function encryptDataRawOutput(encodedData: Uint8Array, aesKey: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+/**
+ * @param {string} encryptedData
+ * @param {Uint8Array|bigint|string} key
+ * @returns
+ */
+export function decryptData(encryptedData: string, key: Uint8Array | bigint | string): Promise<string>;
+/**
+ * @param {Uint8Array} encryptedData
+ * @param {Uint8Array} key 32 bytes
+ */
+export function decryptDataRawOutput(encryptedData: Uint8Array, key: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;

package/dist/types/modules/tide-js/Cryptide/Encryption/DH.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {Point} pub
+ * @param {BigInt|string|Uint8Array} priv
+ */
+export function computeSharedKey(pub: Point, priv: bigint | string | Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+/**
+ *
+ * @param {Point[]} pubs
+ * @param {bigint|string|Uint8Array} priv
+ */
+export function generateECDHi(pubs: Point[], priv: bigint | string | Uint8Array): Promise<Uint8Array<ArrayBuffer>[]>;
+import { Point } from "../Ed25519.js";

package/dist/types/modules/tide-js/Cryptide/Encryption/ElGamal.d.ts

@@ -0,0 +1,20 @@
+export default class ElGamal {
+    /**
+     *
+     * @param {Uint8Array} secretData
+     * @param {Point} publicKey
+     */
+    static encryptData(secretData: Uint8Array, publicKey: Point): Promise<string>;
+    /**
+     *
+     * @param {Uint8Array} secretData
+     * @param {Point} publicKey
+     */
+    static encryptDataRaw(secretData: Uint8Array, publicKey: Point): Promise<Uint8Array<ArrayBuffer>>;
+    /**
+     * @param {string} base64_c1_c2
+     * @param {bigint | Uint8Array} k
+     */
+    static decryptData(base64_c1_c2: string, k: bigint | Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+}
+import { Point } from "../Ed25519.js";

package/dist/types/modules/tide-js/Cryptide/Hashing/H2P.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hashes a msg to a point on the ed25519 curve.
+ * @param {string|Uint8Array} msg
+ * @returns {Promise<Point>}
+ */
+export default function HashToPoint(msg: string | Uint8Array): Promise<Point>;
+import { Point } from "../Ed25519.js";

package/dist/types/modules/tide-js/Cryptide/Hashing/Hash.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {string|Uint8Array} message
+ * @returns
+ */
+export function SHA256_Digest(message: string | Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+/**
+ * @param {string|Uint8Array} message
+ * @returns
+ */
+export function SHA512_Digest(message: string | Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+/**
+ * DO NOT USE THIS TO SIGN. THE KEY IS THE HASH OF THE FIRST MESSAGE PASSED. THIS FUNCTION IS FOR HASHING MULTIPLE MESSAGES.
+ * @param {string} message
+ * @param {Point} pub
+ */
+export function HMAC_forHashing(message: string, pub: Point): Promise<Uint8Array<ArrayBuffer>>;

package/dist/types/modules/tide-js/Cryptide/Interpolation.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @param {bigint} xi
+ * @param {bigint[]} xs
+ * @param {bigint} m
+ * @returns {bigint}
+ */
+export function GetLi(xi: bigint, xs: bigint[], m?: bigint): bigint;
+/**
+ * @param {bigint[]} ids
+ */
+export function GetLis(ids: bigint[]): bigint[];
+/**
+ *
+ * @param {Point[]} points
+ */
+export function AggregatePoints(points: Point[]): Point | null;
+/**
+ *
+ * @param {Ed25519PublicComponent[]} points
+ */
+export function AggregatePublicComponents(points: Ed25519PublicComponent[]): Ed25519PublicComponent | null;
+/**
+ *
+ * @param {Ed25519PublicComponent[]} pointArrays
+ */
+export function AggregatePublicComponentArrays(pointArrays: Ed25519PublicComponent[]): any;
+/**
+ * Will aggregate all points at corresponding indexes. E.g. all points from each array at index 0 will be summed.
+ * @param {Point[][]} pointArrays
+ */
+export function AggregatePointArrays(pointArrays: Point[][]): (Point | null)[];
+/**
+ * Will aggregate all points and multiply by corresponding li of id.
+ * @param {Point[]} points
+ * @param {bigint[]} ids
+ * @returns {Point}
+ */
+export function AggregatePointsWithIds(points: Point[], ids: bigint[]): Point;
+/**
+ * Will aggregate all points and multiply by corresponding li.
+ * @param {Point[]} points
+ * @param {bigint[]} lis
+ * @returns {Point}
+ */
+export function AggregatePointsWithLis(points: Point[], lis: bigint[]): Point;
+import { Point } from "./Ed25519.js";
+import { Ed25519PublicComponent } from "./Components/Schemes/Ed25519/Ed25519Components.js";

package/dist/types/modules/tide-js/Cryptide/Math.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export function mod(a: bigint, b?: bigint): bigint;
+/**
+ *
+ * @param {bigint[]} numbers
+ * @returns
+ */
+export function median(numbers: bigint[]): bigint;
+/**
+ * @returns {bigint}
+ */
+export function RandomBigInt(): bigint;
+export function GenSessKey(): Uint8Array<ArrayBufferLike>;
+/**
+ * @param {Point} gPassPRISM
+ * @returns
+ */
+export function CreateGPrismAuth(gPassPRISM: Point): Promise<Point>;
+/**
+ *
+ * @param {bigint | Uint8Array} a
+ */
+export function GetPublic(a: bigint | Uint8Array): Point;
+/**
+ *
+ * @param {number[]} arr
+ * @returns
+ */
+export function Min(arr: number[]): number;
+/**
+ * @param {bigint} number
+ * @param {bigint} modulo
+ * @returns {bigint}
+ */
+export function mod_inv(number: bigint, modulo?: bigint): bigint;
+/**
+*
+* @param {Point[]} points
+*/
+export function SumPoints(points: Point[]): Point;
+import { Point } from "./Ed25519.js";