@massalabs/gossip-sdk 0.0.1

package/test/session/wasm.spec.ts

@@ -0,0 +1,227 @@
+/**
+ * Real WASM Session Tests
+ *
+ * These tests use the actual WASM SessionModule with real crypto.
+ * No mocks - tests actual session establishment and message encryption.
+ */
+
+import { describe, it, expect, afterEach } from 'vitest';
+import { SessionStatus } from '../../src/assets/generated/wasm/gossip_wasm';
+import {
+  createTestSession,
+  createTestSessionPair,
+  cleanupTestSession,
+  TestSessionData,
+} from '../utils';
+
+describe('Real WASM Session', () => {
+  const sessionsToCleanup: TestSessionData[] = [];
+
+  afterEach(() => {
+    // Cleanup all sessions created during tests
+    sessionsToCleanup.forEach(cleanupTestSession);
+    sessionsToCleanup.length = 0;
+  });
+
+  it('should create a session with real WASM keys', async () => {
+    const sessionData = await createTestSession();
+    sessionsToCleanup.push(sessionData);
+
+    expect(sessionData.session.userId).toBeInstanceOf(Uint8Array);
+    expect(sessionData.session.userId.length).toBe(32);
+    expect(sessionData.session.userIdEncoded).toMatch(/^gossip1/);
+  });
+
+  it('should establish outgoing session between Alice and Bob', async () => {
+    const { alice, bob } = await createTestSessionPair();
+    sessionsToCleanup.push(alice, bob);
+
+    // Alice establishes outgoing session to Bob
+    const announcement = await alice.session.establishOutgoingSession(
+      bob.session.ourPk
+    );
+
+    expect(announcement).toBeInstanceOf(Uint8Array);
+    expect(announcement.length).toBeGreaterThan(0);
+
+    // Alice should now have Bob as a peer with SelfRequested status
+    const alicePeers = alice.session.peerList();
+    expect(alicePeers.length).toBe(1);
+
+    const bobStatus = alice.session.peerSessionStatus(bob.session.userId);
+    expect(bobStatus).toBe(SessionStatus.SelfRequested);
+  });
+
+  it('should complete full session handshake', async () => {
+    const { alice, bob } = await createTestSessionPair();
+    sessionsToCleanup.push(alice, bob);
+
+    // Alice creates announcement for Bob
+    const aliceAnnouncement = await alice.session.establishOutgoingSession(
+      bob.session.ourPk
+    );
+
+    // Bob receives and processes Alice's announcement
+    const announcementResult =
+      await bob.session.feedIncomingAnnouncement(aliceAnnouncement);
+
+    expect(announcementResult).toBeDefined();
+    expect(announcementResult?.announcer_public_keys).toBeDefined();
+
+    // Bob should now have Alice as a peer with PeerRequested status
+    const aliceStatusFromBob = bob.session.peerSessionStatus(
+      alice.session.userId
+    );
+    expect(aliceStatusFromBob).toBe(SessionStatus.PeerRequested);
+
+    // Bob accepts by establishing outgoing session to Alice
+    const bobAnnouncement = await bob.session.establishOutgoingSession(
+      alice.session.ourPk
+    );
+
+    // Alice receives Bob's acceptance announcement
+    const bobAnnouncementResult =
+      await alice.session.feedIncomingAnnouncement(bobAnnouncement);
+
+    expect(bobAnnouncementResult).toBeDefined();
+
+    // Both should now have Active sessions
+    const aliceStatusOfBob = alice.session.peerSessionStatus(
+      bob.session.userId
+    );
+    const bobStatusOfAlice = bob.session.peerSessionStatus(
+      alice.session.userId
+    );
+
+    expect(aliceStatusOfBob).toBe(SessionStatus.Active);
+    expect(bobStatusOfAlice).toBe(SessionStatus.Active);
+  });
+
+  it('should include user data in announcement', async () => {
+    const { alice, bob } = await createTestSessionPair();
+    sessionsToCleanup.push(alice, bob);
+
+    // Alice sends announcement with custom user data
+    const userData = new TextEncoder().encode(
+      JSON.stringify({ u: 'Alice', m: 'Hello!' })
+    );
+    const announcement = await alice.session.establishOutgoingSession(
+      bob.session.ourPk,
+      userData
+    );
+
+    // Bob processes and extracts user data
+    const result = await bob.session.feedIncomingAnnouncement(announcement);
+
+    expect(result).toBeDefined();
+    expect(result?.user_data).toBeInstanceOf(Uint8Array);
+
+    const parsedUserData = JSON.parse(
+      new TextDecoder().decode(result?.user_data)
+    );
+    expect(parsedUserData.u).toBe('Alice');
+    expect(parsedUserData.m).toBe('Hello!');
+  });
+
+  it('should get message board read keys (seekers)', async () => {
+    const { alice, bob } = await createTestSessionPair();
+    sessionsToCleanup.push(alice, bob);
+
+    // Establish session
+    const aliceAnnouncement = await alice.session.establishOutgoingSession(
+      bob.session.ourPk
+    );
+    await bob.session.feedIncomingAnnouncement(aliceAnnouncement);
+
+    const bobAnnouncement = await bob.session.establishOutgoingSession(
+      alice.session.ourPk
+    );
+    await alice.session.feedIncomingAnnouncement(bobAnnouncement);
+
+    // Both should have seekers to monitor
+    const aliceSeekers = alice.session.getMessageBoardReadKeys();
+    const bobSeekers = bob.session.getMessageBoardReadKeys();
+
+    expect(aliceSeekers.length).toBeGreaterThan(0);
+    expect(bobSeekers.length).toBeGreaterThan(0);
+
+    // Each seeker should be a valid key
+    aliceSeekers.forEach(seeker => {
+      expect(seeker).toBeInstanceOf(Uint8Array);
+      expect(seeker.length).toBeGreaterThan(0);
+    });
+  });
+
+  it('should send and receive encrypted messages', async () => {
+    const { alice, bob } = await createTestSessionPair();
+    sessionsToCleanup.push(alice, bob);
+
+    // Establish session (Alice initiates, Bob accepts)
+    const aliceAnnouncement = await alice.session.establishOutgoingSession(
+      bob.session.ourPk
+    );
+    await bob.session.feedIncomingAnnouncement(aliceAnnouncement);
+
+    const bobAnnouncement = await bob.session.establishOutgoingSession(
+      alice.session.ourPk
+    );
+    await alice.session.feedIncomingAnnouncement(bobAnnouncement);
+
+    // Both sessions should be active
+    expect(alice.session.peerSessionStatus(bob.session.userId)).toBe(
+      SessionStatus.Active
+    );
+    expect(bob.session.peerSessionStatus(alice.session.userId)).toBe(
+      SessionStatus.Active
+    );
+
+    // Alice sends a message to Bob
+    const messageContent = new TextEncoder().encode('Hello Bob!');
+    const sendResult = await alice.session.sendMessage(
+      bob.session.userId,
+      messageContent
+    );
+
+    expect(sendResult).toBeDefined();
+    expect(sendResult?.seeker).toBeInstanceOf(Uint8Array);
+    expect(sendResult?.data).toBeInstanceOf(Uint8Array);
+
+    // Bob receives and decrypts the message
+    const receiveResult = await bob.session.feedIncomingMessageBoardRead(
+      sendResult!.seeker,
+      sendResult!.data
+    );
+
+    expect(receiveResult).toBeDefined();
+
+    // The plaintext should contain the original message
+    if (receiveResult?.plaintext) {
+      const decryptedMessage = new TextDecoder().decode(
+        receiveResult.plaintext
+      );
+      expect(decryptedMessage).toBe('Hello Bob!');
+    }
+  });
+
+  it('should discard peer session', async () => {
+    const { alice, bob } = await createTestSessionPair();
+    sessionsToCleanup.push(alice, bob);
+
+    // Alice establishes session
+    await alice.session.establishOutgoingSession(bob.session.ourPk);
+
+    expect(alice.session.peerList().length).toBe(1);
+
+    // Alice discards Bob
+    await alice.session.peerDiscard(bob.session.userId);
+
+    // Bob should no longer be in peer list (or status should be Killed)
+    const statusAfterDiscard = alice.session.peerSessionStatus(
+      bob.session.userId
+    );
+    expect(
+      statusAfterDiscard === SessionStatus.Killed ||
+        statusAfterDiscard === SessionStatus.UnknownPeer
+    ).toBe(true);
+  });
+});

package/test/setup.ts

@@ -0,0 +1,52 @@
+/**
+ * SDK Test Setup File
+ *
+ * Minimal environment setup for SDK tests:
+ * - fake-indexeddb for Dexie/IndexedDB in Node
+ * - IDBKeyRange polyfill
+ * - Shared database cleanup
+ */
+
+import 'fake-indexeddb/auto';
+import { IDBKeyRange } from 'fake-indexeddb';
+import { afterAll, beforeAll, beforeEach } from 'vitest';
+import { db } from '../src/db';
+
+if (typeof process !== 'undefined') {
+  process.env.GOSSIP_API_URL = 'https://api.usegossip.com';
+  process.env.VITE_GOSSIP_API_URL = 'https://api.usegossip.com';
+}
+
+if (typeof globalThis.IDBKeyRange === 'undefined') {
+  (globalThis as { IDBKeyRange?: typeof IDBKeyRange }).IDBKeyRange =
+    IDBKeyRange;
+}
+
+async function clearDatabase(): Promise<void> {
+  await Promise.all(db.tables.map(table => table.clear()));
+}
+
+beforeAll(async () => {
+  if (!db.isOpen()) {
+    await db.open();
+  }
+  await clearDatabase();
+});
+
+beforeEach(async () => {
+  if (!db.isOpen()) {
+    await db.open();
+  }
+  await clearDatabase();
+});
+
+afterAll(async () => {
+  try {
+    await clearDatabase();
+    await db.close();
+  } catch (_) {
+    // Ignore errors - database might already be closed
+  }
+});
+
+console.log('SDK test setup complete: fake-indexeddb initialized');

package/test/utils/contacts.spec.ts

@@ -0,0 +1,156 @@
+/**
+ * Contacts utilities tests
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  db,
+  DiscussionDirection,
+  DiscussionStatus,
+  MessageType,
+  MessageDirection,
+  MessageStatus,
+} from '../../src/db';
+import { encodeUserId } from '../../src/utils/userId';
+import { addContact, getContact, getContacts } from '../../src/contacts';
+import { updateContactName, deleteContact } from '../../src/utils/contacts';
+import type { SessionModule } from '../../src/wasm/session';
+import type { UserPublicKeys as UserPublicKeysType } from '../../src/assets/generated/wasm/gossip_wasm';
+
+const CONTACTS_OWNER_USER_ID = encodeUserId(new Uint8Array(32).fill(1));
+const CONTACTS_CONTACT_USER_ID = encodeUserId(new Uint8Array(32).fill(2));
+const CONTACTS_CONTACT_USER_ID_2 = encodeUserId(new Uint8Array(32).fill(3));
+
+const publicKeys = {
+  to_bytes: () => new Uint8Array([1, 2, 3]),
+} as unknown as UserPublicKeysType;
+
+const fakeSession = {
+  peerDiscard: vi.fn(),
+} as unknown as SessionModule;
+
+describe('Contacts utilities', () => {
+  beforeEach(async () => {
+    if (!db.isOpen()) {
+      await db.open();
+    }
+    await Promise.all(db.tables.map(table => table.clear()));
+  });
+
+  it('adds and fetches a contact', async () => {
+    const result = await addContact(
+      CONTACTS_OWNER_USER_ID,
+      CONTACTS_CONTACT_USER_ID,
+      'Alice',
+      publicKeys,
+      db
+    );
+    expect(result.success).toBe(true);
+
+    const contact = await getContact(
+      CONTACTS_OWNER_USER_ID,
+      CONTACTS_CONTACT_USER_ID,
+      db
+    );
+    expect(contact?.name).toBe('Alice');
+  });
+
+  it('returns error when contact already exists', async () => {
+    await addContact(
+      CONTACTS_OWNER_USER_ID,
+      CONTACTS_CONTACT_USER_ID,
+      'Alice',
+      publicKeys,
+      db
+    );
+    const result = await addContact(
+      CONTACTS_OWNER_USER_ID,
+      CONTACTS_CONTACT_USER_ID,
+      'Alice 2',
+      publicKeys,
+      db
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('exists');
+  });
+
+  it('updates contact name and rejects duplicates', async () => {
+    await addContact(
+      CONTACTS_OWNER_USER_ID,
+      CONTACTS_CONTACT_USER_ID,
+      'Alice',
+      publicKeys,
+      db
+    );
+    await addContact(
+      CONTACTS_OWNER_USER_ID,
+      CONTACTS_CONTACT_USER_ID_2,
+      'Bob',
+      publicKeys,
+      db
+    );
+
+    const updateResult = await updateContactName(
+      CONTACTS_OWNER_USER_ID,
+      CONTACTS_CONTACT_USER_ID,
+      'Alice Updated',
+      db
+    );
+    expect(updateResult.success).toBe(true);
+
+    const duplicateResult = await updateContactName(
+      CONTACTS_OWNER_USER_ID,
+      CONTACTS_CONTACT_USER_ID,
+      'Bob',
+      db
+    );
+    expect(duplicateResult.success).toBe(false);
+    if (!duplicateResult.success) {
+      expect(duplicateResult.reason).toBe('duplicate');
+    }
+  });
+
+  it('deletes contact and related data', async () => {
+    await addContact(
+      CONTACTS_OWNER_USER_ID,
+      CONTACTS_CONTACT_USER_ID,
+      'Alice',
+      publicKeys,
+      db
+    );
+
+    await db.discussions.add({
+      ownerUserId: CONTACTS_OWNER_USER_ID,
+      contactUserId: CONTACTS_CONTACT_USER_ID,
+      direction: DiscussionDirection.INITIATED,
+      status: DiscussionStatus.ACTIVE,
+      unreadCount: 0,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await db.messages.add({
+      ownerUserId: CONTACTS_OWNER_USER_ID,
+      contactUserId: CONTACTS_CONTACT_USER_ID,
+      content: 'Hello',
+      type: MessageType.TEXT,
+      direction: MessageDirection.OUTGOING,
+      status: MessageStatus.SENT,
+      timestamp: new Date(),
+    });
+
+    const result = await deleteContact(
+      CONTACTS_OWNER_USER_ID,
+      CONTACTS_CONTACT_USER_ID,
+      db,
+      fakeSession
+    );
+
+    expect(result.success).toBe(true);
+    expect(fakeSession.peerDiscard).toHaveBeenCalled();
+
+    const contacts = await getContacts(CONTACTS_OWNER_USER_ID, db);
+    expect(contacts.length).toBe(0);
+  });
+});

package/test/utils/discussions.spec.ts

@@ -0,0 +1,66 @@
+/**
+ * Discussion utilities tests
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { db, DiscussionDirection, DiscussionStatus } from '../../src/db';
+import { encodeUserId } from '../../src/utils/userId';
+import { updateDiscussionName } from '../../src/utils/discussions';
+
+const OWNER_USER_ID = encodeUserId(new Uint8Array(32).fill(6));
+const CONTACT_USER_ID = encodeUserId(new Uint8Array(32).fill(7));
+
+describe('Discussion utilities', () => {
+  beforeEach(async () => {
+    if (!db.isOpen()) {
+      await db.open();
+    }
+    await Promise.all(db.tables.map(table => table.clear()));
+  });
+
+  it('updates the custom discussion name', async () => {
+    const discussionId = await db.discussions.add({
+      ownerUserId: OWNER_USER_ID,
+      contactUserId: CONTACT_USER_ID,
+      direction: DiscussionDirection.INITIATED,
+      status: DiscussionStatus.ACTIVE,
+      unreadCount: 0,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    const result = await updateDiscussionName(discussionId, 'Custom Name', db);
+
+    expect(result.success).toBe(true);
+    const discussion = await db.discussions.get(discussionId);
+    expect(discussion?.customName).toBe('Custom Name');
+  });
+
+  it('clears the custom name when empty', async () => {
+    const discussionId = await db.discussions.add({
+      ownerUserId: OWNER_USER_ID,
+      contactUserId: CONTACT_USER_ID,
+      direction: DiscussionDirection.INITIATED,
+      status: DiscussionStatus.ACTIVE,
+      customName: 'Old Name',
+      unreadCount: 0,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    const result = await updateDiscussionName(discussionId, '  ', db);
+
+    expect(result.success).toBe(true);
+    const discussion = await db.discussions.get(discussionId);
+    expect(discussion?.customName).toBeUndefined();
+  });
+
+  it('returns not_found for unknown discussion', async () => {
+    const result = await updateDiscussionName(99999, 'Name', db);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.reason).toBe('not_found');
+    }
+  });
+});

package/test/utils/queue.spec.ts

@@ -0,0 +1,52 @@
+/**
+ * Queue utilities tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { PromiseQueue, QueueManager } from '../../src/utils/queue';
+
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+describe('PromiseQueue', () => {
+  it('executes tasks sequentially', async () => {
+    const queue = new PromiseQueue();
+    const order: string[] = [];
+
+    queue.enqueue(async () => {
+      order.push('first-start');
+      await sleep(20);
+      order.push('first-end');
+    });
+
+    queue.enqueue(async () => {
+      order.push('second');
+    });
+
+    await sleep(50);
+    expect(order).toEqual(['first-start', 'first-end', 'second']);
+  });
+});
+
+describe('QueueManager', () => {
+  it('queues tasks per key independently', async () => {
+    const manager = new QueueManager();
+    const order: string[] = [];
+
+    manager.enqueue('a', async () => {
+      order.push('a-1-start');
+      await sleep(30);
+      order.push('a-1-end');
+    });
+
+    manager.enqueue('b', async () => {
+      order.push('b-1');
+    });
+
+    manager.enqueue('a', async () => {
+      order.push('a-2');
+    });
+
+    await sleep(70);
+    expect(order).toEqual(['a-1-start', 'b-1', 'a-1-end', 'a-2']);
+  });
+});

package/test/utils/serialization.spec.ts

@@ -0,0 +1,120 @@
+/**
+ * Message serialization utilities tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { MessageType } from '../../src/db';
+import {
+  serializeRegularMessage,
+  serializeReplyMessage,
+  serializeForwardMessage,
+  serializeKeepAliveMessage,
+  deserializeMessage,
+  MESSAGE_TYPE_KEEP_ALIVE,
+} from '../../src/utils/messageSerialization';
+
+const serializationSeeker = new Uint8Array(34).fill(4);
+
+describe('message serialization', () => {
+  it('serializes and deserializes regular messages', () => {
+    const serialized = serializeRegularMessage('hello');
+    const deserialized = deserializeMessage(serialized);
+    expect(deserialized.content).toBe('hello');
+    expect(deserialized.type).toBe(MessageType.TEXT);
+  });
+
+  it('serializes and deserializes reply messages', () => {
+    const serialized = serializeReplyMessage('new', 'old', serializationSeeker);
+    const deserialized = deserializeMessage(serialized);
+    expect(deserialized.content).toBe('new');
+    expect(deserialized.replyTo?.originalContent).toBe('old');
+    expect(deserialized.replyTo?.originalSeeker).toEqual(serializationSeeker);
+  });
+
+  it('serializes and deserializes forward messages', () => {
+    const serialized = serializeForwardMessage(
+      'forward',
+      'note',
+      serializationSeeker
+    );
+    const deserialized = deserializeMessage(serialized);
+    expect(deserialized.content).toBe('note');
+    expect(deserialized.forwardOf?.originalContent).toBe('forward');
+    expect(deserialized.forwardOf?.originalSeeker).toEqual(serializationSeeker);
+  });
+
+  it('serializes keep-alive messages', () => {
+    const serialized = serializeKeepAliveMessage();
+    expect(serialized[0]).toBe(MESSAGE_TYPE_KEEP_ALIVE);
+    const deserialized = deserializeMessage(serialized);
+    expect(deserialized.type).toBe(MessageType.KEEP_ALIVE);
+  });
+
+  it('serializes reply with empty original content', () => {
+    const serialized = serializeReplyMessage('reply', '', serializationSeeker);
+    const deserialized = deserializeMessage(serialized);
+    expect(deserialized.replyTo?.originalContent).toBe('');
+    expect(deserialized.content).toBe('reply');
+  });
+
+  it('serializes reply with unicode characters', () => {
+    const serialized = serializeReplyMessage(
+      'Reply with emoji ',
+      'Original with unicode ',
+      serializationSeeker
+    );
+    const deserialized = deserializeMessage(serialized);
+    expect(deserialized.content).toBe('Reply with emoji ');
+    expect(deserialized.replyTo?.originalContent).toBe(
+      'Original with unicode '
+    );
+  });
+
+  it('serializes forward without additional content', () => {
+    const serialized = serializeForwardMessage(
+      'Just forwarding this',
+      '',
+      serializationSeeker
+    );
+    const deserialized = deserializeMessage(serialized);
+    expect(deserialized.content).toBe('');
+    expect(deserialized.forwardOf?.originalContent).toBe(
+      'Just forwarding this'
+    );
+  });
+});
+
+describe('Deserialization Failure Handling', () => {
+  it('should handle invalid message format gracefully', () => {
+    const invalidData = new Uint8Array([0, 1]);
+
+    try {
+      const result = deserializeMessage(invalidData);
+      expect(result).toBeDefined();
+    } catch {
+      expect(true).toBe(true);
+    }
+  });
+
+  it('should handle corrupted message bytes', () => {
+    const corruptedData = new Uint8Array([0, 255, 255, 255, 255, 0, 0, 0, 0]);
+
+    try {
+      const result = deserializeMessage(corruptedData);
+      expect(result).toBeDefined();
+    } catch {
+      expect(true).toBe(true);
+    }
+  });
+
+  it('should handle empty message data', () => {
+    const emptyData = new Uint8Array(0);
+
+    try {
+      const result = deserializeMessage(emptyData);
+      expect(result.content).toBe('');
+    } catch {
+      expect(true).toBe(true);
+    }
+  });
+});