@thezelijah/majik-message 1.1.1 → 1.1.3

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

@@ -4,4 +4,5 @@ export declare const KEY_ALGO: {
     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

@@ -1,5 +1,6 @@
 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

@@ -18,3 +18,4 @@ export declare function aesGcmDecrypt(keyBytes: Uint8Array, iv: Uint8Array, ciph
 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;

package/dist/core/crypto/crypto-provider.js

@@ -57,7 +57,6 @@ export function deriveKeyFromMnemonic(mnemonic, salt, iterations = 200000, keyLe
     return deriveKey(SHA256, m, salt, iterations, keyLen);
 }
 export function x25519SharedSecret(privRaw, pubRaw) {
-    // Use @stablelib/x25519 for scalar multiplication / shared secret
     const priv = new Uint8Array(privRaw);
     const pub = new Uint8Array(pubRaw);
     if (x25519.scalarMult) {
@@ -68,3 +67,7 @@ export function x25519SharedSecret(privRaw, pubRaw) {
     }
     throw new Error("@stablelib/x25519: compatible API not found");
 }
+export function sha256(input) {
+    const hashed = hash(new TextEncoder().encode(input));
+    return arrayToBase64(hashed);
+}

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

@@ -1,3 +1,4 @@
+import { MajikKey } from "@thezelijah/majik-key";
 export interface KeyStoreIdentity {
     id: string;
     publicKey: CryptoKey | {
@@ -39,6 +40,7 @@ export declare class KeyStore {
     static onUnlockRequested?: (id: string) => string | Promise<string>;
     static init(deviceID: string): void;
     private static getDB;
+    static addMajikKey(key: MajikKey): Promise<void>;
     private static putSerializedIdentity;
     private static getSerializedIdentity;
     /**

package/dist/core/crypto/keystore.js

@@ -1,5 +1,5 @@
 import { arrayBufferToBase64, base64ToArrayBuffer, base64ToUtf8, utf8ToBase64, concatUint8Arrays, arrayToBase64, } from "../utils/utilities";
-import { KEY_ALGO, MAJIK_SALT } from "./constants";
+import { KEY_ALGO, MAJIK_MNEMONIC_SALT, MAJIK_SALT } from "./constants";
 import { EncryptionEngine } from "./encryption-engine";
 import { generateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
@@ -60,6 +60,19 @@ export class KeyStore {
         });
         return this.dbPromise;
     }
+    static async addMajikKey(key) {
+        const serializedIdentity = key.toSerializedIdentity();
+        const keyIdentity = key.toKeyIdentity();
+        this.unlockedIdentities.set(keyIdentity.id, keyIdentity);
+        const db = await this.getDB();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this.STORE_NAME, "readwrite");
+            const store = tx.objectStore(this.STORE_NAME);
+            const req = store.put(serializedIdentity);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(new KeyStoreError("Failed to store identity", req.error));
+        });
+    }
     static async putSerializedIdentity(identity) {
         const db = await this.getDB();
         return new Promise((resolve, reject) => {
@@ -493,7 +506,7 @@ export class KeyStore {
             }
         }
         // Derive AES key from mnemonic using Stablelib provider
-        const salt = new TextEncoder().encode("MajikMessageMnemonicSalt");
+        const salt = new TextEncoder().encode(MAJIK_MNEMONIC_SALT);
         const keyBytes = providerDeriveKeyFromMnemonic(mnemonic, salt);
         const iv = generateRandomBytes(IV_LENGTH);
         const ciphertext = aesGcmEncrypt(keyBytes, iv, new Uint8Array(privRawBuf));
@@ -571,7 +584,7 @@ export class KeyStore {
         }
     }
     static async deriveKeyFromMnemonic(mnemonic) {
-        const salt = new TextEncoder().encode("MajikMessageMnemonicSalt");
+        const salt = new TextEncoder().encode(MAJIK_MNEMONIC_SALT);
         const keyMaterial = await crypto.subtle.importKey("raw", new TextEncoder().encode(mnemonic), { name: "PBKDF2" }, false, ["deriveKey"]);
         return crypto.subtle.deriveKey({
             name: "PBKDF2",

package/dist/core/database/thread/enums.d.ts

@@ -0,0 +1,7 @@
+export declare const ThreadStatus: {
+    readonly ONGOING: "ongoing";
+    readonly CLOSED: "closed";
+    readonly PENDING_DELETION: "pending_deletion";
+    readonly MARKED_FOR_DELETION: "marked_for_deletion";
+};
+export type ThreadStatus = (typeof ThreadStatus)[keyof typeof ThreadStatus];

package/dist/core/database/thread/enums.js

@@ -0,0 +1,6 @@
+export const ThreadStatus = {
+    ONGOING: "ongoing",
+    CLOSED: "closed",
+    PENDING_DELETION: "pending_deletion",
+    MARKED_FOR_DELETION: "marked_for_deletion",
+};

package/dist/core/database/thread/mail/majik-message-mail.d.ts

@@ -0,0 +1,177 @@
+import { ISODateString, MajikMessageAccountID, MajikMessageMailID, MajikMessagePublicKey, MajikMessageThreadID } from "../../../types";
+import { MajikMessageIdentity } from "../../system/identity";
+import { MajikMessageThread } from "../majik-message-thread";
+export interface MailMetadata {
+    subject?: string;
+    attachments?: string[];
+    priority?: "low" | "medium" | "high" | "urgent";
+    labels?: string[];
+    isForwarded?: boolean;
+    isReply?: boolean;
+}
+export interface MajikMessageMailJSON {
+    id: MajikMessageMailID;
+    thread_id: MajikMessageThreadID;
+    account: MajikMessageAccountID;
+    message: string;
+    sender: MajikMessagePublicKey;
+    recipients: MajikMessagePublicKey[];
+    timestamp: ISODateString;
+    metadata: MailMetadata;
+    hash: string;
+    p_hash: string;
+    previous_mail_id?: MajikMessageMailID;
+    read_by: MajikMessagePublicKey[];
+}
+export declare class MajikMailError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+export declare class MailValidationError extends MajikMailError {
+    constructor(message: string);
+}
+export declare class MailOperationError extends MajikMailError {
+    constructor(message: string);
+}
+export declare class HashIntegrityError extends MajikMailError {
+    constructor(message: string);
+}
+export declare class MajikMessageMail {
+    private readonly _id;
+    private readonly _threadID;
+    private readonly _account;
+    private _message;
+    private readonly _sender;
+    private _recipients;
+    private readonly _timestamp;
+    private _metadata;
+    private readonly _hash;
+    private readonly _p_hash;
+    private readonly _previousMailID?;
+    private _readBy;
+    private static readonly MAX_MESSAGE_LENGTH;
+    private constructor();
+    get id(): MajikMessageMailID;
+    get threadID(): MajikMessageThreadID;
+    get account(): MajikMessageAccountID;
+    get sender(): MajikMessagePublicKey;
+    get recipients(): readonly MajikMessagePublicKey[];
+    get timestamp(): Date;
+    get metadata(): Readonly<MailMetadata>;
+    get hash(): string;
+    get p_hash(): string;
+    get previousMailID(): MajikMessageMailID | undefined;
+    get readBy(): readonly MajikMessagePublicKey[];
+    get message(): string;
+    /**
+     * Creates the first mail item in a thread.
+     * Uses the thread's hash as the p_hash since this is the first item.
+     *
+     * @param thread - The MajikMessageThread this mail belongs to
+     * @param identity - The sender's MajikMessageIdentity
+     * @param message - Plain text message (encrypted)
+     * @param recipients - Array of recipient public keys (excluding sender)
+     * @param metadata - Optional mail metadata
+     * @returns Promise resolving to new MajikMessageMail instance
+     * @throws Error if validation fails or thread is closed
+     */
+    static create(thread: MajikMessageThread, identity: MajikMessageIdentity, message: string, recipients: MajikMessagePublicKey[], metadata?: MailMetadata): Promise<MajikMessageMail>;
+    /**
+     * Creates a reply to an existing mail item in the thread.
+     * Uses the previous mail's hash as part of the p_hash.
+     *
+     * @param thread - The MajikMessageThread this mail belongs to
+     * @param previousMail - The mail being replied to
+     * @param identity - The sender's MajikMessageIdentity
+     * @param message - Plain text message (encrypted)
+     * @param recipients - Array of recipient public keys (excluding sender)
+     * @param metadata - Optional mail metadata
+     * @returns Promise resolving to new MajikMessageMail instance
+     * @throws Error if validation fails or thread is closed
+     */
+    static reply(thread: MajikMessageThread, previousMail: MajikMessageMail, identity: MajikMessageIdentity, message: string, recipients: MajikMessagePublicKey[], metadata?: MailMetadata): Promise<MajikMessageMail>;
+    /**
+     * Generates the hash for the current mail item.
+     * Format: SHA256(id:message:sender:recipients:timestamp)
+     */
+    private static generateHash;
+    /**
+     * Generates the previous hash (blockchain link).
+     * Format: SHA256(currentHash:previousHash)
+     */
+    private static generatePHash;
+    /**
+     * Validates the current mail item's integrity.
+     * Checks hash and p_hash validity.
+     */
+    validate(): boolean;
+    /**
+     * Validates the p_hash against a previous hash.
+     * Used to verify blockchain integrity.
+     *
+     * @param previousHash - The hash from the previous item (or thread hash for first item)
+     * @returns true if p_hash is valid
+     */
+    validatePHash(previousHash: string): boolean;
+    private validateMessage;
+    /**
+     * Validates an entire chain of mail items in a thread.
+     * Verifies both hash and p_hash integrity for all items.
+     *
+     * @param thread - The thread these mail items belong to
+     * @param mailItems - Array of mail items ordered chronologically (oldest first)
+     * @returns Validation result with details
+     */
+    static validateMailChain(thread: MajikMessageThread, mailItems: MajikMessageMail[]): {
+        isValid: boolean;
+        errors: string[];
+        tamperedItems: string[];
+    };
+    /**
+     * Marks this mail as read by a recipient.
+     * @param recipientPublicKey - The public key of the recipient marking as read
+     * @returns true if successfully marked, false if already read
+     */
+    markAsRead(recipientPublicKey: MajikMessagePublicKey): boolean;
+    /**
+     * Checks if a specific user has read this mail.
+     */
+    hasUserRead(recipientPublicKey: MajikMessagePublicKey): boolean;
+    /**
+     * Checks if all recipients have read this mail.
+     */
+    isReadByAll(): boolean;
+    /**
+     * Gets the list of recipients who haven't read this mail yet.
+     */
+    getUnreadRecipients(): MajikMessagePublicKey[];
+    /**
+     * Gets the read percentage.
+     */
+    getReadPercentage(): number;
+    /**
+     * Checks if a user can access this mail (is sender or recipient).
+     */
+    canUserAccess(userPublicKey: MajikMessagePublicKey): boolean;
+    /**
+     * Checks if a user is the sender of this mail.
+     */
+    isSender(userPublicKey: MajikMessagePublicKey): boolean;
+    /**
+     * Checks if a user is a recipient of this mail.
+     */
+    isRecipient(userPublicKey: MajikMessagePublicKey): boolean;
+    /**
+     * Updates the metadata for this mail.
+     */
+    updateMetadata(metadata: Partial<MailMetadata>): void;
+    toJSON(): MajikMessageMailJSON;
+    static fromJSON(json: MajikMessageMailJSON | string): MajikMessageMail;
+    toString(): string;
+    clone(): MajikMessageMail;
+    /**
+     * Validates raw message length
+     */
+    private static validateRawMessageLength;
+    private static isValidJSON;
+}