chatly-sdk 0.0.5 → 0.0.6

package/test/crypto.test.ts

@@ -1,45 +1,132 @@
+import { encryptMessage, decryptMessage, deriveSharedSecret } from '../src/crypto/e2e';
+import { generateIdentityKeyPair } from '../src/crypto/keys';
 
-import assert from 'assert';
-import { KeyManager } from '../src/crypto/keyManager';
-import { encrypt } from '../src/crypto/encrypt';
-import { decrypt } from '../src/crypto/decrypt';
+describe('End-to-End Encryption', () => {
+  describe('Key Generation', () => {
+    it('should generate a valid key pair', () => {
+      const keyPair = generateIdentityKeyPair();
+      
+      expect(keyPair).toHaveProperty('publicKey');
+      expect(keyPair).toHaveProperty('privateKey');
+      expect(typeof keyPair.publicKey).toBe('string');
+      expect(typeof keyPair.privateKey).toBe('string');
+      expect(keyPair.publicKey.length).toBeGreaterThan(0);
+      expect(keyPair.privateKey.length).toBeGreaterThan(0);
+    });
 
-async function testCrypto() {
-  console.log('Running crypto tests...');
+    it('should generate unique key pairs', () => {
+      const keyPair1 = generateIdentityKeyPair();
+      const keyPair2 = generateIdentityKeyPair();
+      
+      expect(keyPair1.publicKey).not.toBe(keyPair2.publicKey);
+      expect(keyPair1.privateKey).not.toBe(keyPair2.privateKey);
+    });
+  });
 
-  // Test KeyManager
-  const keyManager1 = new KeyManager();
-  const keyManager2 = new KeyManager();
+  describe('Shared Secret Derivation', () => {
+    it('should derive the same shared secret for both parties', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      
+      const aliceShared = await deriveSharedSecret(aliceKeys.privateKey, bobKeys.publicKey);
+      const bobShared = await deriveSharedSecret(bobKeys.privateKey, aliceKeys.publicKey);
+      
+      expect(aliceShared).toBe(bobShared);
+    });
 
-  await keyManager1.generateKeys();
-  await keyManager2.generateKeys();
+    it('should derive different secrets for different key pairs', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const charlieKeys = generateIdentityKeyPair();
+      
+      const aliceBobSecret = await deriveSharedSecret(aliceKeys.privateKey, bobKeys.publicKey);
+      const aliceCharlieSecret = await deriveSharedSecret(aliceKeys.privateKey, charlieKeys.publicKey);
+      
+      expect(aliceBobSecret).not.toBe(aliceCharlieSecret);
+    });
+  });
 
-  const publicKey1 = keyManager1.getPublicKey();
-  const privateKey1 = keyManager1.getPrivateKey();
-  const publicKey2 = keyManager2.getPublicKey();
-  const privateKey2 = keyManager2.getPrivateKey();
+  describe('Message Encryption and Decryption', () => {
+    it('should encrypt and decrypt a message correctly', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const sharedSecret = await deriveSharedSecret(aliceKeys.privateKey, bobKeys.publicKey);
+      
+      const plaintext = 'Hello, Bob!';
+      const encrypted = await encryptMessage(plaintext, sharedSecret);
+      
+      expect(encrypted).toHaveProperty('ciphertext');
+      expect(encrypted).toHaveProperty('iv');
+      expect(typeof encrypted.ciphertext).toBe('string');
+      expect(typeof encrypted.iv).toBe('string');
+      
+      const decrypted = await decryptMessage(encrypted.ciphertext, encrypted.iv, sharedSecret);
+      expect(decrypted).toBe(plaintext);
+    });
 
-  assert(publicKey1, 'publicKey1 should not be null');
-  assert(privateKey1, 'privateKey1 should not be null');
-  assert(publicKey2, 'publicKey2 should not be null');
-  assert(privateKey2, 'privateKey2 should not be null');
+    it('should produce different ciphertexts for the same plaintext', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const sharedSecret = await deriveSharedSecret(aliceKeys.privateKey, bobKeys.publicKey);
+      
+      const plaintext = 'Hello, Bob!';
+      const encrypted1 = await encryptMessage(plaintext, sharedSecret);
+      const encrypted2 = await encryptMessage(plaintext, sharedSecret);
+      
+      expect(encrypted1.ciphertext).not.toBe(encrypted2.ciphertext);
+      expect(encrypted1.iv).not.toBe(encrypted2.iv);
+    });
 
-  console.log('KeyManager test passed.');
+    it('should fail to decrypt with wrong shared secret', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const charlieKeys = generateIdentityKeyPair();
+      
+      const aliceBobSecret = await deriveSharedSecret(aliceKeys.privateKey, bobKeys.publicKey);
+      const aliceCharlieSecret = await deriveSharedSecret(aliceKeys.privateKey, charlieKeys.publicKey);
+      
+      const plaintext = 'Secret message';
+      const encrypted = await encryptMessage(plaintext, aliceBobSecret);
+      
+      await expect(
+        decryptMessage(encrypted.ciphertext, encrypted.iv, aliceCharlieSecret)
+      ).rejects.toThrow();
+    });
 
-  // Test encrypt and decrypt
-  const message = 'This is a secret message.';
-  if (publicKey1 && privateKey1 && publicKey2 && privateKey2) {
-    const encryptedMessage = await encrypt(message, publicKey2, privateKey1);
-    const decryptedMessage = await decrypt(encryptedMessage, publicKey1, privateKey2);
+    it('should handle empty messages', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const sharedSecret = await deriveSharedSecret(aliceKeys.privateKey, bobKeys.publicKey);
+      
+      const plaintext = '';
+      const encrypted = await encryptMessage(plaintext, sharedSecret);
+      const decrypted = await decryptMessage(encrypted.ciphertext, encrypted.iv, sharedSecret);
+      
+      expect(decrypted).toBe(plaintext);
+    });
 
-    assert.strictEqual(decryptedMessage, message, 'Decrypted message should match original message.');
-  } else {
-    assert.fail('Keys should not be null');
-  }
+    it('should handle long messages', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const sharedSecret = await deriveSharedSecret(aliceKeys.privateKey, bobKeys.publicKey);
+      
+      const plaintext = 'A'.repeat(10000);
+      const encrypted = await encryptMessage(plaintext, sharedSecret);
+      const decrypted = await decryptMessage(encrypted.ciphertext, encrypted.iv, sharedSecret);
+      
+      expect(decrypted).toBe(plaintext);
+    });
 
-  console.log('Encrypt/decrypt test passed.');
-
-  console.log('All crypto tests passed.');
-}
-
-testCrypto().catch(console.error);
+    it('should handle special characters and emojis', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const sharedSecret = await deriveSharedSecret(aliceKeys.privateKey, bobKeys.publicKey);
+      
+      const plaintext = 'Hello 👋 World! 🌍 Special chars: @#$%^&*()';
+      const encrypted = await encryptMessage(plaintext, sharedSecret);
+      const decrypted = await decryptMessage(encrypted.ciphertext, encrypted.iv, sharedSecret);
+      
+      expect(decrypted).toBe(plaintext);
+    });
+  });
+});

package/test/sdk.test.ts

@@ -0,0 +1,276 @@
+import { ChatSDK } from '../src/index';
+import { InMemoryUserStore } from '../src/stores/memory/userStore';
+import { InMemoryMessageStore } from '../src/stores/memory/messageStore';
+import { InMemoryGroupStore } from '../src/stores/memory/groupStore';
+import { EVENTS } from '../src/constants';
+import { ValidationError, SessionError } from '../src/utils/errors';
+
+describe('ChatSDK', () => {
+  let sdk: ChatSDK;
+
+  beforeEach(() => {
+    sdk = new ChatSDK({
+      userStore: new InMemoryUserStore(),
+      messageStore: new InMemoryMessageStore(),
+      groupStore: new InMemoryGroupStore(),
+    });
+  });
+
+  describe('User Management', () => {
+    it('should create a user with valid username', async () => {
+      const user = await sdk.createUser('alice');
+      
+      expect(user).toHaveProperty('id');
+      expect(user).toHaveProperty('username', 'alice');
+      expect(user).toHaveProperty('publicKey');
+      expect(user).toHaveProperty('privateKey');
+      expect(user).toHaveProperty('identityKey');
+    });
+
+    it('should reject invalid usernames', async () => {
+      await expect(sdk.createUser('')).rejects.toThrow(ValidationError);
+      await expect(sdk.createUser('ab')).rejects.toThrow(ValidationError); // Too short
+      await expect(sdk.createUser('a'.repeat(21))).rejects.toThrow(ValidationError); // Too long
+      await expect(sdk.createUser('user@name')).rejects.toThrow(ValidationError); // Invalid chars
+    });
+
+    it('should emit user:created event', async () => {
+      const handler = jest.fn();
+      sdk.on(EVENTS.USER_CREATED, handler);
+      
+      const user = await sdk.createUser('bob');
+      
+      expect(handler).toHaveBeenCalledWith(user);
+    });
+
+    it('should list all users', async () => {
+      await sdk.createUser('alice');
+      await sdk.createUser('bob');
+      
+      const users = await sdk.listUsers();
+      
+      expect(users).toHaveLength(2);
+      expect(users.map(u => u.username)).toContain('alice');
+      expect(users.map(u => u.username)).toContain('bob');
+    });
+
+    it('should get user by ID', async () => {
+      const alice = await sdk.createUser('alice');
+      
+      const retrieved = await sdk.getUserById(alice.id);
+      
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.id).toBe(alice.id);
+      expect(retrieved?.username).toBe('alice');
+    });
+  });
+
+  describe('Session Management', () => {
+    it('should create a 1:1 chat session', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      
+      const session = await sdk.startSession(alice, bob);
+      
+      expect(session).toBeDefined();
+      expect(session.id).toBeDefined();
+    });
+
+    it('should emit session:created event', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const handler = jest.fn();
+      sdk.on(EVENTS.SESSION_CREATED, handler);
+      
+      const session = await sdk.startSession(alice, bob);
+      
+      expect(handler).toHaveBeenCalledWith(session);
+    });
+
+    it('should create consistent session IDs regardless of user order', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      
+      const session1 = await sdk.startSession(alice, bob);
+      const session2 = await sdk.startSession(bob, alice);
+      
+      expect(session1.id).toBe(session2.id);
+    });
+  });
+
+  describe('Group Management', () => {
+    it('should create a group with valid members', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      
+      const group = await sdk.createGroup('Team Chat', [alice, bob]);
+      
+      expect(group).toBeDefined();
+      expect(group.group.name).toBe('Team Chat');
+      expect(group.group.members).toHaveLength(2);
+    });
+
+    it('should reject groups with less than 2 members', async () => {
+      const alice = await sdk.createUser('alice');
+      
+      await expect(
+        sdk.createGroup('Solo Chat', [alice])
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it('should reject invalid group names', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      
+      await expect(
+        sdk.createGroup('', [alice, bob])
+      ).rejects.toThrow(ValidationError);
+      
+      await expect(
+        sdk.createGroup('   ', [alice, bob])
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it('should emit group:created event', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const handler = jest.fn();
+      sdk.on(EVENTS.GROUP_CREATED, handler);
+      
+      const group = await sdk.createGroup('Team', [alice, bob]);
+      
+      expect(handler).toHaveBeenCalledWith(group);
+    });
+
+    it('should list all groups', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      
+      await sdk.createGroup('Group 1', [alice, bob]);
+      await sdk.createGroup('Group 2', [alice, bob]);
+      
+      const groups = await sdk.listGroups();
+      
+      expect(groups).toHaveLength(2);
+    });
+
+    it('should load an existing group', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const created = await sdk.createGroup('Team', [alice, bob]);
+      
+      const loaded = await sdk.loadGroup(created.group.id);
+      
+      expect(loaded.group.id).toBe(created.group.id);
+      expect(loaded.group.name).toBe('Team');
+    });
+  });
+
+  describe('Messaging', () => {
+    it('should send and decrypt a 1:1 message', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const session = await sdk.startSession(alice, bob);
+      
+      sdk.setCurrentUser(alice);
+      const message = await sdk.sendMessage(session, 'Hello Bob!');
+      
+      expect(message).toBeDefined();
+      expect(message.senderId).toBe(alice.id);
+      expect(message.receiverId).toBe(bob.id);
+      
+      const decrypted = await sdk.decryptMessage(message, bob);
+      expect(decrypted).toBe('Hello Bob!');
+    });
+
+    it('should reject messages without current user', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const session = await sdk.startSession(alice, bob);
+      
+      await expect(
+        sdk.sendMessage(session, 'Hello')
+      ).rejects.toThrow(SessionError);
+    });
+
+    it('should reject invalid messages', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const session = await sdk.startSession(alice, bob);
+      
+      sdk.setCurrentUser(alice);
+      
+      await expect(
+        sdk.sendMessage(session, '')
+      ).rejects.toThrow(ValidationError);
+      
+      await expect(
+        sdk.sendMessage(session, 'A'.repeat(10001))
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it('should send and decrypt a group message', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const charlie = await sdk.createUser('charlie');
+      const group = await sdk.createGroup('Team', [alice, bob, charlie]);
+      
+      sdk.setCurrentUser(alice);
+      const message = await sdk.sendMessage(group, 'Hello team!');
+      
+      expect(message.groupId).toBe(group.group.id);
+      
+      const decryptedByBob = await sdk.decryptMessage(message, bob);
+      const decryptedByCharlie = await sdk.decryptMessage(message, charlie);
+      
+      expect(decryptedByBob).toBe('Hello team!');
+      expect(decryptedByCharlie).toBe('Hello team!');
+    });
+
+    it('should get messages for a user', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const session = await sdk.startSession(alice, bob);
+      
+      sdk.setCurrentUser(alice);
+      await sdk.sendMessage(session, 'Message 1');
+      await sdk.sendMessage(session, 'Message 2');
+      
+      const messages = await sdk.getMessagesForUser(bob.id);
+      
+      expect(messages).toHaveLength(2);
+    });
+
+    it('should get messages for a group', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const group = await sdk.createGroup('Team', [alice, bob]);
+      
+      sdk.setCurrentUser(alice);
+      await sdk.sendMessage(group, 'Message 1');
+      await sdk.sendMessage(group, 'Message 2');
+      
+      const messages = await sdk.getMessagesForGroup(group.group.id);
+      
+      expect(messages).toHaveLength(2);
+    });
+  });
+
+  describe('Connection State', () => {
+    it('should return disconnected when no transport', () => {
+      expect(sdk.isConnected()).toBe(false);
+      expect(sdk.getConnectionState()).toBe('disconnected');
+    });
+  });
+
+  describe('Queue Status', () => {
+    it('should return queue status', () => {
+      const status = sdk.getQueueStatus();
+      
+      expect(status).toHaveProperty('size');
+      expect(status).toHaveProperty('pending');
+      expect(status).toHaveProperty('retryable');
+      expect(status.size).toBe(0);
+    });
+  });
+});

package/test/validation.test.ts

@@ -0,0 +1,64 @@
+import { validateUsername, validateMessage, validateGroupName, validateGroupMembers } from '../src/utils/validation';
+import { ValidationError } from '../src/utils/errors';
+
+describe('Validation Utilities', () => {
+  describe('validateUsername', () => {
+    it('should accept valid usernames', () => {
+      expect(() => validateUsername('alice')).not.toThrow();
+      expect(() => validateUsername('bob123')).not.toThrow();
+      expect(() => validateUsername('user_name')).not.toThrow();
+      expect(() => validateUsername('user-name')).not.toThrow();
+      expect(() => validateUsername('ABC')).not.toThrow();
+    });
+
+    it('should reject invalid usernames', () => {
+      expect(() => validateUsername('')).toThrow(ValidationError);
+      expect(() => validateUsername('ab')).toThrow(ValidationError); // Too short
+      expect(() => validateUsername('a'.repeat(21))).toThrow(ValidationError); // Too long
+      expect(() => validateUsername('user@name')).toThrow(ValidationError); // Invalid char
+      expect(() => validateUsername('user name')).toThrow(ValidationError); // Space
+      expect(() => validateUsername('user.name')).toThrow(ValidationError); // Dot
+    });
+  });
+
+  describe('validateMessage', () => {
+    it('should accept valid messages', () => {
+      expect(() => validateMessage('Hello')).not.toThrow();
+      expect(() => validateMessage('A'.repeat(10000))).not.toThrow();
+      expect(() => validateMessage('Message with emojis 👋🌍')).not.toThrow();
+    });
+
+    it('should reject invalid messages', () => {
+      expect(() => validateMessage('')).toThrow(ValidationError);
+      expect(() => validateMessage('A'.repeat(10001))).toThrow(ValidationError); // Too long
+    });
+  });
+
+  describe('validateGroupName', () => {
+    it('should accept valid group names', () => {
+      expect(() => validateGroupName('Team Chat')).not.toThrow();
+      expect(() => validateGroupName('Project 2024')).not.toThrow();
+      expect(() => validateGroupName('A'.repeat(100))).not.toThrow();
+    });
+
+    it('should reject invalid group names', () => {
+      expect(() => validateGroupName('')).toThrow(ValidationError);
+      expect(() => validateGroupName('   ')).toThrow(ValidationError);
+      expect(() => validateGroupName('A'.repeat(101))).toThrow(ValidationError); // Too long
+    });
+  });
+
+  describe('validateGroupMembers', () => {
+    it('should accept valid member counts', () => {
+      expect(() => validateGroupMembers(2)).not.toThrow();
+      expect(() => validateGroupMembers(10)).not.toThrow();
+      expect(() => validateGroupMembers(256)).not.toThrow();
+    });
+
+    it('should reject invalid member counts', () => {
+      expect(() => validateGroupMembers(0)).toThrow(ValidationError);
+      expect(() => validateGroupMembers(1)).toThrow(ValidationError); // Too few
+      expect(() => validateGroupMembers(257)).toThrow(ValidationError); // Too many
+    });
+  });
+});

package/tsconfig.json

@@ -4,26 +4,24 @@
     // File Layout
     // "rootDir": "./src",
     // "outDir": "./dist",
-
     // Environment Settings
     // See also https://aka.ms/tsconfig/module
     "module": "nodenext",
     "target": "esnext",
- 
     // For nodejs:
     // "lib": ["esnext"],
-    "types": ["node"],
+    "types": [
+      "node",
+      "jest"
+    ],
     // and npm install -D @types/node
-
     // Other Outputs
     "sourceMap": true,
     "declaration": true,
     "declarationMap": true,
-
     // Stricter Typechecking Options
     "noUncheckedIndexedAccess": true,
     "exactOptionalPropertyTypes": true,
-
     // Style Options
     // "noImplicitReturns": true,
     // "noImplicitOverride": true,
@@ -31,7 +29,6 @@
     // "noUnusedParameters": true,
     // "noFallthroughCasesInSwitch": true,
     // "noPropertyAccessFromIndexSignature": true,
-
     // Recommended Options
     "strict": true,
     "jsx": "react-jsx",
@@ -39,6 +36,10 @@
     "isolatedModules": true,
     "noUncheckedSideEffectImports": true,
     "moduleDetection": "force",
-    "skipLibCheck": true,
-  }
-}
+    "skipLibCheck": true
+  },
+  "exclude": [
+    "dist",
+    "node_modules"
+  ]
+}

package/tsconfig.test.json

@@ -0,0 +1,11 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "module": "commonjs",
+        "esModuleInterop": true
+    },
+    "include": [
+        "test/**/*.ts",
+        "src/**/*.ts"
+    ]
+}

package/src/ChatManager.ts

@@ -1,103 +0,0 @@
-
-import { KeyManager, KeyPair } from './crypto/keyManager';
-import { encrypt } from './crypto/encrypt';
-import { decrypt } from './crypto/decrypt';
-import { ChatClient } from './transport/websocketClient';
-import { Message } from './models/Message';
-
-export class ChatManager {
-  private keyManager: KeyManager;
-  private chatClient: ChatClient;
-  private contacts: { [id: string]: Uint8Array } = {}; // Maps user ID to public key
-
-  constructor(websocketUrl: string) {
-    this.keyManager = new KeyManager();
-    this.chatClient = new ChatClient(websocketUrl);
-  }
-
-  async initialize(): Promise<void> {
-    await this.keyManager.generateKeys();
-    this.chatClient.connect();
-    this.chatClient.onMessage(this.handleIncomingMessage.bind(this));
-  }
-
-  addContact(userId: string, publicKey: Uint8Array): void {
-    this.contacts[userId] = publicKey;
-  }
-
-  async sendMessage(recipientId: string, content: string): Promise<void> {
-    const recipientPublicKey = this.contacts[recipientId];
-    if (!recipientPublicKey) {
-      throw new Error(`Contact not found: ${recipientId}`);
-    }
-
-    const senderPrivateKey = this.keyManager.getPrivateKey();
-    if (!senderPrivateKey) {
-      throw new Error('Sender keys not generated.');
-    }
-
-    const message: Message = {
-      id: Date.now().toString(),
-      senderId: this.getOwnUserId(),
-      recipientId,
-      content,
-      timestamp: Date.now(),
-    };
-
-    const encryptedMessage = await encrypt(
-      JSON.stringify(message),
-      recipientPublicKey,
-      senderPrivateKey
-    );
-
-    this.chatClient.sendMessage(Buffer.from(encryptedMessage));
-  }
-
-  private async handleIncomingMessage(encryptedMessage: Buffer): Promise<void> {
-    // In a real application, you would need a way to identify the sender
-    // and get their public key. For this example, we'll assume the sender
-    // is the only other contact.
-    const senderId = Object.keys(this.contacts)[0];
-    if (!senderId) {
-      console.error('Received message but no contacts are known.');
-      return;
-    }
-    const senderPublicKey = this.contacts[senderId];
-
-    if (!senderPublicKey) {
-      console.error('Received message from unknown sender.');
-      return;
-    }
-
-    const recipientPrivateKey = this.keyManager.getPrivateKey();
-    if (!recipientPrivateKey) {
-      throw new Error('Recipient keys not generated.');
-    }
-
-    try {
-      const decryptedMessageJson = await decrypt(
-        encryptedMessage,
-        senderPublicKey,
-        recipientPrivateKey
-      );
-      const message: Message = JSON.parse(decryptedMessageJson);
-      console.log('Decrypted message:', message);
-    } catch (error) {
-      console.error('Failed to decrypt message:', error);
-    }
-  }
-
-  getOwnUserId(): string {
-    // In a real app, this would be a unique user ID.
-    // For this example, we'll use a hash of the public key.
-    const publicKey = this.keyManager.getPublicKey();
-    if (!publicKey) {
-      throw new Error('Keys not generated.');
-    }
-    return Buffer.from(publicKey).toString('hex');
-  }
-
-  getOwnPublicKey(): Uint8Array | null {
-    return this.keyManager.getPublicKey();
-  }
-}