@massalabs/gossip-sdk 0.0.2-dev.20260128094509 → 0.0.2-dev.20260128160824

package/test/utils/userId.spec.ts

@@ -1,120 +0,0 @@
-/**
- * UserId utilities tests
- */
-
-import { describe, it, expect, beforeAll } from 'vitest';
-import {
-  encodeUserId,
-  decodeUserId,
-  isValidUserId,
-  formatUserId,
-  generate as generateUserId,
-} from '../../src/utils/userId';
-import { bech32 } from '@scure/base';
-import { ensureWasmInitialized } from '../../src/wasm/loader';
-
-describe('userId utils', () => {
-  describe('encodeUserId / decodeUserId', () => {
-    it('encodes and decodes a 32-byte userId', () => {
-      const bytes = new Uint8Array(32).fill(7);
-      const encoded = encodeUserId(bytes);
-      const decoded = decodeUserId(encoded);
-      expect(decoded).toEqual(bytes);
-    });
-
-    it('throws on invalid length', () => {
-      expect(() => encodeUserId(new Uint8Array(31))).toThrow(
-        'User ID must be exactly 32 bytes'
-      );
-      expect(() => encodeUserId(new Uint8Array(64))).toThrow(
-        'User ID must be exactly 32 bytes'
-      );
-    });
-
-    it('throws on invalid prefix', () => {
-      const bytes = new Uint8Array(32).fill(8);
-      const invalid = bech32.encode('wrong', bech32.toWords(bytes));
-      expect(() => decodeUserId(invalid)).toThrow('Invalid prefix');
-    });
-  });
-
-  describe('isValidUserId', () => {
-    it('validates userId format', () => {
-      const encoded = encodeUserId(new Uint8Array(32).fill(1));
-      expect(isValidUserId(encoded)).toBe(true);
-      expect(isValidUserId('invalid')).toBe(false);
-      expect(isValidUserId('gossip1')).toBe(false);
-      expect(isValidUserId('not-a-gossip-id')).toBe(false);
-    });
-  });
-
-  describe('formatUserId', () => {
-    it('formats userId for display', () => {
-      const encoded = encodeUserId(new Uint8Array(32).fill(2));
-      const formatted = formatUserId(encoded, 4, 4);
-      expect(formatted.startsWith('gossip1')).toBe(true);
-      expect(formatted.includes('...')).toBe(true);
-    });
-  });
-});
-
-describe('userId utils (generate)', () => {
-  beforeAll(async () => {
-    await ensureWasmInitialized();
-  });
-
-  it('should generate a valid userId without password', async () => {
-    const userId = await generateUserId();
-
-    expect(userId).toBeTruthy();
-    expect(typeof userId).toBe('string');
-    expect(userId.startsWith('gossip1')).toBe(true);
-    expect(isValidUserId(userId)).toBe(true);
-  });
-
-  it('should generate a valid userId with password', async () => {
-    const userId = await generateUserId('mypassword123');
-
-    expect(userId).toBeTruthy();
-    expect(typeof userId).toBe('string');
-    expect(userId.startsWith('gossip1')).toBe(true);
-    expect(isValidUserId(userId)).toBe(true);
-  });
-
-  it('should generate same userId when called without password (deterministic)', async () => {
-    const userId1 = await generateUserId();
-    const userId2 = await generateUserId();
-
-    expect(userId1).toBe(userId2);
-  });
-
-  it('should generate userId that can be decoded', async () => {
-    const userId = await generateUserId();
-    const decoded = decodeUserId(userId);
-
-    expect(decoded).toBeInstanceOf(Uint8Array);
-    expect(decoded.length).toBe(32);
-  });
-
-  it('should generate different userIds with different passwords', async () => {
-    const userId1 = await generateUserId('password1');
-    const userId2 = await generateUserId('password2');
-
-    expect(userId1).not.toBe(userId2);
-  });
-
-  it('should handle empty string password', async () => {
-    const userId = await generateUserId('');
-
-    expect(userId).toBeTruthy();
-    expect(isValidUserId(userId)).toBe(true);
-  });
-
-  it('should generate valid 32-byte decoded ids', async () => {
-    for (let i = 0; i < 5; i++) {
-      const userId = await generateUserId();
-      const decoded = decodeUserId(userId);
-      expect(decoded.length).toBe(32);
-    }
-  });
-});

package/test/utils/validation.spec.ts

@@ -1,223 +0,0 @@
-/**
- * Validation utilities tests
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { db } from '../../src/db';
-import { encodeUserId } from '../../src/utils/userId';
-import {
-  validatePassword,
-  validateUsernameFormat,
-  validateUsernameAvailability,
-  validateUsernameFormatAndAvailability,
-  validateUserIdFormat,
-} from '../../src/utils/validation';
-
-const VALIDATION_OWNER_USER_ID = encodeUserId(new Uint8Array(32).fill(13));
-
-describe('validation utilities', () => {
-  beforeEach(async () => {
-    if (!db.isOpen()) {
-      await db.open();
-    }
-    await Promise.all(db.tables.map(table => table.clear()));
-  });
-
-  describe('validatePassword', () => {
-    it('should reject empty password', () => {
-      const result = validatePassword('');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('Password is required');
-    });
-
-    it('should reject password with only whitespace', () => {
-      const result = validatePassword('   ');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('Password is required');
-    });
-
-    it('should reject password shorter than 8 characters', () => {
-      const result = validatePassword('short');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('Password must be at least 8 characters long');
-    });
-
-    it('should accept password with exactly 8 characters', () => {
-      const result = validatePassword('12345678');
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should accept valid password', () => {
-      const result = validatePassword('validPassword123');
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should accept password with special characters', () => {
-      const result = validatePassword('P@ssw0rd!#$%');
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should accept very long password', () => {
-      const result = validatePassword('a'.repeat(100));
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-  });
-
-  describe('validateUsernameFormat', () => {
-    it('should reject empty username', () => {
-      const result = validateUsernameFormat('');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('Username is required');
-    });
-
-    it('should reject username with only whitespace', () => {
-      const result = validateUsernameFormat('   ');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('Username is required');
-    });
-
-    it('should reject username shorter than 3 characters', () => {
-      const result = validateUsernameFormat('ab');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('Username must be at least 3 characters long');
-    });
-
-    it('should reject username shorter than 3 characters after trimming', () => {
-      const result = validateUsernameFormat('  ab  ');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('Username must be at least 3 characters long');
-    });
-
-    it('should accept username with exactly 3 characters', () => {
-      const result = validateUsernameFormat('abc');
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should accept valid username', () => {
-      const result = validateUsernameFormat('validUser');
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should accept username with numbers', () => {
-      const result = validateUsernameFormat('user123');
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should accept username with special characters', () => {
-      const result = validateUsernameFormat('user_name-123');
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should handle username with leading/trailing whitespace', () => {
-      const result = validateUsernameFormat('  user  ');
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should reject username with internal spaces', () => {
-      const result = validateUsernameFormat('user name');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe('Username cannot contain spaces');
-    });
-  });
-
-  describe('validateUsernameAvailability', () => {
-    it('checks username availability case-insensitively', async () => {
-      await db.userProfile.put({
-        userId: VALIDATION_OWNER_USER_ID,
-        username: 'Alice',
-        security: {
-          encKeySalt: new Uint8Array(),
-          authMethod: 'password',
-          mnemonicBackup: {
-            encryptedMnemonic: new Uint8Array(),
-            createdAt: new Date(),
-            backedUp: false,
-          },
-        },
-        session: new Uint8Array(),
-        status: 'online',
-        lastSeen: new Date(),
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      });
-
-      const result = await validateUsernameAvailability('alice', db);
-      expect(result.valid).toBe(false);
-    });
-  });
-
-  describe('validateUsernameFormatAndAvailability', () => {
-    it('validates username format and availability', async () => {
-      const invalid = await validateUsernameFormatAndAvailability('ab', db);
-      expect(invalid.valid).toBe(false);
-
-      const valid = await validateUsernameFormatAndAvailability(
-        'validname',
-        db
-      );
-      expect(valid.valid).toBe(true);
-    });
-  });
-
-  describe('validateUserIdFormat', () => {
-    const invalidUserIdMessage = 'Invalid format — must be a valid user ID';
-
-    it('should reject empty userId', () => {
-      const result = validateUserIdFormat('');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe(invalidUserIdMessage);
-    });
-
-    it('should reject userId with invalid format', () => {
-      const result = validateUserIdFormat('invalid');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe(invalidUserIdMessage);
-    });
-
-    it('should reject userId with wrong prefix', () => {
-      const result = validateUserIdFormat(
-        'bitcoin1qpzry9x8gf2tvdw0s3jn54khce6mua7l'
-      );
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe(invalidUserIdMessage);
-    });
-
-    it('should reject userId with invalid checksum', () => {
-      const result = validateUserIdFormat('gossip1invalid');
-      expect(result.valid).toBe(false);
-      expect(result.error).toBe(invalidUserIdMessage);
-    });
-
-    it('should accept valid userId', () => {
-      const validUserId = encodeUserId(new Uint8Array(32).fill(1));
-      const result = validateUserIdFormat(validUserId);
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should handle userId with whitespace', () => {
-      const validUserId = encodeUserId(new Uint8Array(32).fill(1));
-      const result = validateUserIdFormat(`  ${validUserId}  `);
-      expect(result.valid).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should accept multiple different valid userIds', () => {
-      for (let i = 0; i < 5; i++) {
-        const userId = encodeUserId(new Uint8Array(32).fill(i));
-        const result = validateUserIdFormat(userId);
-        expect(result.valid).toBe(true);
-        expect(result.error).toBeUndefined();
-      }
-    });
-  });
-});

package/test/utils.ts

@@ -1,212 +0,0 @@
-/**
- * SDK Test Utilities
- *
- * Helper functions for creating test data and utilities.
- * Uses real WASM SessionModule - no mocks needed.
- */
-
-import type { Contact, Discussion, Message, UserProfile } from '../src/db';
-import {
-  UserPublicKeys,
-  UserKeys,
-} from '../src/assets/generated/wasm/gossip_wasm';
-import { generateUserKeys } from '../src/wasm/userKeys';
-import { SessionModule } from '../src/wasm/session';
-import {
-  MessageType,
-  MessageDirection,
-  MessageStatus,
-  DiscussionStatus,
-  DiscussionDirection,
-} from '../src/db';
-
-/**
- * Create a test contact object (without id).
- */
-export function createTestContact(
-  ownerUserId: string,
-  userId: string,
-  name: string,
-  publicKeys: UserPublicKeys
-): Omit<Contact, 'id'> {
-  return {
-    ownerUserId,
-    userId,
-    name,
-    publicKeys: publicKeys.to_bytes(),
-    isOnline: false,
-    lastSeen: new Date(),
-    createdAt: new Date(),
-  };
-}
-
-/**
- * Create a test discussion object (without id).
- */
-export function createTestDiscussion(
-  ownerUserId: string,
-  contactUserId: string,
-  status: DiscussionStatus = DiscussionStatus.ACTIVE,
-  direction: DiscussionDirection = DiscussionDirection.INITIATED
-): Omit<Discussion, 'id'> {
-  return {
-    ownerUserId,
-    contactUserId,
-    direction,
-    status,
-    unreadCount: 0,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  };
-}
-
-/**
- * Create a test message object (without id).
- */
-export function createTestMessage(
-  ownerUserId: string,
-  contactUserId: string,
-  content: string,
-  direction: MessageDirection = MessageDirection.OUTGOING,
-  status: MessageStatus = MessageStatus.SENT
-): Omit<Message, 'id'> {
-  return {
-    ownerUserId,
-    contactUserId,
-    content,
-    type: MessageType.TEXT,
-    direction,
-    status,
-    timestamp: new Date(),
-  };
-}
-
-/**
- * Create a test user profile object (without session).
- */
-export function createTestUserProfile(
-  userId: string,
-  username: string
-): Omit<UserProfile, 'session'> {
-  return {
-    userId,
-    username,
-    security: {
-      encKeySalt: new Uint8Array(32),
-      authMethod: 'password',
-      mnemonicBackup: {
-        encryptedMnemonic: new Uint8Array(64),
-        createdAt: new Date(),
-        backedUp: false,
-      },
-    },
-    status: 'online',
-    lastSeen: new Date(),
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  };
-}
-
-/**
- * Wait for a condition to be true.
- */
-export function waitFor(
-  condition: () => boolean,
-  timeout = 5000,
-  interval = 100
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const startTime = Date.now();
-    const check = () => {
-      if (condition()) {
-        resolve();
-      } else if (Date.now() - startTime > timeout) {
-        reject(new Error('Timeout waiting for condition'));
-      } else {
-        setTimeout(check, interval);
-      }
-    };
-    check();
-  });
-}
-
-/**
- * Wait for a specified number of milliseconds.
- */
-export function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-/**
- * Test session data structure returned by createTestSession.
- */
-export interface TestSessionData {
-  session: SessionModule;
-  userKeys: UserKeys;
-}
-
-/**
- * Create a real SessionModule using WASM.
- * This creates a fully functional session with real crypto.
- *
- * @param passphrase - Optional passphrase for key generation (defaults to random)
- * @param onPersist - Optional persistence callback
- * @returns Object containing session and userKeys (remember to call cleanupTestSession when done)
- */
-export async function createTestSession(
-  passphrase?: string,
-  onPersist?: () => Promise<void>
-): Promise<TestSessionData> {
-  const finalPassphrase =
-    passphrase ?? `test-passphrase-${Date.now()}-${Math.random()}`;
-  const userKeys = await generateUserKeys(finalPassphrase);
-
-  if (!userKeys) {
-    throw new Error('Failed to generate user keys for test session');
-  }
-
-  const session = new SessionModule(userKeys, onPersist);
-  return { session, userKeys };
-}
-
-/**
- * Create a pair of test sessions (e.g., Alice and Bob) for e2e testing.
- * Both sessions use real WASM crypto.
- *
- * @returns Object containing both sessions and their keys
- */
-export async function createTestSessionPair(): Promise<{
-  alice: TestSessionData;
-  bob: TestSessionData;
-}> {
-  const [alice, bob] = await Promise.all([
-    createTestSession(`alice-test-key-${Date.now()}`),
-    createTestSession(`bob-test-key-${Date.now()}`),
-  ]);
-
-  return { alice, bob };
-}
-
-/**
- * Helper to cleanup test sessions and free WASM memory.
- * Call this in afterEach/afterAll.
- */
-export function cleanupTestSession(sessionData: TestSessionData): void {
-  try {
-    sessionData.session.cleanup();
-  } catch {
-    // Session might already be cleaned up
-  }
-  try {
-    sessionData.userKeys.free();
-  } catch {
-    // Keys might already be freed
-  }
-}
-
-/**
- * Helper to cleanup multiple test sessions.
- */
-export function cleanupTestSessions(sessions: TestSessionData[]): void {
-  sessions.forEach(cleanupTestSession);
-}

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "lib": ["ES2020", "DOM"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "isolatedModules": true,
-    "moduleDetection": "force",
-    "noEmit": false,
-    "declaration": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "types": ["vite/client"]
-  },
-  "include": ["src"]
-}

package/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./src/contacts.ts","./src/db.ts","./src/gossipsdk.ts","./src/index.ts","./src/types.ts","./src/utils.ts","./src/api/messageprotocol/index.ts","./src/api/messageprotocol/mock.ts","./src/api/messageprotocol/rest.ts","./src/api/messageprotocol/types.ts","./src/assets/generated/wasm/gossip_wasm.d.ts","./src/assets/generated/wasm/gossip_wasm_bg.wasm.d.ts","./src/config/protocol.ts","./src/config/sdk.ts","./src/core/sdkeventemitter.ts","./src/core/sdkpolling.ts","./src/core/index.ts","./src/crypto/bip39.ts","./src/crypto/encryption.ts","./src/services/announcement.ts","./src/services/auth.ts","./src/services/discussion.ts","./src/services/message.ts","./src/services/refresh.ts","./src/types/events.ts","./src/utils/base64.ts","./src/utils/contacts.ts","./src/utils/discussions.ts","./src/utils/logs.ts","./src/utils/messageserialization.ts","./src/utils/queue.ts","./src/utils/type.ts","./src/utils/userid.ts","./src/utils/validation.ts","./src/wasm/encryption.ts","./src/wasm/index.ts","./src/wasm/loader.ts","./src/wasm/session.ts","./src/wasm/userkeys.ts","./test/announcement-service.test.ts","./test/auth-service.test.ts","./test/auto-accept.test.ts","./test/contacts-utils.test.ts","./test/db-helpers.test.ts","./test/db-operations.test.ts","./test/db-simple.test.ts","./test/discussion-service.test.ts","./test/discussions-utils.test.ts","./test/edge-cases.test.ts","./test/gossip-sdk-lifecycle.test.ts","./test/helpers.ts","./test/high-priority-gaps.test.ts","./test/index.test.ts","./test/message-deduplication.test.ts","./test/message-serialization.test.ts","./test/message-service.test.ts","./test/protocol-config.test.ts","./test/queue-utils.test.ts","./test/refresh-service.test.ts","./test/sdk-config.test.ts","./test/sending-reset.test.ts","./test/session-persistence.test.ts","./test/setup.ts","./test/startup-recovery.test.ts","./test/user-id-utils.test.ts","./test/validation-utils.test.ts","./test/waiting-session-after-accept.test.ts","../src/vite-env.d.ts"],"errors":true,"version":"5.9.3"}

package/vitest.config.ts

@@ -1,28 +0,0 @@
-import { defineConfig } from 'vitest/config';
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    setupFiles: [resolve(__dirname, 'test/setup.ts')],
-    include: ['test/**/*.{test,spec}.{js,ts}'],
-    // Run tests sequentially to avoid database conflicts
-    isolate: false,
-    fileParallelism: false,
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'json', 'html'],
-      exclude: ['node_modules/', 'test/', '**/*.d.ts', '**/*.config.*'],
-    },
-  },
-  resolve: {
-    alias: {
-      '@': resolve(__dirname, 'src'),
-    },
-  },
-});