@originals/sdk 1.4.2 → 1.4.3

package/tests/unit/utils/MetricsCollector.test.ts

@@ -1,358 +0,0 @@
-import { describe, test, expect, beforeEach } from 'bun:test';
-import { MetricsCollector } from '../../../src/utils/MetricsCollector';
-
-describe('MetricsCollector', () => {
-  let metrics: MetricsCollector;
-  
-  beforeEach(() => {
-    metrics = new MetricsCollector();
-  });
-  
-  describe('operation recording', () => {
-    test('should record operation with duration and success', () => {
-      metrics.recordOperation('testOp', 100, true);
-      
-      const opMetrics = metrics.getOperationMetrics('testOp');
-      
-      expect(opMetrics).not.toBeNull();
-      expect(opMetrics!.count).toBe(1);
-      expect(opMetrics!.totalTime).toBe(100);
-      expect(opMetrics!.avgTime).toBe(100);
-      expect(opMetrics!.minTime).toBe(100);
-      expect(opMetrics!.maxTime).toBe(100);
-      expect(opMetrics!.errorCount).toBe(0);
-    });
-    
-    test('should record multiple operations and calculate statistics', () => {
-      metrics.recordOperation('testOp', 50, true);
-      metrics.recordOperation('testOp', 100, true);
-      metrics.recordOperation('testOp', 150, true);
-      
-      const opMetrics = metrics.getOperationMetrics('testOp');
-      
-      expect(opMetrics!.count).toBe(3);
-      expect(opMetrics!.totalTime).toBe(300);
-      expect(opMetrics!.avgTime).toBe(100);
-      expect(opMetrics!.minTime).toBe(50);
-      expect(opMetrics!.maxTime).toBe(150);
-    });
-    
-    test('should track errors in operations', () => {
-      metrics.recordOperation('testOp', 50, true);
-      metrics.recordOperation('testOp', 100, false);
-      metrics.recordOperation('testOp', 75, false);
-      
-      const opMetrics = metrics.getOperationMetrics('testOp');
-      
-      expect(opMetrics!.count).toBe(3);
-      expect(opMetrics!.errorCount).toBe(2);
-    });
-    
-    test('should return null for non-existent operation', () => {
-      const opMetrics = metrics.getOperationMetrics('nonExistent');
-      
-      expect(opMetrics).toBeNull();
-    });
-  });
-  
-  describe('startOperation helper', () => {
-    test('should track operation duration automatically', () => {
-      const complete = metrics.startOperation('autoOp');
-      
-      // Simulate work
-      const start = Date.now();
-      while (Date.now() - start < 10) {
-        // Wait 10ms
-      }
-      
-      complete(true);
-      
-      const opMetrics = metrics.getOperationMetrics('autoOp');
-      
-      expect(opMetrics!.count).toBe(1);
-      expect(opMetrics!.totalTime).toBeGreaterThanOrEqual(9);
-    });
-    
-    test('should record success or failure', () => {
-      const complete1 = metrics.startOperation('op1');
-      complete1(true);
-      
-      const complete2 = metrics.startOperation('op1');
-      complete2(false);
-      
-      const opMetrics = metrics.getOperationMetrics('op1');
-      
-      expect(opMetrics!.count).toBe(2);
-      expect(opMetrics!.errorCount).toBe(1);
-    });
-  });
-  
-  describe('asset lifecycle metrics', () => {
-    test('should record asset creations', () => {
-      metrics.recordAssetCreated();
-      metrics.recordAssetCreated();
-      metrics.recordAssetCreated();
-      
-      const allMetrics = metrics.getMetrics();
-      
-      expect(allMetrics.assetsCreated).toBe(3);
-    });
-    
-    test('should record migrations by layer transition', () => {
-      metrics.recordMigration('did:peer', 'did:webvh');
-      metrics.recordMigration('did:peer', 'did:webvh');
-      metrics.recordMigration('did:webvh', 'did:btco');
-      
-      const allMetrics = metrics.getMetrics();
-      
-      expect(allMetrics.assetsMigrated['peer→webvh']).toBe(2);
-      expect(allMetrics.assetsMigrated['webvh→btco']).toBe(1);
-    });
-    
-    test('should record asset transfers', () => {
-      metrics.recordTransfer();
-      metrics.recordTransfer();
-      
-      const allMetrics = metrics.getMetrics();
-      
-      expect(allMetrics.assetsTransferred).toBe(2);
-    });
-  });
-  
-  describe('error tracking', () => {
-    test('should track errors by code', () => {
-      metrics.recordError('ERR_001');
-      metrics.recordError('ERR_001');
-      metrics.recordError('ERR_002');
-      
-      const allMetrics = metrics.getMetrics();
-      
-      expect(allMetrics.errors['ERR_001']).toBe(2);
-      expect(allMetrics.errors['ERR_002']).toBe(1);
-    });
-    
-    test('should increment operation error count when operation is provided', () => {
-      // First create some operations
-      metrics.recordOperation('testOp', 100, true);
-      
-      // Then record errors for that operation
-      metrics.recordError('ERR_001', 'testOp');
-      metrics.recordError('ERR_002', 'testOp');
-      
-      const opMetrics = metrics.getOperationMetrics('testOp');
-      
-      expect(opMetrics!.errorCount).toBe(2);
-    });
-  });
-  
-  describe('cache statistics', () => {
-    test('should track cache hits and misses', () => {
-      metrics.recordCacheHit();
-      metrics.recordCacheHit();
-      metrics.recordCacheMiss();
-      
-      const allMetrics = metrics.getMetrics();
-      
-      expect(allMetrics.cacheStats).toBeDefined();
-      expect(allMetrics.cacheStats!.hits).toBe(2);
-      expect(allMetrics.cacheStats!.misses).toBe(1);
-      expect(allMetrics.cacheStats!.hitRate).toBeCloseTo(2 / 3);
-    });
-    
-    test('should return undefined cache stats when no cache operations', () => {
-      const allMetrics = metrics.getMetrics();
-      
-      expect(allMetrics.cacheStats).toBeUndefined();
-    });
-    
-    test('should calculate hit rate correctly', () => {
-      // 80% hit rate
-      for (let i = 0; i < 8; i++) {
-        metrics.recordCacheHit();
-      }
-      for (let i = 0; i < 2; i++) {
-        metrics.recordCacheMiss();
-      }
-      
-      const allMetrics = metrics.getMetrics();
-      
-      expect(allMetrics.cacheStats!.hitRate).toBe(0.8);
-    });
-  });
-  
-  describe('system metrics', () => {
-    test('should track start time', () => {
-      const allMetrics = metrics.getMetrics();
-      
-      expect(allMetrics.startTime).toBeDefined();
-      expect(new Date(allMetrics.startTime).getTime()).toBeLessThanOrEqual(Date.now());
-    });
-    
-    test('should track uptime', async () => {
-      await new Promise(resolve => setTimeout(resolve, 10));
-      
-      const allMetrics = metrics.getMetrics();
-      
-      expect(allMetrics.uptime).toBeGreaterThanOrEqual(9);
-    });
-  });
-  
-  describe('reset functionality', () => {
-    test('should reset all metrics', () => {
-      // Record various metrics
-      metrics.recordAssetCreated();
-      metrics.recordMigration('did:peer', 'did:webvh');
-      metrics.recordTransfer();
-      metrics.recordOperation('testOp', 100, true);
-      metrics.recordError('ERR_001');
-      metrics.recordCacheHit();
-      metrics.recordCacheMiss();
-      
-      // Reset
-      metrics.reset();
-      
-      const allMetrics = metrics.getMetrics();
-      
-      expect(allMetrics.assetsCreated).toBe(0);
-      expect(Object.keys(allMetrics.assetsMigrated).length).toBe(0);
-      expect(allMetrics.assetsTransferred).toBe(0);
-      expect(Object.keys(allMetrics.operationTimes).length).toBe(0);
-      expect(Object.keys(allMetrics.errors).length).toBe(0);
-      expect(allMetrics.cacheStats).toBeUndefined();
-    });
-  });
-  
-  describe('export formats', () => {
-    beforeEach(() => {
-      // Set up some test metrics
-      metrics.recordAssetCreated();
-      metrics.recordAssetCreated();
-      metrics.recordMigration('did:peer', 'did:webvh');
-      metrics.recordTransfer();
-      metrics.recordOperation('createAsset', 150, true);
-      metrics.recordOperation('createAsset', 200, true);
-      metrics.recordOperation('createAsset', 250, false);
-      metrics.recordError('ERR_001');
-      metrics.recordCacheHit();
-      metrics.recordCacheMiss();
-    });
-    
-    test('should export as JSON', () => {
-      const json = metrics.export('json');
-      
-      expect(() => JSON.parse(json)).not.toThrow();
-      
-      const parsed = JSON.parse(json);
-      expect(parsed.assetsCreated).toBe(2);
-      expect(parsed.assetsMigrated['peer→webvh']).toBe(1);
-      expect(parsed.assetsTransferred).toBe(1);
-    });
-    
-    test('should export as Prometheus format', () => {
-      const prometheus = metrics.export('prometheus');
-      
-      // Check for expected Prometheus metrics
-      expect(prometheus).toContain('originals_assets_created_total');
-      expect(prometheus).toContain('originals_assets_transferred_total');
-      expect(prometheus).toContain('originals_assets_migrated_total');
-      expect(prometheus).toContain('originals_operation_createAsset_total');
-      expect(prometheus).toContain('originals_operation_createAsset_duration_milliseconds');
-      expect(prometheus).toContain('originals_errors_total');
-      expect(prometheus).toContain('originals_cache_hits_total');
-      expect(prometheus).toContain('originals_uptime_milliseconds');
-    });
-    
-    test('should format Prometheus metrics correctly', () => {
-      const prometheus = metrics.export('prometheus');
-      
-      // Check specific values
-      expect(prometheus).toContain('originals_assets_created_total 2');
-      expect(prometheus).toContain('originals_assets_transferred_total 1');
-      expect(prometheus).toContain('originals_assets_migrated_total{from="peer",to="webvh"} 1');
-    });
-    
-    test('should include operation statistics in Prometheus format', () => {
-      const prometheus = metrics.export('prometheus');
-      
-      // Check for operation metrics
-      expect(prometheus).toContain('originals_operation_createAsset_total 3');
-      expect(prometheus).toContain('originals_operation_createAsset_errors_total 1');
-      
-      // Check for duration quantiles
-      expect(prometheus).toContain('originals_operation_createAsset_duration_milliseconds{quantile="0.0"}');
-      expect(prometheus).toContain('originals_operation_createAsset_duration_milliseconds{quantile="0.5"}');
-      expect(prometheus).toContain('originals_operation_createAsset_duration_milliseconds{quantile="1.0"}');
-    });
-    
-    test('should throw error for unsupported format', () => {
-      expect(() => metrics.export('xml' as any)).toThrow('Unsupported export format');
-    });
-  });
-  
-  describe('comprehensive metrics snapshot', () => {
-    test('should provide complete metrics snapshot', () => {
-      // Set up comprehensive metrics
-      metrics.recordAssetCreated();
-      metrics.recordMigration('did:peer', 'did:webvh');
-      metrics.recordMigration('did:webvh', 'did:btco');
-      metrics.recordTransfer();
-      metrics.recordOperation('op1', 100, true);
-      metrics.recordOperation('op2', 200, false);
-      metrics.recordError('ERR_001');
-      metrics.recordCacheHit();
-      
-      const allMetrics = metrics.getMetrics();
-      
-      // Verify structure
-      expect(allMetrics).toHaveProperty('assetsCreated');
-      expect(allMetrics).toHaveProperty('assetsMigrated');
-      expect(allMetrics).toHaveProperty('assetsTransferred');
-      expect(allMetrics).toHaveProperty('operationTimes');
-      expect(allMetrics).toHaveProperty('errors');
-      expect(allMetrics).toHaveProperty('cacheStats');
-      expect(allMetrics).toHaveProperty('startTime');
-      expect(allMetrics).toHaveProperty('uptime');
-      
-      // Verify values
-      expect(allMetrics.assetsCreated).toBe(1);
-      expect(allMetrics.assetsMigrated['peer→webvh']).toBe(1);
-      expect(allMetrics.assetsMigrated['webvh→btco']).toBe(1);
-      expect(allMetrics.assetsTransferred).toBe(1);
-      expect(allMetrics.operationTimes['op1']).toBeDefined();
-      expect(allMetrics.operationTimes['op2']).toBeDefined();
-      expect(allMetrics.errors['ERR_001']).toBe(1);
-    });
-  });
-  
-  describe('memory efficiency', () => {
-    test('should not leak memory with many operations', () => {
-      // Record a large number of operations
-      for (let i = 0; i < 10000; i++) {
-        metrics.recordOperation(`op${i % 10}`, Math.random() * 100, Math.random() > 0.1);
-      }
-      
-      // Should only have 10 unique operations
-      const allMetrics = metrics.getMetrics();
-      expect(Object.keys(allMetrics.operationTimes).length).toBe(10);
-      
-      // Each operation should have correct count
-      expect(allMetrics.operationTimes['op0'].count).toBe(1000);
-    });
-    
-    test('should handle many error codes efficiently', () => {
-      // Record many different error codes
-      for (let i = 0; i < 1000; i++) {
-        metrics.recordError(`ERR_${i % 50}`);
-      }
-      
-      const allMetrics = metrics.getMetrics();
-      
-      // Should have 50 unique error codes
-      expect(Object.keys(allMetrics.errors).length).toBe(50);
-      
-      // Each error code should appear 20 times
-      expect(allMetrics.errors['ERR_0']).toBe(20);
-    });
-  });
-});
-

package/tests/unit/utils/bitcoin-address.test.ts

@@ -1,250 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { describe, test, expect } from 'bun:test';
-import { validateBitcoinAddress, isValidBitcoinAddress } from '../../../src/utils/bitcoin-address';
-import * as bitcoin from 'bitcoinjs-lib';
-
-describe('bitcoin-address validation', () => {
-  describe('validateBitcoinAddress', () => {
-    describe('mainnet addresses', () => {
-      test('accepts valid mainnet bech32 (bc1) address', () => {
-        // Valid P2WPKH mainnet address
-        expect(() => validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'mainnet')).not.toThrow();
-      });
-
-      test('legacy address formats are not supported in bitcoinjs-lib v6', () => {
-        // bitcoinjs-lib v6 primarily supports bech32 addresses
-        // Legacy P2PKH (1...) and P2SH (3...) formats require additional libraries
-        // For the purposes of this SDK focused on modern Bitcoin, we'll primarily validate bech32
-        expect(true).toBe(true);
-      });
-
-      test('accepts valid mainnet P2WSH (bc1...) address', () => {
-        // Valid P2WSH address (longer than P2WPKH)
-        expect(() => validateBitcoinAddress('bc1qeklep85ntjz4605drds6aww9u0qr46qzrv5xswd35uhjuj8ahfcqgf6hak', 'mainnet')).not.toThrow();
-      });
-
-      test('rejects mainnet address with invalid checksum', () => {
-        // Modified last character to break checksum
-        expect(() => validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdd', 'mainnet'))
-          .toThrow(/Invalid Bitcoin address/i);
-      });
-
-      test('rejects regtest address on mainnet network', () => {
-        // Regtest/testnet address should fail on mainnet
-        expect(() => validateBitcoinAddress('tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx', 'mainnet'))
-          .toThrow(/Invalid/i);
-      });
-    });
-
-    describe('regtest addresses', () => {
-      test('accepts valid regtest/testnet bech32 addresses', () => {
-        // Regtest accepts both bcrt1 and tb1 addresses (testnet format is commonly used)
-        // Using testnet bech32 address which is valid for regtest
-        expect(() => validateBitcoinAddress('tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx', 'regtest')).not.toThrow();
-        expect(() => validateBitcoinAddress('tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7', 'regtest')).not.toThrow();
-      });
-
-      test('rejects mainnet address on regtest network', () => {
-        expect(() => validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'regtest'))
-          .toThrow(/Invalid/i);
-      });
-    });
-
-    describe('signet addresses', () => {
-      test('accepts valid signet bech32 (tb1) address', () => {
-        // Signet uses tb1 prefix like testnet
-        expect(() => validateBitcoinAddress('tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx', 'signet')).not.toThrow();
-      });
-
-      test('accepts valid signet legacy addresses', () => {
-        // Signet uses same formats as testnet
-        expect(() => validateBitcoinAddress('mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn', 'signet')).not.toThrow();
-      });
-
-      test('rejects mainnet address on signet network', () => {
-        expect(() => validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'signet'))
-          .toThrow(/Invalid/i);
-      });
-    });
-
-    describe('invalid addresses', () => {
-      test('rejects empty string', () => {
-        expect(() => validateBitcoinAddress('', 'mainnet'))
-          .toThrow(/empty/i);
-      });
-
-      test('rejects whitespace-only string', () => {
-        expect(() => validateBitcoinAddress('   ', 'mainnet'))
-          .toThrow(/empty/i);
-      });
-
-      test('rejects null or undefined', () => {
-        expect(() => validateBitcoinAddress(null as any, 'mainnet'))
-          .toThrow(/non-empty string/i);
-        expect(() => validateBitcoinAddress(undefined as any, 'mainnet'))
-          .toThrow(/non-empty string/i);
-      });
-
-      test('rejects non-string values', () => {
-        expect(() => validateBitcoinAddress(123 as any, 'mainnet'))
-          .toThrow(/non-empty string/i);
-        expect(() => validateBitcoinAddress({} as any, 'mainnet'))
-          .toThrow(/non-empty string/i);
-      });
-
-      test('rejects address that is too short', () => {
-        expect(() => validateBitcoinAddress('bc1qar0sr', 'mainnet'))
-          .toThrow(/length/i);
-      });
-
-      test('rejects address that is too long', () => {
-        const tooLong = 'bc1' + 'q'.repeat(100);
-        expect(() => validateBitcoinAddress(tooLong, 'mainnet'))
-          .toThrow(/length/i);
-      });
-
-      test('rejects completely malformed address', () => {
-        expect(() => validateBitcoinAddress('not-a-bitcoin-address-at-all-really-long', 'mainnet'))
-          .toThrow(/Invalid/i);
-      });
-
-      test('rejects address with invalid characters', () => {
-        expect(() => validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5md@', 'mainnet'))
-          .toThrow(/Invalid/i);
-      });
-
-      test('rejects mock addresses', () => {
-        expect(() => validateBitcoinAddress('mock-address', 'mainnet'))
-          .toThrow(/Mock or test addresses/i);
-        expect(() => validateBitcoinAddress('test-address', 'testnet'))
-          .toThrow(/Mock or test addresses/i);
-        expect(() => validateBitcoinAddress('MOCK-ADDRESS', 'mainnet'))
-          .toThrow(/Mock or test addresses/i);
-        expect(() => validateBitcoinAddress('TEST-ADDRESS', 'regtest'))
-          .toThrow(/Mock or test addresses/i);
-      });
-
-      test('rejects address with wrong network prefix', () => {
-        // Using testnet prefix on mainnet
-        expect(() => validateBitcoinAddress('tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx', 'mainnet'))
-          .toThrow(/Invalid/i);
-        
-        // Using mainnet prefix on regtest
-        expect(() => validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'regtest'))
-          .toThrow(/Invalid/i);
-      });
-    });
-
-    describe('edge cases', () => {
-      test('trims whitespace before validation', () => {
-        expect(() => validateBitcoinAddress('  bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq  ', 'mainnet')).not.toThrow();
-      });
-
-      test('returns true for valid addresses', () => {
-        const result = validateBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'mainnet');
-        expect(result).toBe(true);
-      });
-
-      test('provides descriptive error messages', () => {
-        // Invalid bech32 address
-        expect(() => validateBitcoinAddress('bc1qinvalidaddresswithinvalidchecksum', 'mainnet'))
-          .toThrow(/Invalid/);
-
-        // Mock address
-        expect(() => validateBitcoinAddress('mock-address', 'mainnet'))
-          .toThrow(/Mock or test addresses are not valid/);
-
-        // Empty
-        expect(() => validateBitcoinAddress('', 'mainnet'))
-          .toThrow(/non-empty string/);
-      });
-    });
-
-    describe('real-world address examples', () => {
-      test('accepts various valid mainnet bech32 addresses', () => {
-        const validAddresses = [
-          'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh',  // P2WPKH
-          'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq',  // P2WPKH
-          'bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3', // P2WSH
-          'bc1qeklep85ntjz4605drds6aww9u0qr46qzrv5xswd35uhjuj8ahfcqgf6hak', // P2WSH
-        ];
-
-        validAddresses.forEach(address => {
-          expect(() => validateBitcoinAddress(address, 'mainnet')).not.toThrow();
-        });
-      });
-
-      test('accepts various valid regtest bech32 addresses', () => {
-        const validAddresses = [
-          'tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7',
-          'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx',
-        ];
-
-        validAddresses.forEach(address => {
-          expect(() => validateBitcoinAddress(address, 'regtest')).not.toThrow();
-        });
-      });
-    });
-  });
-
-  describe('isValidBitcoinAddress', () => {
-    test('returns true for valid addresses', () => {
-      expect(isValidBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'mainnet')).toBe(true);
-      expect(isValidBitcoinAddress('tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx', 'regtest')).toBe(true);
-      expect(isValidBitcoinAddress('tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx', 'signet')).toBe(true);
-    });
-
-    test('returns false for invalid addresses', () => {
-      expect(isValidBitcoinAddress('mock-address', 'mainnet')).toBe(false);
-      expect(isValidBitcoinAddress('', 'mainnet')).toBe(false);
-      expect(isValidBitcoinAddress('invalid', 'mainnet')).toBe(false);
-      expect(isValidBitcoinAddress('bc1qinvalidaddresswith', 'mainnet')).toBe(false);
-    });
-
-    test('returns false for wrong network', () => {
-      expect(isValidBitcoinAddress('bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq', 'testnet')).toBe(false);
-      expect(isValidBitcoinAddress('tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx', 'mainnet')).toBe(false);
-    });
-
-    test('does not throw for any input', () => {
-      expect(() => isValidBitcoinAddress('', 'mainnet')).not.toThrow();
-      expect(() => isValidBitcoinAddress(null as any, 'mainnet')).not.toThrow();
-      expect(() => isValidBitcoinAddress(undefined as any, 'mainnet')).not.toThrow();
-    });
-  });
-
-  describe('integration with bitcoinjs-lib', () => {
-    test('validates addresses that bitcoinjs-lib can decode', () => {
-      const validMainnetAddresses = [
-        'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq',
-        'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh',
-      ];
-
-      validMainnetAddresses.forEach(address => {
-        // Should not throw with our validator
-        expect(() => validateBitcoinAddress(address, 'mainnet')).not.toThrow();
-        
-        // Should also not throw with bitcoinjs-lib directly
-        expect(() => bitcoin.address.toOutputScript(address, bitcoin.networks.bitcoin)).not.toThrow();
-      });
-    });
-
-    test('rejects addresses that bitcoinjs-lib rejects', () => {
-      const invalidAddresses = [
-        'bc1qinvalid',
-        '1InvalidBase58',
-        'not-an-address',
-      ];
-
-      invalidAddresses.forEach(address => {
-        // Should throw with our validator (if long enough)
-        if (address.length >= 26) {
-          expect(() => validateBitcoinAddress(address, 'mainnet')).toThrow();
-        }
-        
-        // Should also throw with bitcoinjs-lib directly
-        expect(() => bitcoin.address.toOutputScript(address, bitcoin.networks.bitcoin)).toThrow();
-      });
-    });
-  });
-});

package/tests/unit/utils/cbor.test.ts

@@ -1,35 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { encode, decode } from '../../../src/utils/cbor';
-
-describe('utils/cbor', () => {
-  test('encode returns Uint8Array', () => {
-    const input = { a: 1, b: 'two' };
-    const out = encode(input);
-    expect(out).toBeInstanceOf(Uint8Array);
-    expect(out.length).toBeGreaterThan(0);
-  });
-
-  test('decode roundtrips object', () => {
-    const input = { a: 1, b: 'two', nested: { ok: true } };
-    const encoded = encode(input);
-    const decoded = decode<typeof input>(encoded);
-    expect(decoded).toEqual(input);
-  });
-
-  test('decode accepts Buffer', () => {
-    const input = [1, 2, 3];
-    const encoded = encode(input);
-    const buf = Buffer.from(encoded);
-    const decoded = decode<number[]>(buf);
-    expect(decoded).toEqual(input);
-  });
-
-  test('decode accepts ArrayBuffer', () => {
-    const input = { hello: 'world' };
-    const encoded = encode(input);
-    const ab = encoded.buffer.slice(encoded.byteOffset, encoded.byteOffset + encoded.byteLength) as ArrayBuffer;
-    const decoded = decode<typeof input>(ab as ArrayBuffer);
-    expect(decoded).toEqual(input);
-  });
-});
-