holosphere 2.0.0-alpha1 → 2.0.0-alpha4

package/tests/unit/contract/utils.test.js

@@ -1,159 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-describe('Contract: Utility Operations', () => {
-  let hs;
-
-  beforeEach(() => {
-    hs = new HoloSphere({ relays: [], appName: 'test-utils' });
-  });
-
-  describe('isValidH3()', () => {
-    it('should return true for valid H3 ID', () => {
-      expect(hs.isValidH3('8928342e20fffff')).toBe(true);
-    });
-
-    it('should return false for invalid string', () => {
-      expect(hs.isValidH3('invalid')).toBe(false);
-    });
-
-    it('should return false for non-string input', () => {
-      expect(hs.isValidH3(123)).toBe(false);
-      expect(hs.isValidH3(null)).toBe(false);
-      expect(hs.isValidH3(undefined)).toBe(false);
-      expect(hs.isValidH3({})).toBe(false);
-    });
-
-    it('should validate H3 format (starts with 8, at least 15 chars)', () => {
-      expect(hs.isValidH3('8a2a1072b59ffff')).toBe(true);
-      expect(hs.isValidH3('7a2a1072b59ffff')).toBe(false);
-      expect(hs.isValidH3('8a2a107')).toBe(false);
-    });
-  });
-
-  describe('metrics()', () => {
-    it('should return metrics object', () => {
-      const metrics = hs.metrics();
-      expect(typeof metrics).toBe('object');
-    });
-
-    it('should include writes count', () => {
-      const metrics = hs.metrics();
-      expect(metrics).toHaveProperty('writes');
-      expect(typeof metrics.writes).toBe('number');
-    });
-
-    it('should include reads count', () => {
-      const metrics = hs.metrics();
-      expect(metrics).toHaveProperty('reads');
-      expect(typeof metrics.reads).toBe('number');
-    });
-
-    it('should include subscriptions count', () => {
-      const metrics = hs.metrics();
-      expect(metrics).toHaveProperty('subscriptions');
-      expect(typeof metrics.subscriptions).toBe('number');
-    });
-
-    it('should include federations count', () => {
-      const metrics = hs.metrics();
-      expect(metrics).toHaveProperty('federations');
-      expect(typeof metrics.federations).toBe('number');
-    });
-
-    it('should include average write time', () => {
-      const metrics = hs.metrics();
-      expect(metrics).toHaveProperty('avgWriteTime');
-      expect(typeof metrics.avgWriteTime).toBe('number');
-    });
-
-    it('should include average read time', () => {
-      const metrics = hs.metrics();
-      expect(metrics).toHaveProperty('avgReadTime');
-      expect(typeof metrics.avgReadTime).toBe('number');
-    });
-
-    it('should update metrics after operations', async () => {
-      const holonId = await hs.toHolon(37.7749, -122.4194, 9);
-
-      const before = hs.metrics();
-
-      await hs.write(holonId, 'test', { id: 'test-1', value: 'data' });
-      await hs.read(holonId, 'test', 'test-1');
-
-      const after = hs.metrics();
-
-      expect(after.writes).toBeGreaterThanOrEqual(before.writes);
-      expect(after.reads).toBeGreaterThanOrEqual(before.reads);
-    });
-  });
-
-  describe('Error Types', () => {
-    it('should export ValidationError class', async () => {
-      try {
-        await hs.setSchema('test', 'invalid://schema', true);
-      } catch (err) {
-        expect(err.constructor.name).toBe('ValidationError');
-        expect(err).toHaveProperty('errors');
-        expect(Array.isArray(err.errors)).toBe(true);
-      }
-    });
-
-    it('should export AuthorizationError class', async () => {
-      const holonId = await hs.toHolon(37.7749, -122.4194, 9);
-
-      // Write data with an owner to trigger authorization check
-      await hs.write(holonId, 'test', {
-        id: 'others-data',
-        _creator: '04' + 'fedcba9876543210'.repeat(8) // Different owner
-      });
-
-      try {
-        await hs.delete(holonId, 'test', 'others-data');
-      } catch (err) {
-        expect(err.constructor.name).toBe('AuthorizationError');
-        expect(err).toHaveProperty('requiredPermission');
-      }
-    });
-
-    it('should export HolosphereError class', () => {
-      try {
-        new HoloSphere({ relays: [], appName: 123 });
-      } catch (err) {
-        expect(err.constructor.name).toMatch(/Error$/);
-      }
-    });
-
-    it('ValidationError should include validation details', async () => {
-      await hs.setSchema('test', 'test://schema', true);
-
-      try {
-        await hs.write(
-          await hs.toHolon(37.7749, -122.4194, 9),
-          'test',
-          { invalid: 'data' },
-          { strict: true }
-        );
-      } catch (err) {
-        expect(err.message).toBeTruthy();
-        expect(err.errors).toBeTruthy();
-      }
-    });
-
-    it('AuthorizationError should include required permission', async () => {
-      const holonId = await hs.toHolon(37.7749, -122.4194, 9);
-
-      // Write data with an owner to trigger authorization check
-      await hs.write(holonId, 'test', {
-        id: 'protected-data',
-        _creator: '04' + 'fedcba9876543210'.repeat(8) // Different owner
-      });
-
-      try {
-        await hs.delete(holonId, 'test', 'protected-data');
-      } catch (err) {
-        expect(err.requiredPermission).toBe('delete');
-      }
-    });
-  });
-});

package/tests/unit/core.test.js

@@ -1,152 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import HoloSphere from '../../src/index.js';
-
-describe('Unit: Core Module', () => {
-  describe('HoloSphere class initialization', () => {
-    it('should initialize with default config', () => {
-      const hs = new HoloSphere({ relays: [] });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-
-    it('should initialize with custom appName', () => {
-      const hs = new HoloSphere({ relays: [], appName: 'custom-app' });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-
-    it('should initialize with custom peers array', () => {
-      const hs = new HoloSphere({
-        appName: 'test',
-        peers: ['https://relay1.com/gun', 'https://relay2.com/gun']
-      });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-
-    it('should initialize with radisk enabled', () => {
-      const hs = new HoloSphere({
-        appName: 'test',
-        radisk: true
-      });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-
-    it('should initialize with radisk config object', () => {
-      const hs = new HoloSphere({
-        appName: 'test',
-        radisk: { path: './test-data' }
-      });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-  });
-
-  describe('Config validation', () => {
-    it('should throw TypeError for invalid appName type', () => {
-      expect(() => new HoloSphere({ relays: [], appName: 123 })).toThrow(TypeError);
-      expect(() => new HoloSphere({ relays: [], appName: null })).toThrow(TypeError);
-      expect(() => new HoloSphere({ relays: [], appName: {} })).toThrow(TypeError);
-    });
-
-    it('should throw TypeError for invalid relays type', () => {
-      expect(() => new HoloSphere({ relays: 'not-an-array', appName: 'test' })).toThrow(TypeError);
-      expect(() => new HoloSphere({ relays: 123, appName: 'test' })).toThrow(TypeError);
-    });
-
-    it('should throw TypeError for invalid logLevel', () => {
-      expect(() => new HoloSphere({ logLevel: 'INVALID' })).toThrow(TypeError);
-      expect(() => new HoloSphere({ logLevel: 123 })).toThrow(TypeError);
-    });
-
-    it('should validate config defaults are applied', () => {
-      const hs = new HoloSphere({ relays: [] });
-      // Should use default appName, radisk: true, logLevel: 'WARN'
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-  });
-
-  describe('Nostr client creation', () => {
-    it('should create Nostr client instance internally', () => {
-      const hs = new HoloSphere({ relays: [], appName: 'test' });
-      // Internal client instance should exist
-      expect(hs).toHaveProperty('client');
-    });
-
-    it('should configure Nostr client with relays', () => {
-      const relays = ['wss://relay.example.com'];
-      const hs = new HoloSphere({ relays, appName: 'test' });
-      expect(hs).toBeInstanceOf(HoloSphere);
-      expect(hs.client.relays).toEqual(relays);
-    });
-
-    it('should accept empty relays array for testing', () => {
-      const hs = new HoloSphere({ relays: [], appName: 'test' });
-      expect(hs.client.relays).toEqual([]);
-    });
-  });
-
-  describe('Radisk adapter integration', () => {
-    it('should integrate radisk when enabled', () => {
-      const hs = new HoloSphere({
-        appName: 'test',
-        radisk: true
-      });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-
-    it('should accept radisk path configuration', () => {
-      const hs = new HoloSphere({
-        appName: 'test',
-        radisk: { path: './custom-path' }
-      });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-
-    it('should work without radisk when disabled', () => {
-      const hs = new HoloSphere({
-        appName: 'test',
-        radisk: false
-      });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-  });
-
-  describe('Log level configuration', () => {
-    it('should accept ERROR log level', () => {
-      const hs = new HoloSphere({ logLevel: 'ERROR' });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-
-    it('should accept WARN log level', () => {
-      const hs = new HoloSphere({ logLevel: 'WARN' });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-
-    it('should accept INFO log level', () => {
-      const hs = new HoloSphere({ logLevel: 'INFO' });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-
-    it('should accept DEBUG log level', () => {
-      const hs = new HoloSphere({ logLevel: 'DEBUG' });
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-
-    it('should use WARN as default log level', () => {
-      const hs = new HoloSphere({ relays: [] });
-      // Default should be WARN
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-  });
-
-  describe('App configuration storage', () => {
-    it('should store app configuration internally', () => {
-      const config = {
-        appName: 'test-app',
-        peers: ['https://relay.com/gun'],
-        logLevel: 'DEBUG'
-      };
-
-      const hs = new HoloSphere(config);
-      // Config should be accessible (implementation-specific)
-      expect(hs).toHaveProperty('config');
-    });
-  });
-});

package/tests/unit/crypto.test.js

@@ -1,328 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import HoloSphere from '../../src/index.js';
-import { getPublicKey } from '../../src/crypto/secp256k1.js';
-
-describe('Unit: Crypto Module', () => {
-  let hs;
-  let privateKey;
-  let publicKey;
-
-  beforeEach(async () => {
-    hs = new HoloSphere({ relays: [], appName: 'test-crypto-unit', relays: [] });
-    // Use valid secp256k1 keys - derive public key from private key
-    privateKey = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
-    publicKey = await getPublicKey(privateKey);
-  });
-
-  describe('secp256k1 signing and verification', () => {
-    it('should sign content with private key', async () => {
-      const content = { message: 'Test message' };
-      const signature = await hs.sign(content, privateKey);
-
-      expect(typeof signature).toBe('string');
-      expect(signature).toMatch(/^[0-9a-f]+$/);
-      expect(signature.length).toBeGreaterThan(0);
-    });
-
-    it('should verify valid signature', async () => {
-      const content = { message: 'Test message' };
-      const signature = await hs.sign(content, privateKey);
-
-      const isValid = await hs.verify(content, signature, publicKey);
-      expect(isValid).toBe(true);
-    });
-
-    it('should reject invalid signature', async () => {
-      const content = { message: 'Test message' };
-      const invalidSig = 'invalid-signature';
-
-      const isValid = await hs.verify(content, invalidSig, publicKey);
-      expect(isValid).toBe(false);
-    });
-
-    it('should reject tampered content', async () => {
-      const content = { message: 'Original message' };
-      const signature = await hs.sign(content, privateKey);
-
-      const tamperedContent = { message: 'Tampered message' };
-      const isValid = await hs.verify(tamperedContent, signature, publicKey);
-      expect(isValid).toBe(false);
-    });
-
-    it('should reject wrong public key', async () => {
-      const content = { message: 'Test message' };
-      const signature = await hs.sign(content, privateKey);
-
-      const wrongPublicKey = '04' + 'fedcba9876543210'.repeat(8);
-      const isValid = await hs.verify(content, signature, wrongPublicKey);
-      expect(isValid).toBe(false);
-    });
-
-    it('should handle string content', async () => {
-      const content = 'Plain string content';
-      const signature = await hs.sign(content, privateKey);
-
-      expect(typeof signature).toBe('string');
-
-      const isValid = await hs.verify(content, signature, publicKey);
-      expect(isValid).toBe(true);
-    });
-
-    it('should handle complex object content', async () => {
-      const content = {
-        nested: {
-          deep: {
-            object: 'value',
-            array: [1, 2, 3]
-          }
-        },
-        number: 42,
-        boolean: true
-      };
-
-      const signature = await hs.sign(content, privateKey);
-      const isValid = await hs.verify(content, signature, publicKey);
-      expect(isValid).toBe(true);
-    });
-  });
-
-  describe('Capability token generation', () => {
-    it('should generate capability token', async () => {
-      const token = await hs.issueCapability(
-        ['read', 'write'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey
-      );
-
-      expect(typeof token).toBe('string');
-      expect(token.length).toBeGreaterThan(0);
-    });
-
-    it('should include permissions in token', async () => {
-      const token = await hs.issueCapability(
-        ['read', 'write', 'delete'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey
-      );
-
-      // Token should encode permissions
-      expect(typeof token).toBe('string');
-    });
-
-    it('should include scope in token', async () => {
-      const token = await hs.issueCapability(
-        ['read'],
-        { holonId: '8928342e20fffff', lensName: 'specific-lens' },
-        publicKey
-      );
-
-      expect(typeof token).toBe('string');
-    });
-
-    it('should include recipient public key in token', async () => {
-      const recipientKey = '04' + 'abcdef0123456789'.repeat(8);
-      const token = await hs.issueCapability(
-        ['write'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        recipientKey
-      );
-
-      expect(typeof token).toBe('string');
-    });
-
-    it('should accept custom expiration time', async () => {
-      const token = await hs.issueCapability(
-        ['read'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey,
-        { expiresIn: 86400000 } // 24 hours
-      );
-
-      expect(typeof token).toBe('string');
-    });
-
-    it('should use issuer key when provided', async () => {
-      const token = await hs.issueCapability(
-        ['delete'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey,
-        { issuerKey: privateKey }
-      );
-
-      expect(typeof token).toBe('string');
-    });
-  });
-
-  describe('Token expiration validation', () => {
-    it('should validate non-expired token', async () => {
-      const token = await hs.issueCapability(
-        ['read'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey,
-        { expiresIn: 3600000 } // 1 hour
-      );
-
-      const isValid = await hs.verifyCapability(
-        token,
-        'read',
-        { holonId: '8928342e20fffff', lensName: 'test' }
-      );
-
-      expect(isValid).toBe(true);
-    });
-
-    it('should reject expired token', async () => {
-      const token = await hs.issueCapability(
-        ['read'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey,
-        { expiresIn: -1000 } // Already expired
-      );
-
-      const isValid = await hs.verifyCapability(
-        token,
-        'read',
-        { holonId: '8928342e20fffff', lensName: 'test' }
-      );
-
-      expect(isValid).toBe(false);
-    });
-
-    it('should validate token with sufficient time remaining', async () => {
-      const token = await hs.issueCapability(
-        ['write'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey,
-        { expiresIn: 7200000 } // 2 hours
-      );
-
-      const isValid = await hs.verifyCapability(
-        token,
-        'write',
-        { holonId: '8928342e20fffff', lensName: 'test' }
-      );
-
-      expect(isValid).toBe(true);
-    });
-  });
-
-  describe('Nonce uniqueness (replay protection)', () => {
-    it('should include unique nonce in each token', async () => {
-      const token1 = await hs.issueCapability(
-        ['read'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey
-      );
-
-      const token2 = await hs.issueCapability(
-        ['read'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey
-      );
-
-      // Tokens should be different due to unique nonces
-      expect(token1).not.toBe(token2);
-    });
-
-    it('should reject replayed token', async () => {
-      const token = await hs.issueCapability(
-        ['write'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey
-      );
-
-      // First use should succeed
-      const firstUse = await hs.verifyCapability(
-        token,
-        'write',
-        { holonId: '8928342e20fffff', lensName: 'test' }
-      );
-      expect(firstUse).toBe(true);
-
-      // Replay should be rejected (if nonce tracking implemented)
-      // This depends on implementation of replay protection
-    });
-  });
-
-  describe('Lazy initialization (module not loaded until first use)', () => {
-    it('should not load crypto module on HoloSphere initialization', () => {
-      const hs = new HoloSphere({ relays: [], appName: 'lazy-test', relays: [] });
-
-      // Crypto module should not be loaded yet
-      expect(hs).toBeInstanceOf(HoloSphere);
-    });
-
-    it('should lazy load crypto module on first sign() call', async () => {
-      const hs = new HoloSphere({ relays: [], appName: 'lazy-test', relays: [] });
-
-      // First crypto operation triggers lazy load
-      const signature = await hs.sign({ test: 'data' }, privateKey);
-
-      expect(typeof signature).toBe('string');
-    });
-
-    it('should lazy load crypto module on first issueCapability() call', async () => {
-      const hs = new HoloSphere({ relays: [], appName: 'lazy-test', relays: [] });
-
-      const token = await hs.issueCapability(
-        ['read'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey
-      );
-
-      expect(typeof token).toBe('string');
-    });
-
-    it('should reuse loaded crypto module for subsequent operations', async () => {
-      const hs = new HoloSphere({ relays: [], appName: 'lazy-test', relays: [] });
-
-      // First operation loads module
-      await hs.sign({ test: 'data' }, privateKey);
-
-      // Subsequent operations use loaded module
-      const token = await hs.issueCapability(
-        ['read'],
-        { holonId: '8928342e20fffff', lensName: 'test' },
-        publicKey
-      );
-
-      expect(typeof token).toBe('string');
-    });
-  });
-
-  describe('Error handling', () => {
-    it('should throw error for invalid private key format', async () => {
-      await expect(
-        hs.sign({ test: 'data' }, 'invalid-key')
-      ).rejects.toThrow(Error);
-    });
-
-    it('should throw error for invalid public key format', async () => {
-      const signature = await hs.sign({ test: 'data' }, privateKey);
-
-      await expect(
-        hs.verify({ test: 'data' }, signature, 'invalid-pubkey')
-      ).rejects.toThrow(Error);
-    });
-
-    it('should handle empty permissions array', async () => {
-      await expect(
-        hs.issueCapability(
-          [],
-          { holonId: '8928342e20fffff', lensName: 'test' },
-          publicKey
-        )
-      ).rejects.toThrow(Error);
-    });
-
-    it('should handle invalid scope', async () => {
-      await expect(
-        hs.issueCapability(
-          ['read'],
-          { holonId: '', lensName: '' },
-          publicKey
-        )
-      ).rejects.toThrow(Error);
-    });
-  });
-});