@majikah/majik-message 0.1.1

package/dist/core/compressor/majik-compressor.js

@@ -0,0 +1,100 @@
+import { init, compress as zstdCompress, decompress as zstdDecompress, } from "@bokuweb/zstd-wasm";
+import { gzipSync, gunzipSync } from "fflate";
+export class MajikCompressor {
+    static PREFIX = "mjkcmp";
+    static initialized = false;
+    static async ensureInit() {
+        if (!this.initialized) {
+            await init(); // only init Zstd for binary mode
+            this.initialized = true;
+        }
+    }
+    static encodeInput(input) {
+        if (typeof input === "string")
+            return { type: "str", data: new TextEncoder().encode(input) };
+        if (input instanceof Uint8Array)
+            return { type: "blob", data: input };
+        if (input instanceof ArrayBuffer)
+            return { type: "blob", data: new Uint8Array(input) };
+        if (typeof input === "object")
+            return {
+                type: "json",
+                data: new TextEncoder().encode(JSON.stringify(input)),
+            };
+        throw new Error("Unsupported input type for MajikCompressor");
+    }
+    static decodeOutput(type, data) {
+        if (type === "str")
+            return new TextDecoder().decode(data);
+        if (type === "json")
+            return JSON.parse(new TextDecoder().decode(data));
+        if (type === "blob")
+            return data;
+        throw new Error(`Unsupported type for decoding: ${type}`);
+    }
+    // --- Compress input and return string ---
+    static async compress(mode, input, level = 9) {
+        const { type, data } = this.encodeInput(input);
+        let compressed;
+        if (mode === "binary") {
+            await this.ensureInit();
+            compressed = zstdCompress(data, level);
+        }
+        else {
+            // plaintext mode → fflate gzip
+            compressed = gzipSync(data);
+        }
+        const b64 = this.uint8ArrayToBase64(compressed);
+        return `${this.PREFIX}:${type}:${b64}`;
+    }
+    // --- Decompress string with prefix ---
+    static async decompress(mode, compressedStr) {
+        if (!compressedStr.startsWith(`${this.PREFIX}:`))
+            throw new Error("Invalid MajikCompressor string format");
+        const [, type, b64] = compressedStr.split(":", 3);
+        const compressedData = this.base64ToUint8Array(b64);
+        let decompressed;
+        if (mode === "binary") {
+            await this.ensureInit();
+            decompressed = zstdDecompress(compressedData);
+        }
+        else {
+            decompressed = gunzipSync(compressedData);
+        }
+        return this.decodeOutput(type, decompressed);
+    }
+    static async decompressJSON(compressedStr) {
+        const result = await this.decompress("binary", compressedStr);
+        if (typeof result === "object" && !(result instanceof Uint8Array))
+            return result;
+        throw new Error("Decompressed data is not JSON");
+    }
+    static async decompressString(compressedStr) {
+        const result = await this.decompress("binary", compressedStr);
+        if (typeof result === "string")
+            return result;
+        throw new Error("Decompressed data is not a string");
+    }
+    static async decompressBlob(compressedStr) {
+        const result = await this.decompress("binary", compressedStr);
+        if (result instanceof Uint8Array)
+            return result;
+        throw new Error("Decompressed data is not a blob");
+    }
+    static uint8ArrayToBase64(u8) {
+        let binary = "";
+        const chunkSize = 0x8000;
+        for (let i = 0; i < u8.length; i += chunkSize) {
+            const chunk = u8.subarray(i, i + chunkSize);
+            binary += String.fromCharCode(...chunk);
+        }
+        return btoa(binary);
+    }
+    static base64ToUint8Array(b64) {
+        const binary = atob(b64);
+        const u8 = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            u8[i] = binary.charCodeAt(i);
+        return u8;
+    }
+}

package/dist/core/contacts/majik-contact-directory.d.ts

@@ -0,0 +1,42 @@
+import { MessageEnvelope } from "../messages/message-envelope";
+import { MAJIK_API_RESPONSE } from "../types";
+import { MajikContact, MajikContactData, SerializedMajikContact } from "./majik-contact";
+export interface MajikContactDirectoryData {
+    contacts: SerializedMajikContact[];
+}
+export declare class MajikContactDirectoryError extends Error {
+    cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare class MajikContactDirectory {
+    private contacts;
+    private fingerprintMap;
+    constructor(initialContacts?: MajikContact[]);
+    addContact(contact: MajikContact): this;
+    addContacts(contacts: MajikContact[]): this;
+    removeContact(id: string): MAJIK_API_RESPONSE;
+    updateContactMeta(id: string, meta: Partial<MajikContactData["meta"]>): MajikContact;
+    getContact(id: string): MajikContact | undefined;
+    getContactByFingerprint(fingerprint: string): MajikContact | undefined;
+    /**
+     * Get contact by public key (base64)
+     * Uses MajikContact.getPublicKeyBase64() for canonical comparison
+     */
+    getContactByPublicKeyBase64(publicKeyBase64: string): Promise<MajikContact | undefined>;
+    hasFingerprint(fingerprint: string): boolean;
+    listContacts(sortedByLabel?: boolean, majikahOnly?: boolean): MajikContact[];
+    blockContact(id: string): MajikContact;
+    unblockContact(id: string): MajikContact;
+    hasContact(id: string): boolean;
+    clear(): this;
+    setMajikahStatus(id: string, status: boolean): MajikContact;
+    isMajikahIdentityChecked(id: string): boolean;
+    isMajikahRegistered(id: string): boolean;
+    /**
+     * Checks if a given envelope corresponds to a known contact
+     */
+    hasContactForEnvelope(envelope: MessageEnvelope): boolean;
+    toJSON(): Promise<MajikContactDirectoryData>;
+    fromJSON(data: MajikContactDirectoryData): Promise<this>;
+    private assertId;
+}

package/dist/core/contacts/majik-contact-directory.js

@@ -0,0 +1,203 @@
+import { KEY_ALGO } from "../crypto/constants";
+import { base64ToArrayBuffer } from "../utils/utilities";
+import { MajikContact, } from "./majik-contact";
+/* -------------------------------
+ * Errors
+ * ------------------------------- */
+export class MajikContactDirectoryError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = "MajikContactDirectoryError";
+        this.cause = cause;
+    }
+}
+/* -------------------------------
+ * MajikContactDirectory Class
+ * ------------------------------- */
+export class MajikContactDirectory {
+    contacts = new Map();
+    fingerprintMap = new Map(); // fingerprint → contact id
+    constructor(initialContacts) {
+        if (initialContacts?.length) {
+            initialContacts.forEach((c) => this.addContact(c));
+        }
+    }
+    /* ================================
+     * Contact Management
+     * ================================ */
+    addContact(contact) {
+        if (!(contact instanceof MajikContact)) {
+            throw new MajikContactDirectoryError("Invalid contact instance");
+        }
+        if (this.contacts.has(contact.id)) {
+            throw new MajikContactDirectoryError(`Contact with id "${contact.id}" already exists`);
+        }
+        this.contacts.set(contact.id, contact);
+        this.fingerprintMap.set(contact.fingerprint, contact.id);
+        return this;
+    }
+    addContacts(contacts) {
+        contacts.forEach((c) => this.addContact(c));
+        return this;
+    }
+    removeContact(id) {
+        this.assertId(id);
+        const contact = this.contacts.get(id);
+        if (contact) {
+            this.fingerprintMap.delete(contact.fingerprint);
+            this.contacts.delete(id);
+            return {
+                message: "Contact removed successfully",
+                success: true,
+            };
+        }
+        else {
+            return {
+                message: "Contact not found",
+                success: false,
+            };
+        }
+    }
+    updateContactMeta(id, meta) {
+        const contact = this.getContact(id);
+        if (!contact)
+            throw new MajikContactDirectoryError("Contact not found");
+        if (meta) {
+            meta.label && contact.updateLabel(meta.label);
+            meta.notes && contact.updateNotes(meta.notes);
+            meta.blocked !== undefined && contact.setBlocked(meta.blocked);
+        }
+        return contact;
+    }
+    getContact(id) {
+        this.assertId(id);
+        return this.contacts.get(id);
+    }
+    getContactByFingerprint(fingerprint) {
+        if (!fingerprint) {
+            throw new MajikContactDirectoryError("Fingerprint must be a non-empty string");
+        }
+        const contactId = this.fingerprintMap.get(fingerprint);
+        return contactId ? this.contacts.get(contactId) : undefined;
+    }
+    /**
+     * Get contact by public key (base64)
+     * Uses MajikContact.getPublicKeyBase64() for canonical comparison
+     */
+    async getContactByPublicKeyBase64(publicKeyBase64) {
+        if (!publicKeyBase64 || typeof publicKeyBase64 !== "string") {
+            throw new MajikContactDirectoryError("Public key must be a non-empty base64 string");
+        }
+        for (const contact of this.contacts.values()) {
+            const contactKey = await contact.getPublicKeyBase64();
+            if (contactKey === publicKeyBase64) {
+                return contact;
+            }
+        }
+        return undefined;
+    }
+    hasFingerprint(fingerprint) {
+        return this.fingerprintMap.has(fingerprint);
+    }
+    listContacts(sortedByLabel = false, majikahOnly = false) {
+        let contacts = [...this.contacts.values()];
+        if (majikahOnly) {
+            contacts = contacts.filter((c) => c.isMajikahRegistered());
+        }
+        if (sortedByLabel) {
+            contacts.sort((a, b) => (a.meta.label || "").localeCompare(b.meta.label || ""));
+        }
+        return contacts;
+    }
+    blockContact(id) {
+        const contact = this.getContact(id);
+        if (!contact)
+            throw new MajikContactDirectoryError(`Contact with id "${id}" not found for block`);
+        return contact.block();
+    }
+    unblockContact(id) {
+        const contact = this.getContact(id);
+        if (!contact)
+            throw new MajikContactDirectoryError(`Contact with id "${id}" not found for unblock`);
+        return contact.unblock();
+    }
+    hasContact(id) {
+        return this.contacts.has(id);
+    }
+    clear() {
+        this.contacts.clear();
+        this.fingerprintMap.clear();
+        return this;
+    }
+    setMajikahStatus(id, status) {
+        const contact = this.getContact(id);
+        if (!contact)
+            throw new MajikContactDirectoryError("Contact not found");
+        contact.setMajikahStatus(status);
+        return contact;
+    }
+    isMajikahIdentityChecked(id) {
+        const contact = this.getContact(id);
+        if (!contact)
+            throw new MajikContactDirectoryError("Contact not found");
+        return contact.isMajikahIdentityChecked();
+    }
+    isMajikahRegistered(id) {
+        const contact = this.getContact(id);
+        if (!contact)
+            throw new MajikContactDirectoryError("Contact not found");
+        return contact.isMajikahRegistered();
+    }
+    /**
+     * Checks if a given envelope corresponds to a known contact
+     */
+    hasContactForEnvelope(envelope) {
+        try {
+            const fingerprint = envelope.extractFingerprint();
+            return this.hasFingerprint(fingerprint);
+        }
+        catch {
+            return false;
+        }
+    }
+    /* ================================
+     * Serialization / Persistence
+     * ================================ */
+    async toJSON() {
+        const contactsData = [];
+        for (const contact of this.contacts.values()) {
+            contactsData.push(await contact.toJSON());
+        }
+        return { contacts: contactsData };
+    }
+    async fromJSON(data) {
+        if (!data?.contacts) {
+            throw new MajikContactDirectoryError("Invalid serialized data");
+        }
+        this.clear();
+        for (const item of data.contacts) {
+            const raw = base64ToArrayBuffer(item.publicKeyBase64);
+            let publicKey;
+            try {
+                publicKey = await crypto.subtle.importKey("raw", raw, KEY_ALGO, true, []);
+            }
+            catch (e) {
+                // Fallback: create a raw-key wrapper when the browser does not support the namedCurve
+                publicKey = { raw: new Uint8Array(raw) };
+            }
+            const contact = MajikContact.create(item.id, publicKey, item.fingerprint, item.meta);
+            this.contacts.set(contact.id, contact);
+            this.fingerprintMap.set(contact.fingerprint, contact.id);
+        }
+        return this;
+    }
+    /* ================================
+     * Validation Helpers
+     * ================================ */
+    assertId(id) {
+        if (!id || typeof id !== "string") {
+            throw new MajikContactDirectoryError("Contact ID must be a non-empty string");
+        }
+    }
+}

package/dist/core/contacts/majik-contact.d.ts

@@ -0,0 +1,72 @@
+import { MajikMessageIdentityJSON } from "../database/system/identity";
+import { ISODateString } from "../types";
+export type SerializedMajikContact = Omit<MajikContactData, "publicKey"> & {
+    publicKeyBase64: string;
+};
+export interface MajikContactMeta {
+    label?: string;
+    notes?: string;
+    blocked?: boolean;
+    createdAt?: ISODateString;
+    updatedAt?: ISODateString;
+}
+export interface MajikContactData {
+    id: string;
+    publicKey: CryptoKey | {
+        raw: Uint8Array;
+    };
+    fingerprint: string;
+    meta?: MajikContactMeta;
+    majikah_registered?: boolean;
+}
+export interface MajikContactCard {
+    id: string;
+    publicKey: string;
+    fingerprint: string;
+    label: string;
+}
+export declare class MajikContactError extends Error {
+    cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare class MajikContact {
+    readonly id: string;
+    readonly publicKey: CryptoKey | {
+        raw: Uint8Array;
+    };
+    readonly fingerprint: string;
+    meta: MajikContactMeta;
+    private majikah_registered?;
+    constructor(data: MajikContactData);
+    static create(id: string, publicKey: CryptoKey | {
+        raw: Uint8Array;
+    }, fingerprint: string, meta?: Partial<MajikContactMeta>): MajikContact;
+    private assertId;
+    private assertPublicKey;
+    private assertFingerprint;
+    private updateTimestamp;
+    updateLabel(label: string): this;
+    updateNotes(notes: string): this;
+    isBlocked(): boolean;
+    setBlocked(blocked: boolean): this;
+    block(): this;
+    unblock(): this;
+    isMajikahIdentityChecked(): boolean;
+    isMajikahRegistered(): boolean;
+    setMajikahStatus(status: boolean): this;
+    getDisplayName(): Promise<string>;
+    /**
+     * Support both CryptoKey and raw-key wrappers (fallbacks when WebCrypto X25519 unsupported)
+     */
+    getPublicKeyBase64(): Promise<string>;
+    toJSON(): Promise<SerializedMajikContact>;
+    /**
+     * Reconstruct a MajikContact from its serialized form
+     */
+    static fromJSON(serialized: SerializedMajikContact): MajikContact;
+    /**
+     * Create a new MajikContact from a MajikMessageIdentityJSON
+     */
+    static fromIdentityJSON(identityJSON: MajikMessageIdentityJSON): Promise<MajikContact>;
+    static isBlocked(contact: MajikContact): boolean;
+}

package/dist/core/contacts/majik-contact.js

@@ -0,0 +1,192 @@
+import { arrayBufferToBase64, base64ToArrayBuffer } from "../utils/utilities";
+/* -------------------------------
+ * Errors
+ * ------------------------------- */
+export class MajikContactError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = "MajikContactError";
+        this.cause = cause;
+    }
+}
+/* -------------------------------
+ * MajikContact Class
+ * ------------------------------- */
+export class MajikContact {
+    id;
+    publicKey;
+    fingerprint;
+    meta;
+    majikah_registered;
+    constructor(data) {
+        this.assertId(data.id);
+        this.assertPublicKey(data.publicKey);
+        this.assertFingerprint(data.fingerprint);
+        this.id = data.id;
+        this.publicKey = data.publicKey;
+        this.fingerprint = data.fingerprint;
+        this.meta = {
+            label: data.meta?.label || "",
+            notes: data.meta?.notes || "",
+            blocked: data.meta?.blocked || false,
+            createdAt: data.meta?.createdAt || new Date().toISOString(),
+            updatedAt: data.meta?.updatedAt || new Date().toISOString(),
+        };
+    }
+    static create(id, publicKey, fingerprint, meta) {
+        return new MajikContact({
+            id,
+            publicKey,
+            fingerprint,
+            meta,
+        });
+    }
+    assertId(id) {
+        if (!id || typeof id !== "string") {
+            throw new MajikContactError("Contact ID must be a non-empty string");
+        }
+    }
+    assertPublicKey(key) {
+        // Accept either a WebCrypto CryptoKey (with .type === 'public')
+        // or a raw-key wrapper object that contains a Uint8Array `raw` field.
+        if (!key)
+            throw new MajikContactError("Invalid public key");
+        const anyKey = key;
+        if (anyKey && typeof anyKey === "object") {
+            if (anyKey.type === "public")
+                return;
+            if (anyKey.raw instanceof Uint8Array)
+                return;
+        }
+        throw new MajikContactError("Invalid public key");
+    }
+    assertFingerprint(fingerprint) {
+        if (!fingerprint || typeof fingerprint !== "string") {
+            throw new MajikContactError("Fingerprint must be a non-empty string");
+        }
+    }
+    updateTimestamp() {
+        this.meta.updatedAt = new Date().toISOString();
+    }
+    updateLabel(label) {
+        if (typeof label !== "string")
+            throw new MajikContactError("Label must be a string");
+        this.meta.label = label;
+        this.updateTimestamp();
+        return this;
+    }
+    updateNotes(notes) {
+        if (typeof notes !== "string")
+            throw new MajikContactError("Notes must be a string");
+        this.meta.notes = notes;
+        this.updateTimestamp();
+        return this;
+    }
+    isBlocked() {
+        return this.meta.blocked || false;
+    }
+    setBlocked(blocked) {
+        if (typeof blocked !== "boolean")
+            throw new MajikContactError("Blocked must be boolean");
+        this.meta.blocked = blocked;
+        this.updateTimestamp();
+        return this;
+    }
+    // Idempotent block/unblock for safe scanning
+    block() {
+        if (!this.isBlocked())
+            this.setBlocked(true);
+        return this;
+    }
+    unblock() {
+        if (this.isBlocked())
+            this.setBlocked(false);
+        return this;
+    }
+    isMajikahIdentityChecked() {
+        return this.majikah_registered !== undefined;
+    }
+    isMajikahRegistered() {
+        return this.majikah_registered || false;
+    }
+    setMajikahStatus(status) {
+        this.majikah_registered = status;
+        return this;
+    }
+    async getDisplayName() {
+        return this.meta.label || (await this.getPublicKeyBase64());
+    }
+    /**
+     * Support both CryptoKey and raw-key wrappers (fallbacks when WebCrypto X25519 unsupported)
+     */
+    async getPublicKeyBase64() {
+        try {
+            // If it's a CryptoKey, export with SubtleCrypto
+            const raw = await crypto.subtle.exportKey("raw", this.publicKey);
+            return arrayBufferToBase64(raw);
+        }
+        catch (e) {
+            // Fallback: publicKey may be a wrapper with `raw` Uint8Array
+            const maybe = this.publicKey;
+            if (maybe && maybe.raw instanceof Uint8Array) {
+                return arrayBufferToBase64(maybe.raw.buffer);
+            }
+            throw e;
+        }
+    }
+    async toJSON() {
+        return {
+            id: this.id,
+            fingerprint: this.fingerprint,
+            meta: { ...this.meta },
+            publicKeyBase64: await this.getPublicKeyBase64(),
+            majikah_registered: this.majikah_registered,
+        };
+    }
+    /**
+     * Reconstruct a MajikContact from its serialized form
+     */
+    static fromJSON(serialized) {
+        try {
+            const publicKeyRaw = new Uint8Array(base64ToArrayBuffer(serialized.publicKeyBase64));
+            return new MajikContact({
+                id: serialized.id,
+                fingerprint: serialized.fingerprint,
+                meta: serialized.meta,
+                publicKey: { raw: publicKeyRaw },
+                majikah_registered: serialized.majikah_registered,
+            });
+        }
+        catch (err) {
+            throw new MajikContactError("Failed to deserialize MajikContact", err);
+        }
+    }
+    /**
+     * Create a new MajikContact from a MajikMessageIdentityJSON
+     */
+    static async fromIdentityJSON(identityJSON) {
+        try {
+            const publicKeyRaw = new Uint8Array(base64ToArrayBuffer(identityJSON.public_key));
+            const contactData = {
+                id: identityJSON.id,
+                publicKey: { raw: publicKeyRaw },
+                fingerprint: identityJSON.id,
+                meta: {
+                    label: identityJSON.label,
+                    createdAt: identityJSON.timestamp,
+                    updatedAt: identityJSON.timestamp,
+                    blocked: identityJSON.restricted,
+                },
+                majikah_registered: true,
+            };
+            return new MajikContact(contactData);
+        }
+        catch (err) {
+            throw new MajikContactError("Failed to create MajikContact from MajikMessageIdentityJSON", err);
+        }
+    }
+    static isBlocked(contact) {
+        return !!contact.meta.blocked;
+    }
+}

package/dist/core/crypto/constants.d.ts

@@ -0,0 +1,8 @@
+import { MAJIK_API_RESPONSE } from "../types";
+export declare const KEY_ALGO: {
+    readonly name: "ECDH";
+    readonly namedCurve: "X25519";
+};
+export declare const MAJIK_SALT = "MajikMessageSalt";
+export declare const MAJIK_MNEMONIC_SALT = "MajikMessageMnemonicSalt";
+export declare const API_DEFAULT_FAIL: MAJIK_API_RESPONSE;

package/dist/core/crypto/constants.js

@@ -0,0 +1,7 @@
+export const KEY_ALGO = { name: "ECDH", namedCurve: "X25519" };
+export const MAJIK_SALT = "MajikMessageSalt";
+export const MAJIK_MNEMONIC_SALT = "MajikMessageMnemonicSalt";
+export const API_DEFAULT_FAIL = {
+    message: "Something went wrong",
+    success: false,
+};

package/dist/core/crypto/crypto-provider.d.ts

@@ -0,0 +1,21 @@
+export declare const IV_LENGTH = 12;
+export declare function generateRandomBytes(len: number): Uint8Array;
+export declare function generateEd25519Keypair(): {
+    edPublic: Uint8Array;
+    edSecret: Uint8Array;
+    xPublic: Uint8Array | null;
+    xSecret: Uint8Array | null;
+};
+export declare function deriveEd25519FromSeed(seed32: Uint8Array): {
+    edPublic: Uint8Array;
+    edSecret: Uint8Array;
+    xPublic: Uint8Array | null;
+    xSecret: Uint8Array | null;
+};
+export declare function fingerprintFromPublicRaw(rawPublic: Uint8Array): string;
+export declare function aesGcmEncrypt(keyBytes: Uint8Array, iv: Uint8Array, plaintext: Uint8Array): Uint8Array;
+export declare function aesGcmDecrypt(keyBytes: Uint8Array, iv: Uint8Array, ciphertext: Uint8Array): Uint8Array | null;
+export declare function deriveKeyFromPassphrase(passphrase: string, salt: Uint8Array, iterations?: number, keyLen?: number): Uint8Array;
+export declare function deriveKeyFromMnemonic(mnemonic: string, salt: Uint8Array, iterations?: number, keyLen?: number): Uint8Array;
+export declare function x25519SharedSecret(privRaw: Uint8Array, pubRaw: Uint8Array): Uint8Array;
+export declare function sha256(input: string): string;