@originals/sdk 1.1.0

package/tests/unit/storage/MemoryStorageAdapter.test.ts

@@ -0,0 +1,93 @@
+import { describe, test, expect } from 'bun:test';
+import { MemoryStorageAdapter } from '../../../src/storage/MemoryStorageAdapter';
+
+describe('MemoryStorageAdapter', () => {
+  test('putObject stores string content', async () => {
+    const adapter = new MemoryStorageAdapter();
+    const uri = await adapter.putObject('example.com', '/test.txt', 'hello world');
+    expect(uri).toBe('mem://example.com/test.txt');
+  });
+
+  test('putObject stores Uint8Array content', async () => {
+    const adapter = new MemoryStorageAdapter();
+    const data = new Uint8Array([1, 2, 3, 4]);
+    const uri = await adapter.putObject('example.com', '/test.bin', data);
+    expect(uri).toBe('mem://example.com/test.bin');
+  });
+
+  test('getObject retrieves stored content', async () => {
+    const adapter = new MemoryStorageAdapter();
+    const data = new Uint8Array([5, 6, 7, 8]);
+    await adapter.putObject('example.com', '/data.bin', data);
+    
+    const result = await adapter.getObject('example.com', '/data.bin');
+    expect(result).not.toBeNull();
+    expect(result?.content).toEqual(data);
+  });
+
+  test('getObject returns null for non-existent object', async () => {
+    const adapter = new MemoryStorageAdapter();
+    const result = await adapter.getObject('example.com', '/nonexistent.txt');
+    expect(result).toBeNull();
+  });
+
+  test('exists returns true for stored object', async () => {
+    const adapter = new MemoryStorageAdapter();
+    await adapter.putObject('example.com', '/test.txt', 'content');
+    
+    const exists = await adapter.exists('example.com', '/test.txt');
+    expect(exists).toBe(true);
+  });
+
+  test('exists returns false for non-existent object', async () => {
+    const adapter = new MemoryStorageAdapter();
+    const exists = await adapter.exists('example.com', '/nonexistent.txt');
+    expect(exists).toBe(false);
+  });
+
+  test('putObject strips leading slashes from path', async () => {
+    const adapter = new MemoryStorageAdapter();
+    const uri = await adapter.putObject('example.com', '///test.txt', 'content');
+    expect(uri).toBe('mem://example.com/test.txt');
+    
+    const result = await adapter.getObject('example.com', '/test.txt');
+    expect(result).not.toBeNull();
+  });
+
+  test('getObject works with paths that have leading slashes', async () => {
+    const adapter = new MemoryStorageAdapter();
+    await adapter.putObject('example.com', 'test.txt', 'content');
+    
+    const result = await adapter.getObject('example.com', '/test.txt');
+    expect(result).not.toBeNull();
+  });
+
+  test('multiple domains are isolated', async () => {
+    const adapter = new MemoryStorageAdapter();
+    await adapter.putObject('domain1.com', '/test.txt', 'content1');
+    await adapter.putObject('domain2.com', '/test.txt', 'content2');
+    
+    const result1 = await adapter.getObject('domain1.com', '/test.txt');
+    const result2 = await adapter.getObject('domain2.com', '/test.txt');
+    
+    expect(new TextDecoder().decode(result1?.content)).toBe('content1');
+    expect(new TextDecoder().decode(result2?.content)).toBe('content2');
+  });
+
+  test('putObject overwrites existing content', async () => {
+    const adapter = new MemoryStorageAdapter();
+    await adapter.putObject('example.com', '/test.txt', 'original');
+    await adapter.putObject('example.com', '/test.txt', 'updated');
+    
+    const result = await adapter.getObject('example.com', '/test.txt');
+    expect(new TextDecoder().decode(result?.content)).toBe('updated');
+  });
+
+  test('exists handles paths with leading slashes', async () => {
+    const adapter = new MemoryStorageAdapter();
+    await adapter.putObject('example.com', 'test.txt', 'content');
+    
+    const exists = await adapter.exists('example.com', '/test.txt');
+    expect(exists).toBe(true);
+  });
+});

package/tests/unit/types/network.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect } from 'bun:test';
+import {
+  WEBVH_NETWORKS,
+  DEFAULT_WEBVH_NETWORK,
+  getNetworkConfig,
+  getNetworkDomain,
+  getNetworkContextUrl,
+  validateVersionForNetwork,
+  getRecommendedNetworkForVersion,
+  getBitcoinNetworkForWebVH,
+  getWebVHNetworkForBitcoin,
+  type WebVHNetworkName,
+  type BitcoinNetworkName,
+} from '../../../src/types/network';
+
+describe('Network Configuration', () => {
+  describe('WEBVH_NETWORKS', () => {
+    it('should define all three networks', () => {
+      expect(WEBVH_NETWORKS.magby).toBeDefined();
+      expect(WEBVH_NETWORKS.cleffa).toBeDefined();
+      expect(WEBVH_NETWORKS.pichu).toBeDefined();
+    });
+
+    it('should have correct domains for each network', () => {
+      expect(WEBVH_NETWORKS.magby.domain).toBe('magby.originals.build');
+      expect(WEBVH_NETWORKS.cleffa.domain).toBe('cleffa.originals.build');
+      expect(WEBVH_NETWORKS.pichu.domain).toBe('pichu.originals.build');
+    });
+
+    it('should have correct stability levels', () => {
+      expect(WEBVH_NETWORKS.magby.stability).toBe('patch');
+      expect(WEBVH_NETWORKS.cleffa.stability).toBe('minor');
+      expect(WEBVH_NETWORKS.pichu.stability).toBe('major');
+    });
+
+    it('should have correct context URLs', () => {
+      expect(WEBVH_NETWORKS.magby.contextUrl).toBe('https://magby.originals.build/context');
+      expect(WEBVH_NETWORKS.cleffa.contextUrl).toBe('https://cleffa.originals.build/context');
+      expect(WEBVH_NETWORKS.pichu.contextUrl).toBe('https://pichu.originals.build/context');
+    });
+  });
+
+  describe('DEFAULT_WEBVH_NETWORK', () => {
+    it('should default to pichu (production)', () => {
+      expect(DEFAULT_WEBVH_NETWORK).toBe('pichu');
+    });
+  });
+
+  describe('getNetworkConfig', () => {
+    it('should return correct config for each network', () => {
+      const magbyConfig = getNetworkConfig('magby');
+      expect(magbyConfig.name).toBe('magby');
+      expect(magbyConfig.domain).toBe('magby.originals.build');
+
+      const cleffaConfig = getNetworkConfig('cleffa');
+      expect(cleffaConfig.name).toBe('cleffa');
+      expect(cleffaConfig.domain).toBe('cleffa.originals.build');
+
+      const pichuConfig = getNetworkConfig('pichu');
+      expect(pichuConfig.name).toBe('pichu');
+      expect(pichuConfig.domain).toBe('pichu.originals.build');
+    });
+
+    it('should throw error for invalid network', () => {
+      expect(() => getNetworkConfig('invalid' as WebVHNetworkName)).toThrow(
+        'Invalid WebVH network: invalid'
+      );
+    });
+  });
+
+  describe('getNetworkDomain', () => {
+    it('should return correct domain for each network', () => {
+      expect(getNetworkDomain('magby')).toBe('magby.originals.build');
+      expect(getNetworkDomain('cleffa')).toBe('cleffa.originals.build');
+      expect(getNetworkDomain('pichu')).toBe('pichu.originals.build');
+    });
+  });
+
+  describe('getNetworkContextUrl', () => {
+    it('should return correct context URL for each network', () => {
+      expect(getNetworkContextUrl('magby')).toBe('https://magby.originals.build/context');
+      expect(getNetworkContextUrl('cleffa')).toBe('https://cleffa.originals.build/context');
+      expect(getNetworkContextUrl('pichu')).toBe('https://pichu.originals.build/context');
+    });
+  });
+
+  describe('validateVersionForNetwork', () => {
+    describe('pichu (major releases only)', () => {
+      it('should accept major releases (X.0.0)', () => {
+        expect(validateVersionForNetwork('1.0.0', 'pichu')).toBe(true);
+        expect(validateVersionForNetwork('2.0.0', 'pichu')).toBe(true);
+        expect(validateVersionForNetwork('10.0.0', 'pichu')).toBe(true);
+      });
+
+      it('should reject minor releases (X.Y.0 where Y > 0)', () => {
+        expect(validateVersionForNetwork('1.1.0', 'pichu')).toBe(false);
+        expect(validateVersionForNetwork('2.5.0', 'pichu')).toBe(false);
+      });
+
+      it('should reject patch releases (X.Y.Z where Z > 0)', () => {
+        expect(validateVersionForNetwork('1.0.1', 'pichu')).toBe(false);
+        expect(validateVersionForNetwork('1.1.1', 'pichu')).toBe(false);
+        expect(validateVersionForNetwork('2.3.4', 'pichu')).toBe(false);
+      });
+    });
+
+    describe('cleffa (minor releases)', () => {
+      it('should accept major releases (X.0.0)', () => {
+        expect(validateVersionForNetwork('1.0.0', 'cleffa')).toBe(true);
+        expect(validateVersionForNetwork('2.0.0', 'cleffa')).toBe(true);
+      });
+
+      it('should accept minor releases (X.Y.0)', () => {
+        expect(validateVersionForNetwork('1.1.0', 'cleffa')).toBe(true);
+        expect(validateVersionForNetwork('2.5.0', 'cleffa')).toBe(true);
+        expect(validateVersionForNetwork('10.20.0', 'cleffa')).toBe(true);
+      });
+
+      it('should reject patch releases (X.Y.Z where Z > 0)', () => {
+        expect(validateVersionForNetwork('1.0.1', 'cleffa')).toBe(false);
+        expect(validateVersionForNetwork('1.1.1', 'cleffa')).toBe(false);
+        expect(validateVersionForNetwork('2.3.4', 'cleffa')).toBe(false);
+      });
+    });
+
+    describe('magby (all versions)', () => {
+      it('should accept major releases', () => {
+        expect(validateVersionForNetwork('1.0.0', 'magby')).toBe(true);
+        expect(validateVersionForNetwork('2.0.0', 'magby')).toBe(true);
+      });
+
+      it('should accept minor releases', () => {
+        expect(validateVersionForNetwork('1.1.0', 'magby')).toBe(true);
+        expect(validateVersionForNetwork('2.5.0', 'magby')).toBe(true);
+      });
+
+      it('should accept patch releases', () => {
+        expect(validateVersionForNetwork('1.0.1', 'magby')).toBe(true);
+        expect(validateVersionForNetwork('1.1.1', 'magby')).toBe(true);
+        expect(validateVersionForNetwork('2.3.4', 'magby')).toBe(true);
+      });
+    });
+
+    it('should handle pre-release versions', () => {
+      // Pre-release should still follow the same rules for the base version
+      expect(validateVersionForNetwork('1.0.0-beta.1', 'pichu')).toBe(true);
+      expect(validateVersionForNetwork('1.1.0-alpha', 'pichu')).toBe(false);
+      expect(validateVersionForNetwork('1.1.0-beta.1', 'cleffa')).toBe(true);
+      expect(validateVersionForNetwork('1.1.1-rc.1', 'cleffa')).toBe(false);
+    });
+
+    it('should throw error for invalid version format', () => {
+      expect(() => validateVersionForNetwork('invalid', 'pichu')).toThrow('Invalid version format');
+      expect(() => validateVersionForNetwork('1.0', 'pichu')).toThrow('Invalid version format');
+      expect(() => validateVersionForNetwork('v1.0.0', 'pichu')).toThrow('Invalid version format');
+    });
+  });
+
+  describe('getRecommendedNetworkForVersion', () => {
+    it('should recommend pichu for major releases', () => {
+      expect(getRecommendedNetworkForVersion('1.0.0')).toBe('pichu');
+      expect(getRecommendedNetworkForVersion('2.0.0')).toBe('pichu');
+      expect(getRecommendedNetworkForVersion('10.0.0')).toBe('pichu');
+    });
+
+    it('should recommend cleffa for minor releases', () => {
+      expect(getRecommendedNetworkForVersion('1.1.0')).toBe('cleffa');
+      expect(getRecommendedNetworkForVersion('2.5.0')).toBe('cleffa');
+      expect(getRecommendedNetworkForVersion('10.20.0')).toBe('cleffa');
+    });
+
+    it('should recommend magby for patch releases', () => {
+      expect(getRecommendedNetworkForVersion('1.0.1')).toBe('magby');
+      expect(getRecommendedNetworkForVersion('1.1.1')).toBe('magby');
+      expect(getRecommendedNetworkForVersion('2.3.4')).toBe('magby');
+    });
+
+    it('should handle pre-release versions correctly', () => {
+      expect(getRecommendedNetworkForVersion('1.0.0-beta')).toBe('pichu');
+      expect(getRecommendedNetworkForVersion('1.1.0-alpha')).toBe('cleffa');
+      expect(getRecommendedNetworkForVersion('1.1.1-rc.1')).toBe('magby');
+    });
+  });
+
+  describe('Bitcoin Network Mapping', () => {
+    describe('WEBVH_NETWORKS Bitcoin mappings', () => {
+      it('should map magby to regtest', () => {
+        expect(WEBVH_NETWORKS.magby.bitcoinNetwork).toBe('regtest');
+      });
+
+      it('should map cleffa to signet', () => {
+        expect(WEBVH_NETWORKS.cleffa.bitcoinNetwork).toBe('signet');
+      });
+
+      it('should map pichu to mainnet', () => {
+        expect(WEBVH_NETWORKS.pichu.bitcoinNetwork).toBe('mainnet');
+      });
+    });
+
+    describe('getBitcoinNetworkForWebVH', () => {
+      it('should return regtest for magby', () => {
+        expect(getBitcoinNetworkForWebVH('magby')).toBe('regtest');
+      });
+
+      it('should return signet for cleffa', () => {
+        expect(getBitcoinNetworkForWebVH('cleffa')).toBe('signet');
+      });
+
+      it('should return mainnet for pichu', () => {
+        expect(getBitcoinNetworkForWebVH('pichu')).toBe('mainnet');
+      });
+    });
+
+    describe('getWebVHNetworkForBitcoin', () => {
+      it('should return magby for regtest', () => {
+        expect(getWebVHNetworkForBitcoin('regtest')).toBe('magby');
+      });
+
+      it('should return cleffa for signet', () => {
+        expect(getWebVHNetworkForBitcoin('signet')).toBe('cleffa');
+      });
+
+      it('should return pichu for mainnet', () => {
+        expect(getWebVHNetworkForBitcoin('mainnet')).toBe('pichu');
+      });
+    });
+
+    describe('Network mapping consistency', () => {
+      it('should have bidirectional mapping for all WebVH networks', () => {
+        // magby ↔ regtest
+        const magbyBitcoin = getBitcoinNetworkForWebVH('magby');
+        expect(getWebVHNetworkForBitcoin(magbyBitcoin)).toBe('magby');
+
+        // cleffa ↔ signet
+        const cleffaBitcoin = getBitcoinNetworkForWebVH('cleffa');
+        expect(getWebVHNetworkForBitcoin(cleffaBitcoin)).toBe('cleffa');
+
+        // pichu ↔ mainnet
+        const pichuBitcoin = getBitcoinNetworkForWebVH('pichu');
+        expect(getWebVHNetworkForBitcoin(pichuBitcoin)).toBe('pichu');
+      });
+
+      it('should maintain environment consistency across networks', () => {
+        // Development: magby → regtest
+        expect(getBitcoinNetworkForWebVH('magby')).toBe('regtest');
+
+        // Staging: cleffa → signet
+        expect(getBitcoinNetworkForWebVH('cleffa')).toBe('signet');
+
+        // Production: pichu → mainnet
+        expect(getBitcoinNetworkForWebVH('pichu')).toBe('mainnet');
+      });
+    });
+  });
+});