@k9o/react-native-matrix-crypto 1.0.0

package/lib/index.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatrixCrypto = void 0;
+const react_native_1 = require("react-native");
+const LINKING_ERROR = `The package 'react-native-matrix-crypto' doesn't seem to be linked. Make sure: \n\n` +
+    react_native_1.Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+    '- You rebuilt the app after installing the package\n' +
+    '- You are not using Expo Go\n';
+const MatrixCryptoModule = react_native_1.NativeModules.MatrixCrypto
+    ? react_native_1.NativeModules.MatrixCrypto
+    : new Proxy({}, {
+        get() {
+            throw new Error(LINKING_ERROR);
+        },
+    });
+class MatrixCrypto {
+    constructor() {
+        this.handle = null;
+    }
+    /**
+     * Get or create singleton instance
+     */
+    static getInstance() {
+        if (!MatrixCrypto.instance) {
+            MatrixCrypto.instance = new MatrixCrypto();
+        }
+        return MatrixCrypto.instance;
+    }
+    /**
+     * Initialize the crypto machine
+     */
+    async initialize(userId, deviceId, pickleKey) {
+        try {
+            this.handle = await MatrixCryptoModule.initialize(userId, deviceId, pickleKey);
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize Matrix crypto: ${error}`);
+        }
+    }
+    /**
+     * Get the device fingerprint
+     */
+    async getDeviceFingerprint() {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            return await MatrixCryptoModule.getDeviceFingerprint(this.handle);
+        }
+        catch (error) {
+            throw new Error(`Failed to get device fingerprint: ${error}`);
+        }
+    }
+    /**
+     * Get the user ID
+     */
+    async getUserId() {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            return await MatrixCryptoModule.getUserId(this.handle);
+        }
+        catch (error) {
+            throw new Error(`Failed to get user ID: ${error}`);
+        }
+    }
+    /**
+     * Get the device ID
+     */
+    async getDeviceId() {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            return await MatrixCryptoModule.getDeviceId(this.handle);
+        }
+        catch (error) {
+            throw new Error(`Failed to get device ID: ${error}`);
+        }
+    }
+    /**
+     * Get devices for a user
+     */
+    async getUserDevices(userId) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            return await MatrixCryptoModule.getUserDevices(this.handle, userId);
+        }
+        catch (error) {
+            throw new Error(`Failed to get user devices: ${error}`);
+        }
+    }
+    /**
+     * Add a device
+     */
+    async addDevice(device) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            await MatrixCryptoModule.addDevice(this.handle, device);
+        }
+        catch (error) {
+            throw new Error(`Failed to add device: ${error}`);
+        }
+    }
+    /**
+     * Start device verification
+     */
+    async startVerification(otherUserId, otherDeviceId) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            return await MatrixCryptoModule.startVerification(this.handle, otherUserId, otherDeviceId);
+        }
+        catch (error) {
+            throw new Error(`Failed to start verification: ${error}`);
+        }
+    }
+    /**
+     * Get SAS emojis
+     */
+    async getSASEmojis(verificationId) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            return await MatrixCryptoModule.getSASEmojis(this.handle, verificationId);
+        }
+        catch (error) {
+            throw new Error(`Failed to get SAS emojis: ${error}`);
+        }
+    }
+    /**
+     * Confirm SAS
+     */
+    async confirmSAS(verificationId) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            await MatrixCryptoModule.confirmSAS(this.handle, verificationId);
+        }
+        catch (error) {
+            throw new Error(`Failed to confirm SAS: ${error}`);
+        }
+    }
+    /**
+     * Complete verification
+     */
+    async completeVerification(verificationId) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            await MatrixCryptoModule.completeVerification(this.handle, verificationId);
+        }
+        catch (error) {
+            throw new Error(`Failed to complete verification: ${error}`);
+        }
+    }
+    /**
+     * Cancel verification
+     */
+    async cancelVerification(verificationId) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            await MatrixCryptoModule.cancelVerification(this.handle, verificationId);
+        }
+        catch (error) {
+            throw new Error(`Failed to cancel verification: ${error}`);
+        }
+    }
+    /**
+     * Get verification state
+     */
+    async getVerificationState(verificationId) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            return await MatrixCryptoModule.getVerificationState(this.handle, verificationId);
+        }
+        catch (error) {
+            throw new Error(`Failed to get verification state: ${error}`);
+        }
+    }
+    /**
+     * Enable room encryption
+     */
+    async enableRoomEncryption(roomId, algorithm) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            await MatrixCryptoModule.enableRoomEncryption(this.handle, roomId, algorithm);
+        }
+        catch (error) {
+            throw new Error(`Failed to enable room encryption: ${error}`);
+        }
+    }
+    /**
+     * Get room encryption state
+     */
+    async getRoomEncryptionState(roomId) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            return await MatrixCryptoModule.getRoomEncryptionState(this.handle, roomId);
+        }
+        catch (error) {
+            throw new Error(`Failed to get room encryption state: ${error}`);
+        }
+    }
+    /**
+     * Encrypt event
+     */
+    async encryptEvent(roomId, eventType, content) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            return await MatrixCryptoModule.encryptEvent(this.handle, roomId, eventType, content);
+        }
+        catch (error) {
+            throw new Error(`Failed to encrypt event: ${error}`);
+        }
+    }
+    /**
+     * Decrypt event
+     */
+    async decryptEvent(roomId, encryptedContent) {
+        if (!this.handle) {
+            throw new Error('Crypto not initialized');
+        }
+        try {
+            return await MatrixCryptoModule.decryptEvent(this.handle, roomId, encryptedContent);
+        }
+        catch (error) {
+            throw new Error(`Failed to decrypt event: ${error}`);
+        }
+    }
+    /**
+     * Cleanup
+     */
+    async destroy() {
+        if (this.handle) {
+            try {
+                await MatrixCryptoModule.destroy(this.handle);
+            }
+            catch (error) {
+                console.error(`Failed to destroy crypto: ${error}`);
+            }
+            this.handle = null;
+        }
+    }
+}
+exports.MatrixCrypto = MatrixCrypto;
+MatrixCrypto.instance = null;
+exports.default = MatrixCrypto.getInstance();

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@k9o/react-native-matrix-crypto",
+  "version": "1.0.0",
+  "description": "Native Rust crypto bridge for React Native Matrix client with End-to-End Encryption support",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "src",
+    "ios",
+    "android",
+    "react-native-matrix-crypto.podspec"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "prepare": "npm run build",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint src --ext .ts,.tsx"
+  },
+  "keywords": [
+    "matrix",
+    "crypto",
+    "e2ee",
+    "encryption",
+    "react-native",
+    "ios",
+    "android",
+    "rust",
+    "uniffi"
+  ],
+  "author": "Matrix Chat Contributors",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/k9o-dev/matrix-crypto-bridge.git",
+    "directory": "react-native-matrix-crypto"
+  },
+  "bugs": {
+    "url": "https://github.com/k9o-dev/matrix-crypto-bridge/issues"
+  },
+  "homepage": "https://github.com/k9o-dev/matrix-crypto-bridge#readme",
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-native": ">=0.71.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "react": "^19.2.4",
+    "react-native": "^0.84.1",
+    "@types/react": "^19.2.0",
+    "@types/react-native": "^0.73.0",
+    "typescript": "^5.3.3",
+    "jest": "^29.7.0",
+    "eslint": "^8.50.0",
+    "@typescript-eslint/eslint-plugin": "^6.7.0",
+    "@typescript-eslint/parser": "^6.7.0"
+  },
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=8.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/react-native-matrix-crypto.podspec

@@ -0,0 +1,25 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-matrix-crypto"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+  s.platforms    = { :ios => "11.0" }
+  s.source       = { :git => package["repository"]["url"], :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.requires_arc = true
+
+  s.dependency "React-Core"
+  s.dependency "MatrixCryptoBridge"
+
+  s.pod_target_xcconfig = {
+    "DEFINES_MODULE" => "YES",
+    "SWIFT_VERSION" => "5.9"
+  }
+end

package/src/CryptoAPI.ts

@@ -0,0 +1,256 @@
+import { NativeMatrixCrypto } from './NativeMatrixCrypto';
+import {
+  DeviceInfo,
+  EmojiSASPair,
+  VerificationState,
+  RoomEncryptionState,
+} from './index';
+
+/**
+ * High-level API for Matrix crypto operations
+ * Provides a clean, easy-to-use interface for encryption, device verification, and key management
+ */
+export class CryptoAPI {
+  private initialized: boolean = false;
+  private userId: string = '';
+  private deviceId: string = '';
+
+  /**
+   * Initialize the crypto API
+   */
+  async initialize(
+    userId: string,
+    deviceId: string,
+    pickleKey: string
+  ): Promise<void> {
+    try {
+      await NativeMatrixCrypto.initialize(userId, deviceId, pickleKey);
+      this.initialized = true;
+      this.userId = userId;
+      this.deviceId = deviceId;
+    } catch (error) {
+      throw new Error(`Failed to initialize crypto: ${error}`);
+    }
+  }
+
+  /**
+   * Check if crypto is initialized
+   */
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  /**
+   * Get device information
+   */
+  async getDeviceInfo(): Promise<{
+    fingerprint: string;
+    userId: string;
+    deviceId: string;
+  }> {
+    this.assertInitialized();
+    try {
+      const [fingerprint, userId, deviceId] = await Promise.all([
+        NativeMatrixCrypto.getDeviceFingerprint(),
+        NativeMatrixCrypto.getUserId(),
+        NativeMatrixCrypto.getDeviceId(),
+      ]);
+      return { fingerprint, userId, deviceId };
+    } catch (error) {
+      throw new Error(`Failed to get device info: ${error}`);
+    }
+  }
+
+  /**
+   * Get all devices for a user
+   */
+  async getUserDevices(userId: string): Promise<DeviceInfo[]> {
+    this.assertInitialized();
+    try {
+      return await NativeMatrixCrypto.getUserDevices(userId);
+    } catch (error) {
+      throw new Error(`Failed to get user devices: ${error}`);
+    }
+  }
+
+  /**
+   * Add a device to the device store
+   */
+  async addDevice(device: DeviceInfo): Promise<void> {
+    this.assertInitialized();
+    try {
+      await NativeMatrixCrypto.addDevice(device);
+    } catch (error) {
+      throw new Error(`Failed to add device: ${error}`);
+    }
+  }
+
+  /**
+   * Start device verification with another device
+   */
+  async startVerification(
+    otherUserId: string,
+    otherDeviceId: string
+  ): Promise<VerificationState> {
+    this.assertInitialized();
+    try {
+      const result = await NativeMatrixCrypto.startVerification(
+        otherUserId,
+        otherDeviceId
+      );
+      return result as VerificationState;
+    } catch (error) {
+      throw new Error(`Failed to start verification: ${error}`);
+    }
+  }
+
+  /**
+   * Get SAS emoji pairs for verification
+   */
+  async getSASEmojis(verificationId: string): Promise<EmojiSASPair[]> {
+    this.assertInitialized();
+    try {
+      return await NativeMatrixCrypto.getSASEmojis(verificationId);
+    } catch (error) {
+      throw new Error(`Failed to get SAS emojis: ${error}`);
+    }
+  }
+
+  /**
+   * Confirm SAS verification
+   */
+  async confirmSAS(verificationId: string): Promise<void> {
+    this.assertInitialized();
+    try {
+      await NativeMatrixCrypto.confirmSAS(verificationId);
+    } catch (error) {
+      throw new Error(`Failed to confirm SAS: ${error}`);
+    }
+  }
+
+  /**
+   * Complete device verification
+   */
+  async completeVerification(verificationId: string): Promise<void> {
+    this.assertInitialized();
+    try {
+      await NativeMatrixCrypto.completeVerification(verificationId);
+    } catch (error) {
+      throw new Error(`Failed to complete verification: ${error}`);
+    }
+  }
+
+  /**
+   * Cancel device verification
+   */
+  async cancelVerification(verificationId: string): Promise<void> {
+    this.assertInitialized();
+    try {
+      await NativeMatrixCrypto.cancelVerification(verificationId);
+    } catch (error) {
+      throw new Error(`Failed to cancel verification: ${error}`);
+    }
+  }
+
+  /**
+   * Get the current state of a verification
+   */
+  async getVerificationState(
+    verificationId: string
+  ): Promise<VerificationState> {
+    this.assertInitialized();
+    try {
+      const result = await NativeMatrixCrypto.getVerificationState(verificationId);
+      return result as VerificationState;
+    } catch (error) {
+      throw new Error(`Failed to get verification state: ${error}`);
+    }
+  }
+
+  /**
+   * Enable encryption for a room
+   */
+  async enableRoomEncryption(
+    roomId: string,
+    algorithm: string = 'm.megolm.v1.aes-sha2'
+  ): Promise<void> {
+    this.assertInitialized();
+    try {
+      await NativeMatrixCrypto.enableRoomEncryption(roomId, algorithm);
+    } catch (error) {
+      throw new Error(`Failed to enable room encryption: ${error}`);
+    }
+  }
+
+  /**
+   * Get encryption state for a room
+   */
+  async getRoomEncryptionState(roomId: string): Promise<RoomEncryptionState> {
+    this.assertInitialized();
+    try {
+      return await NativeMatrixCrypto.getRoomEncryptionState(roomId);
+    } catch (error) {
+      throw new Error(`Failed to get room encryption state: ${error}`);
+    }
+  }
+
+  /**
+   * Encrypt an event
+   */
+  async encryptEvent(
+    roomId: string,
+    eventType: string,
+    content: string
+  ): Promise<string> {
+    this.assertInitialized();
+    try {
+      return await NativeMatrixCrypto.encryptEvent(
+        roomId,
+        eventType,
+        content
+      );
+    } catch (error) {
+      throw new Error(`Failed to encrypt event: ${error}`);
+    }
+  }
+
+  /**
+   * Decrypt an event
+   */
+  async decryptEvent(
+    roomId: string,
+    encryptedContent: string
+  ): Promise<string> {
+    this.assertInitialized();
+    try {
+      return await NativeMatrixCrypto.decryptEvent(roomId, encryptedContent);
+    } catch (error) {
+      throw new Error(`Failed to decrypt event: ${error}`);
+    }
+  }
+
+  /**
+   * Cleanup and destroy the crypto instance
+   */
+  async destroy(): Promise<void> {
+    try {
+      await NativeMatrixCrypto.destroy();
+      this.initialized = false;
+    } catch (error) {
+      throw new Error(`Failed to destroy crypto: ${error}`);
+    }
+  }
+
+  /**
+   * Helper method to ensure crypto is initialized
+   */
+  private assertInitialized(): void {
+    if (!this.initialized) {
+      throw new Error(
+        'Crypto not initialized. Call initialize() first.'
+      );
+    }
+  }
+}
+
+export default CryptoAPI;