stated-protocol-parser 1.0.6 → 5.0.0

package/src/hash.test.ts

@@ -1,217 +1,219 @@
-import { sha256, verify, fromUrlSafeBase64, toUrlSafeBase64 } from './hash.node';
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { sha256, verify, fromUrlSafeBase64, toUrlSafeBase64 } from './hash';
 
 describe('Hash utilities', () => {
-    describe('sha256', () => {
-        it('should hash a simple string', () => {
-            const input = 'hello world';
-            const hash = sha256(input);
-            
-            // Verify it's URL-safe (no +, /, or =)
-            expect(hash).not.toContain('+');
-            expect(hash).not.toContain('/');
-            expect(hash).not.toContain('=');
-            
-            // Verify consistent output
-            const hash2 = sha256(input);
-            expect(hash).toBe(hash2);
-        });
-
-        it('should produce correct hash for known input', () => {
-            const input = 'hello world';
-            const expectedHash = 'uU0nuZNNPgilLlLX2n2r-sSE7-N6U4DukIj3rOLvzek';
-            const hash = sha256(input);
-            expect(hash).toBe(expectedHash);
-        });
-
-        it('should handle empty string', () => {
-            const hash = sha256('');
-            expect(hash).toBeTruthy();
-            expect(typeof hash).toBe('string');
-        });
-
-        it('should handle unicode characters', () => {
-            const input = '你好世界 🌍';
-            const hash = sha256(input);
-            expect(hash).toBeTruthy();
-            expect(typeof hash).toBe('string');
-            
-            // Verify consistency
-            const hash2 = sha256(input);
-            expect(hash).toBe(hash2);
-        });
-
-        it('should handle Buffer input', () => {
-            const data = Buffer.from('hello world');
-            const hash = sha256(data);
-            
-            // Should produce same hash as string input
-            const stringHash = sha256('hello world');
-            expect(hash).toBe(stringHash);
-        });
-
-        it('should produce different hashes for different inputs', () => {
-            const hash1 = sha256('hello');
-            const hash2 = sha256('world');
-            expect(hash1).not.toBe(hash2);
-        });
-
-        it('should produce 43-character URL-safe base64 string', () => {
-            const hash = sha256('test');
-            // SHA-256 produces 256 bits = 32 bytes
-            // Base64 encoding: 32 bytes * 4/3 = 42.67, rounded up = 43 chars (without padding)
-            expect(hash.length).toBe(43);
-        });
-    });
-
-    describe('verify', () => {
-        it('should verify correct hash', () => {
-            const content = 'hello world';
-            const hash = sha256(content);
-            const isValid = verify(content, hash);
-            expect(isValid).toBe(true);
-        });
-
-        it('should reject incorrect hash', () => {
-            const content = 'hello world';
-            const wrongHash = 'incorrect_hash_value_here_1234567890';
-            const isValid = verify(content, wrongHash);
-            expect(isValid).toBe(false);
-        });
-
-        it('should reject hash for different content', () => {
-            const content1 = 'hello world';
-            const content2 = 'goodbye world';
-            const hash1 = sha256(content1);
-            const isValid = verify(content2, hash1);
-            expect(isValid).toBe(false);
-        });
-
-        it('should work with Buffer', () => {
-            const data = Buffer.from('test data');
-            const hash = sha256(data);
-            const isValid = verify(data, hash);
-            expect(isValid).toBe(true);
-        });
-    });
-
-    describe('fromUrlSafeBase64', () => {
-        it('should convert URL-safe base64 to standard base64', () => {
-            // Use a URL-safe string that contains both - and _ characters
-            const urlSafe = 'abc-def_ghi';
-            const standard = fromUrlSafeBase64(urlSafe);
-            
-            // Should replace - with + and _ with /
-            expect(standard).toContain('+');
-            expect(standard).toContain('/');
-            // Should add padding
-            expect(standard.endsWith('=')).toBe(true);
-        });
-
-        it('should add correct padding', () => {
-            // Test different padding scenarios
-            const testCases = [
-                { input: 'abc', expectedPadding: 1 },
-                { input: 'abcd', expectedPadding: 0 },
-                { input: 'abcde', expectedPadding: 3 },
-                { input: 'abcdef', expectedPadding: 2 },
-            ];
-
-            testCases.forEach(({ input, expectedPadding }) => {
-                const result = fromUrlSafeBase64(input);
-                const paddingCount = (result.match(/=/g) || []).length;
-                expect(paddingCount).toBe(expectedPadding);
-            });
-        });
-
-        it('should handle strings without special characters', () => {
-            const input = 'abcdefghijklmnop';
-            const result = fromUrlSafeBase64(input);
-            expect(result).toBeTruthy();
-        });
-    });
-
-    describe('toUrlSafeBase64', () => {
-        it('should convert standard base64 to URL-safe', () => {
-            const standard = 'uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=';
-            const urlSafe = toUrlSafeBase64(standard);
-            
-            // Should not contain standard base64 special characters
-            expect(urlSafe).not.toContain('+');
-            expect(urlSafe).not.toContain('/');
-            expect(urlSafe).not.toContain('=');
-            
-            // Should contain URL-safe replacements
-            expect(urlSafe).toContain('-');
-        });
-
-        it('should remove padding', () => {
-            const withPadding = 'abc=';
-            const result = toUrlSafeBase64(withPadding);
-            expect(result).not.toContain('=');
-            expect(result).toBe('abc');
-        });
-
-        it('should be reversible with fromUrlSafeBase64', () => {
-            // Start with a standard base64 string with special chars
-            const original = 'test+data/with==';
-            const urlSafe = toUrlSafeBase64(original);
-            const restored = fromUrlSafeBase64(urlSafe);
-            
-            // Should restore to equivalent base64 (padding might differ slightly)
-            expect(restored.replace(/=+$/, '')).toBe(original.replace(/=+$/, ''));
-        });
-    });
-
-    describe('Round-trip conversions', () => {
-        it('should maintain hash integrity through URL-safe conversion', () => {
-            const content = 'test content for hashing';
-            const hash = sha256(content);
-            
-            // Convert to standard base64 and back
-            const standard = fromUrlSafeBase64(hash);
-            const backToUrlSafe = toUrlSafeBase64(standard);
-            
-            expect(backToUrlSafe).toBe(hash);
-        });
-
-        it('should verify hash after conversion', () => {
-            const content = 'verification test';
-            const hash = sha256(content);
-            
-            // Convert and back
-            const standard = fromUrlSafeBase64(hash);
-            const urlSafe = toUrlSafeBase64(standard);
-            
-            // Should still verify
-            const isValid = verify(content, urlSafe);
-            expect(isValid).toBe(true);
-        });
-    });
-
-    describe('Edge cases', () => {
-        it('should handle very long strings', () => {
-            const longString = 'a'.repeat(10000);
-            const hash = sha256(longString);
-            expect(hash).toBeTruthy();
-            expect(hash.length).toBe(43);
-        });
-
-        it('should handle special characters', () => {
-            const special = '!@#$%^&*()_+-=[]{}|;:,.<>?';
-            const hash = sha256(special);
-            expect(hash).toBeTruthy();
-            
-            const isValid = verify(special, hash);
-            expect(isValid).toBe(true);
-        });
-
-        it('should handle newlines and whitespace', () => {
-            const withNewlines = 'line1\nline2\r\nline3\ttab';
-            const hash = sha256(withNewlines);
-            expect(hash).toBeTruthy();
-            
-            const isValid = verify(withNewlines, hash);
-            expect(isValid).toBe(true);
-        });
-    });
-});
+  describe('sha256', () => {
+    it('should hash a simple string', () => {
+      const input = 'hello world';
+      const hash = sha256(input);
+
+      // Verify it's URL-safe (no +, /, or =)
+      assert.ok(!hash.includes('+'));
+      assert.ok(!hash.includes('/'));
+      assert.ok(!hash.includes('='));
+
+      // Verify consistent output
+      const hash2 = sha256(input);
+      assert.strictEqual(hash, hash2);
+    });
+
+    it('should produce correct hash for known input', () => {
+      const input = 'hello world';
+      const expectedHash = 'uU0nuZNNPgilLlLX2n2r-sSE7-N6U4DukIj3rOLvzek';
+      const hash = sha256(input);
+      assert.strictEqual(hash, expectedHash);
+    });
+
+    it('should handle empty string', () => {
+      const hash = sha256('');
+      assert.ok(hash);
+      assert.strictEqual(typeof hash, 'string');
+    });
+
+    it('should handle unicode characters', () => {
+      const input = '你好世界 🌍';
+      const hash = sha256(input);
+      assert.ok(hash);
+      assert.strictEqual(typeof hash, 'string');
+
+      // Verify consistency
+      const hash2 = sha256(input);
+      assert.strictEqual(hash, hash2);
+    });
+
+    it('should handle Buffer input', () => {
+      const data = Buffer.from('hello world');
+      const hash = sha256(data);
+
+      // Should produce same hash as string input
+      const stringHash = sha256('hello world');
+      assert.strictEqual(hash, stringHash);
+    });
+
+    it('should produce different hashes for different inputs', () => {
+      const hash1 = sha256('hello');
+      const hash2 = sha256('world');
+      assert.notStrictEqual(hash1, hash2);
+    });
+
+    it('should produce 43-character URL-safe base64 string', () => {
+      const hash = sha256('test');
+      // SHA-256 produces 256 bits = 32 bytes
+      // Base64 encoding: 32 bytes * 4/3 = 42.67, rounded up = 43 chars (without padding)
+      assert.strictEqual(hash.length, 43);
+    });
+  });
+
+  describe('verify', () => {
+    it('should verify correct hash', () => {
+      const content = 'hello world';
+      const hash = sha256(content);
+      const isValid = verify(content, hash);
+      assert.strictEqual(isValid, true);
+    });
+
+    it('should reject incorrect hash', () => {
+      const content = 'hello world';
+      const wrongHash = 'incorrect_hash_value_here_1234567890';
+      const isValid = verify(content, wrongHash);
+      assert.strictEqual(isValid, false);
+    });
+
+    it('should reject hash for different content', () => {
+      const content1 = 'hello world';
+      const content2 = 'goodbye world';
+      const hash1 = sha256(content1);
+      const isValid = verify(content2, hash1);
+      assert.strictEqual(isValid, false);
+    });
+
+    it('should work with Buffer', () => {
+      const data = Buffer.from('test data');
+      const hash = sha256(data);
+      const isValid = verify(data, hash);
+      assert.strictEqual(isValid, true);
+    });
+  });
+
+  describe('fromUrlSafeBase64', () => {
+    it('should convert URL-safe base64 to standard base64', () => {
+      // Use a URL-safe string that contains both - and _ characters
+      const urlSafe = 'abc-def_ghi';
+      const standard = fromUrlSafeBase64(urlSafe);
+
+      // Should replace - with + and _ with /
+      assert.ok(standard.includes('+'));
+      assert.ok(standard.includes('/'));
+      // Should add padding
+      assert.strictEqual(standard.endsWith('='), true);
+    });
+
+    it('should add correct padding', () => {
+      // Test different padding scenarios
+      const testCases = [
+        { input: 'abc', expectedPadding: 1 },
+        { input: 'abcd', expectedPadding: 0 },
+        { input: 'abcde', expectedPadding: 3 },
+        { input: 'abcdef', expectedPadding: 2 },
+      ];
+
+      testCases.forEach(({ input, expectedPadding }) => {
+        const result = fromUrlSafeBase64(input);
+        const paddingCount = (result.match(/=/g) || []).length;
+        assert.strictEqual(paddingCount, expectedPadding);
+      });
+    });
+
+    it('should handle strings without special characters', () => {
+      const input = 'abcdefghijklmnop';
+      const result = fromUrlSafeBase64(input);
+      assert.ok(result);
+    });
+  });
+
+  describe('toUrlSafeBase64', () => {
+    it('should convert standard base64 to URL-safe', () => {
+      const standard = 'uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=';
+      const urlSafe = toUrlSafeBase64(standard);
+
+      // Should not contain standard base64 special characters
+      assert.ok(!urlSafe.includes('+'));
+      assert.ok(!urlSafe.includes('/'));
+      assert.ok(!urlSafe.includes('='));
+
+      // Should contain URL-safe replacements
+      assert.ok(urlSafe.includes('-'));
+    });
+
+    it('should remove padding', () => {
+      const withPadding = 'abc=';
+      const result = toUrlSafeBase64(withPadding);
+      assert.ok(!result.includes('='));
+      assert.strictEqual(result, 'abc');
+    });
+
+    it('should be reversible with fromUrlSafeBase64', () => {
+      // Start with a standard base64 string with special chars
+      const original = 'test+data/with==';
+      const urlSafe = toUrlSafeBase64(original);
+      const restored = fromUrlSafeBase64(urlSafe);
+
+      // Should restore to equivalent base64 (padding might differ slightly)
+      assert.strictEqual(restored.replace(/=+$/, ''), original.replace(/=+$/, ''));
+    });
+  });
+
+  describe('Round-trip conversions', () => {
+    it('should maintain hash integrity through URL-safe conversion', () => {
+      const content = 'test content for hashing';
+      const hash = sha256(content);
+
+      // Convert to standard base64 and back
+      const standard = fromUrlSafeBase64(hash);
+      const backToUrlSafe = toUrlSafeBase64(standard);
+
+      assert.strictEqual(backToUrlSafe, hash);
+    });
+
+    it('should verify hash after conversion', () => {
+      const content = 'verification test';
+      const hash = sha256(content);
+
+      // Convert and back
+      const standard = fromUrlSafeBase64(hash);
+      const urlSafe = toUrlSafeBase64(standard);
+
+      // Should still verify
+      const isValid = verify(content, urlSafe);
+      assert.strictEqual(isValid, true);
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle very long strings', () => {
+      const longString = 'a'.repeat(10000);
+      const hash = sha256(longString);
+      assert.ok(hash);
+      assert.strictEqual(hash.length, 43);
+    });
+
+    it('should handle special characters', () => {
+      const special = '!@#$%^&*()_+-=[]{}|;:,.<>?';
+      const hash = sha256(special);
+      assert.ok(hash);
+
+      const isValid = verify(special, hash);
+      assert.strictEqual(isValid, true);
+    });
+
+    it('should handle newlines and whitespace', () => {
+      const withNewlines = 'line1\nline2\r\nline3\ttab';
+      const hash = sha256(withNewlines);
+      assert.ok(hash);
+
+      const isValid = verify(withNewlines, hash);
+      assert.strictEqual(isValid, true);
+    });
+  });
+});

package/src/hash.ts

@@ -0,0 +1,99 @@
+/**
+ * Universal hash utilities using @noble/hashes
+ * Works in both browser and Node.js environments
+ */
+
+import { sha256 as nobleSha256 } from '@noble/hashes/sha2.js';
+
+/**
+ * Compute SHA-256 hash of a string and return it as URL-safe base64
+ * Works in both browser and Node.js environments
+ * @param input - The string or buffer to hash
+ * @returns URL-safe base64 encoded hash
+ */
+export const sha256 = (input: string | Uint8Array): string => {
+  let data: Uint8Array;
+
+  if (typeof input === 'string') {
+    const encoder = new TextEncoder();
+    data = encoder.encode(input);
+  } else {
+    data = input;
+  }
+
+  // Use @noble/hashes for consistent cross-platform hashing
+  const hashArray = nobleSha256(data);
+
+  // Convert to base64
+  const base64 = bytesToBase64(hashArray);
+
+  // Make URL-safe: remove padding and replace + with - and / with _
+  const urlSafe = base64.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+
+  return urlSafe;
+};
+
+/**
+ * Verify that content matches a given hash
+ * @param content - The content to verify
+ * @param hash - The expected hash
+ * @returns True if the hash matches
+ */
+export const verify = (content: string | Uint8Array, hash: string): boolean => {
+  const computed = sha256(content);
+  return computed === hash;
+};
+
+/**
+ * Convert URL-safe base64 back to standard base64
+ * @param urlSafe - URL-safe base64 string
+ * @returns Standard base64 string with padding
+ */
+export const fromUrlSafeBase64 = (urlSafe: string): string => {
+  const base64 = urlSafe.replace(/-/g, '+').replace(/_/g, '/');
+  // Add padding if needed
+  const padding = '='.repeat((4 - (base64.length % 4)) % 4);
+  return base64 + padding;
+};
+
+/**
+ * Convert standard base64 to URL-safe base64
+ * @param base64 - Standard base64 string
+ * @returns URL-safe base64 string without padding
+ */
+export const toUrlSafeBase64 = (base64: string): string => {
+  return base64.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+};
+
+/**
+ * Convert bytes to base64 string
+ * @param bytes - Uint8Array to convert
+ * @returns Base64 string
+ */
+function bytesToBase64(bytes: Uint8Array): string {
+  // Use btoa if available (browser), otherwise use Buffer (Node.js)
+  if (typeof btoa !== 'undefined') {
+    return btoa(String.fromCharCode(...Array.from(bytes)));
+  } else {
+    return Buffer.from(bytes).toString('base64');
+  }
+}
+
+/**
+ * Convert base64 string to bytes
+ * @param base64 - Base64 string to convert
+ * @returns Uint8Array
+ */
+export function base64ToBytes(base64: string): Uint8Array {
+  // Use atob if available (browser), otherwise use Buffer (Node.js)
+  if (typeof atob !== 'undefined') {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+  } else {
+    return new Uint8Array(Buffer.from(base64, 'base64'));
+  }
+}