@originals/sdk 1.1.0

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

@@ -0,0 +1,358 @@
+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

@@ -0,0 +1,250 @@
+/* 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

@@ -0,0 +1,35 @@
+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);
+  });
+});
+