@mcp-i/core 0.1.0

package/src/utils/__tests__/base58.test.ts

@@ -0,0 +1,281 @@
+/**
+ * Tests for Base58 Utilities
+ */
+
+import { describe, it, expect } from "vitest";
+import { base58Encode, base58Decode, isValidBase58 } from "../base58.js";
+
+describe("Base58 Utilities", () => {
+  describe("base58Encode", () => {
+    it("should encode bytes to Base58", () => {
+      const bytes = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
+      const encoded = base58Encode(bytes);
+
+      expect(encoded).toBeDefined();
+      expect(typeof encoded).toBe("string");
+      expect(encoded.length).toBeGreaterThan(0);
+    });
+
+    it("should encode empty bytes to empty string", () => {
+      const bytes = new Uint8Array(0);
+      const encoded = base58Encode(bytes);
+
+      expect(encoded).toBe("");
+    });
+
+    it("should encode single byte", () => {
+      const bytes = new Uint8Array([42]);
+      const encoded = base58Encode(bytes);
+
+      expect(encoded).toBeDefined();
+      expect(encoded.length).toBeGreaterThan(0);
+    });
+
+    it("should encode bytes with leading zeros", () => {
+      const bytes = new Uint8Array([0, 0, 1, 2, 3]);
+      const encoded = base58Encode(bytes);
+
+      // Leading zeros should be encoded as '1'
+      expect(encoded.startsWith("1")).toBe(true);
+    });
+
+    it("should encode all zero bytes", () => {
+      const bytes = new Uint8Array([0, 0, 0]);
+      const encoded = base58Encode(bytes);
+
+      expect(encoded).toBeDefined();
+      // All zeros should result in multiple '1' characters
+      expect(encoded.length).toBeGreaterThan(0);
+    });
+
+    it("should produce deterministic output", () => {
+      const bytes = new Uint8Array([1, 2, 3, 4, 5]);
+      const encoded1 = base58Encode(bytes);
+      const encoded2 = base58Encode(bytes);
+
+      expect(encoded1).toBe(encoded2);
+    });
+  });
+
+  describe("base58Decode", () => {
+    it("should decode Base58 to bytes", () => {
+      const original = new Uint8Array([72, 101, 108, 108, 111]);
+      const encoded = base58Encode(original);
+      const decoded = base58Decode(encoded);
+
+      expect(decoded).toEqual(original);
+    });
+
+    it("should decode empty string to empty bytes", () => {
+      const decoded = base58Decode("");
+
+      expect(decoded).toEqual(new Uint8Array(0));
+    });
+
+    it("should decode string with leading '1' characters", () => {
+      // Leading '1' characters represent leading zeros
+      const encoded = "11ABC";
+      const decoded = base58Decode(encoded);
+
+      expect(decoded).toBeDefined();
+      expect(decoded[0]).toBe(0);
+      expect(decoded[1]).toBe(0);
+    });
+
+    it("should round-trip encode and decode", () => {
+      const testCases = [
+        new Uint8Array([1, 2, 3]),
+        new Uint8Array([255, 255, 255]),
+        new Uint8Array([0, 1, 2]),
+        new Uint8Array([128, 64, 32]),
+      ];
+
+      for (const bytes of testCases) {
+        const encoded = base58Encode(bytes);
+        const decoded = base58Decode(encoded);
+
+        expect(decoded).toEqual(bytes);
+      }
+    });
+
+    it("should throw error for invalid Base58 character", () => {
+      expect(() => {
+        base58Decode("invalid@base58");
+      }).toThrow("Invalid base58 character");
+    });
+
+    it("should throw error for character '0'", () => {
+      expect(() => {
+        base58Decode("ABC0DEF");
+      }).toThrow("Invalid base58 character");
+    });
+
+    it("should throw error for character 'O'", () => {
+      expect(() => {
+        base58Decode("ABCODEF");
+      }).toThrow("Invalid base58 character");
+    });
+
+    it("should throw error for character 'I'", () => {
+      expect(() => {
+        base58Decode("ABCDIEF");
+      }).toThrow("Invalid base58 character");
+    });
+
+    it("should throw error for character 'l'", () => {
+      expect(() => {
+        base58Decode("ABCDlEF");
+      }).toThrow("Invalid base58 character");
+    });
+  });
+
+  describe("isValidBase58", () => {
+    it("should return true for valid Base58 string", () => {
+      const valid = base58Encode(new Uint8Array([1, 2, 3]));
+      expect(isValidBase58(valid)).toBe(true);
+    });
+
+    it("should return true for empty string", () => {
+      expect(isValidBase58("")).toBe(true);
+    });
+
+    it("should return false for string with invalid character '0'", () => {
+      expect(isValidBase58("ABC0DEF")).toBe(false);
+    });
+
+    it("should return false for string with invalid character 'O'", () => {
+      expect(isValidBase58("ABCODEF")).toBe(false);
+    });
+
+    it("should return false for string with invalid character 'I'", () => {
+      expect(isValidBase58("ABCDIEF")).toBe(false);
+    });
+
+    it("should return false for string with invalid character 'l'", () => {
+      expect(isValidBase58("ABCDlEF")).toBe(false);
+    });
+
+    it("should return false for string with special characters", () => {
+      expect(isValidBase58("ABC@DEF")).toBe(false);
+      expect(isValidBase58("ABC-DEF")).toBe(false);
+      expect(isValidBase58("ABC DEF")).toBe(false);
+    });
+
+    it("should return true for all valid Base58 characters", () => {
+      const validChars =
+        "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+      expect(isValidBase58(validChars)).toBe(true);
+    });
+
+    it("should return true for string with only '1' characters", () => {
+      expect(isValidBase58("1111")).toBe(true);
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle large byte arrays", () => {
+      const largeArray = new Uint8Array(100);
+      for (let i = 0; i < 100; i++) {
+        largeArray[i] = i % 256;
+      }
+
+      const encoded = base58Encode(largeArray);
+      const decoded = base58Decode(encoded);
+
+      expect(decoded).toEqual(largeArray);
+    });
+
+    it("should handle bytes with maximum values", () => {
+      const maxBytes = new Uint8Array([255, 255, 255, 255]);
+      const encoded = base58Encode(maxBytes);
+      const decoded = base58Decode(encoded);
+
+      expect(decoded).toEqual(maxBytes);
+    });
+
+    it("should handle single byte encoding/decoding", () => {
+      for (let i = 0; i < 256; i++) {
+        const bytes = new Uint8Array([i]);
+        const encoded = base58Encode(bytes);
+        const decoded = base58Decode(encoded);
+
+        expect(decoded).toEqual(bytes);
+      }
+    });
+
+    it("should handle mixed leading zeros and non-zero bytes", () => {
+      const testCases = [
+        new Uint8Array([0, 1]),
+        new Uint8Array([0, 0, 1]),
+        new Uint8Array([0, 255]),
+        new Uint8Array([0, 0, 0, 1, 2, 3]),
+      ];
+
+      for (const bytes of testCases) {
+        const encoded = base58Encode(bytes);
+        const decoded = base58Decode(encoded);
+
+        expect(decoded).toEqual(bytes);
+      }
+    });
+
+    it("should produce shorter output for small values", () => {
+      const small = new Uint8Array([1]);
+      const large = new Uint8Array([255, 255, 255]);
+
+      const smallEncoded = base58Encode(small);
+      const largeEncoded = base58Encode(large);
+
+      // Small values should produce shorter Base58 strings
+      expect(smallEncoded.length).toBeLessThan(largeEncoded.length);
+    });
+  });
+
+  describe("Real-world DID:key Examples", () => {
+    it("should encode/decode Ed25519 public key bytes", () => {
+      // Example Ed25519 public key (32 bytes)
+      const ed25519Key = new Uint8Array([
+        0xed,
+        0x01, // Ed25519 multicodec prefix
+        0x12,
+        0x34,
+        0x56,
+        0x78,
+        0x9a,
+        0xbc,
+        0xde,
+        0xf0,
+        0x12,
+        0x34,
+        0x56,
+        0x78,
+        0x9a,
+        0xbc,
+        0xde,
+        0xf0,
+        0x12,
+        0x34,
+        0x56,
+        0x78,
+        0x9a,
+        0xbc,
+        0xde,
+        0xf0,
+        0x12,
+        0x34,
+        0x56,
+        0x78,
+        0x9a,
+        0xbc,
+        0xde,
+        0xf0,
+      ]);
+
+      const encoded = base58Encode(ed25519Key);
+      expect(isValidBase58(encoded)).toBe(true);
+
+      const decoded = base58Decode(encoded);
+      expect(decoded).toEqual(ed25519Key);
+    });
+  });
+});

package/src/utils/__tests__/base64.test.ts

@@ -0,0 +1,239 @@
+/**
+ * Tests for Base64URL Utilities
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  base64urlDecodeToString,
+  base64urlDecodeToBytes,
+  base64urlEncodeFromString,
+  base64urlEncodeFromBytes,
+  bytesToBase64,
+  base64ToBytes,
+} from "../base64.js";
+
+describe("Base64URL Utilities", () => {
+  describe("base64urlEncodeFromString", () => {
+    it("should encode string to base64url", () => {
+      const input = "Hello, World!";
+      const encoded = base64urlEncodeFromString(input);
+
+      expect(encoded).toBeDefined();
+      expect(encoded).not.toContain("+");
+      expect(encoded).not.toContain("/");
+      expect(encoded).not.toContain("=");
+    });
+
+    it("should encode empty string", () => {
+      const encoded = base64urlEncodeFromString("");
+      expect(encoded).toBe("");
+    });
+
+    it("should encode special characters", () => {
+      const input = "test@example.com";
+      const encoded = base64urlEncodeFromString(input);
+      const decoded = base64urlDecodeToString(encoded);
+
+      expect(decoded).toBe(input);
+    });
+
+    it("should encode Unicode characters", () => {
+      // In Node.js, Buffer.from handles Unicode correctly
+      // btoa doesn't handle Unicode, but our function falls back to Buffer
+      // Test with characters that work in both paths
+      const input = "Hello 世界 World";
+
+      // This should work in Node.js (Buffer path)
+      const encoded = base64urlEncodeFromString(input);
+      const decoded = base64urlDecodeToString(encoded);
+
+      expect(decoded).toBe(input);
+    });
+  });
+
+  describe("base64urlDecodeToString", () => {
+    it("should decode base64url string", () => {
+      const original = "Hello, World!";
+      const encoded = base64urlEncodeFromString(original);
+      const decoded = base64urlDecodeToString(encoded);
+
+      expect(decoded).toBe(original);
+    });
+
+    it("should decode string without padding", () => {
+      // Base64URL strings don't have padding
+      const encoded = "SGVsbG8gV29ybGQ"; // "Hello World" in base64url
+      const decoded = base64urlDecodeToString(encoded);
+
+      expect(decoded).toBe("Hello World");
+    });
+
+    it("should decode string with padding", () => {
+      // Even if padding is present, it should work
+      const encoded = "SGVsbG8="; // "Hello" with padding
+      const decoded = base64urlDecodeToString(encoded);
+
+      expect(decoded).toBe("Hello");
+    });
+
+    it("should throw error for invalid base64url string", () => {
+      expect(() => {
+        base64urlDecodeToString("invalid-base64!!!");
+      }).toThrow("Invalid base64url string");
+    });
+
+    it("should throw error for string with invalid characters", () => {
+      expect(() => {
+        base64urlDecodeToString("SGVsbG8@World");
+      }).toThrow("Invalid base64url string");
+    });
+
+    it("should handle empty string", () => {
+      const decoded = base64urlDecodeToString("");
+      expect(decoded).toBe("");
+    });
+  });
+
+  describe("base64urlEncodeFromBytes", () => {
+    it("should encode Uint8Array to base64url", () => {
+      const bytes = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
+      const encoded = base64urlEncodeFromBytes(bytes);
+
+      expect(encoded).toBeDefined();
+      expect(encoded).not.toContain("+");
+      expect(encoded).not.toContain("/");
+      expect(encoded).not.toContain("=");
+    });
+
+    it("should encode empty Uint8Array", () => {
+      const bytes = new Uint8Array(0);
+      const encoded = base64urlEncodeFromBytes(bytes);
+      expect(encoded).toBe("");
+    });
+
+    it("should round-trip encode and decode", () => {
+      const original = new Uint8Array([1, 2, 3, 4, 5, 255]);
+      const encoded = base64urlEncodeFromBytes(original);
+      const decoded = base64urlDecodeToBytes(encoded);
+
+      expect(decoded).toEqual(original);
+    });
+  });
+
+  describe("base64urlDecodeToBytes", () => {
+    it("should decode base64url to Uint8Array", () => {
+      const original = new Uint8Array([72, 101, 108, 108, 111]);
+      const encoded = base64urlEncodeFromBytes(original);
+      const decoded = base64urlDecodeToBytes(encoded);
+
+      expect(decoded).toEqual(original);
+    });
+
+    it("should decode without padding", () => {
+      const encoded = "SGVsbG8"; // "Hello" without padding
+      const decoded = base64urlDecodeToBytes(encoded);
+
+      expect(decoded).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
+    });
+
+    it("should throw error for invalid base64url", () => {
+      expect(() => {
+        base64urlDecodeToBytes("invalid!!!");
+      }).toThrow(); // atob throws "Invalid character"
+    });
+
+    it("should handle empty string", () => {
+      const decoded = base64urlDecodeToBytes("");
+      expect(decoded).toEqual(new Uint8Array(0));
+    });
+  });
+
+  describe("bytesToBase64", () => {
+    it("should convert bytes to standard base64", () => {
+      const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+      const base64 = bytesToBase64(bytes);
+
+      expect(base64).toBeDefined();
+      expect(base64).toBe("SGVsbG8="); // Standard base64 includes padding
+    });
+
+    it("should handle empty bytes", () => {
+      const bytes = new Uint8Array(0);
+      const base64 = bytesToBase64(bytes);
+      expect(base64).toBe("");
+    });
+
+    it("should include padding when needed", () => {
+      const bytes = new Uint8Array([72]); // Single byte
+      const base64 = bytesToBase64(bytes);
+      expect(base64).toContain("="); // Should have padding
+    });
+  });
+
+  describe("base64ToBytes", () => {
+    it("should convert standard base64 to bytes", () => {
+      const base64 = "SGVsbG8="; // "Hello" in standard base64
+      const bytes = base64ToBytes(base64);
+
+      expect(bytes).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
+    });
+
+    it("should handle base64 without padding", () => {
+      const base64 = "SGVsbG8"; // Without padding
+      const bytes = base64ToBytes(base64);
+
+      expect(bytes).toBeDefined();
+    });
+
+    it("should handle empty string", () => {
+      const bytes = base64ToBytes("");
+      expect(bytes).toEqual(new Uint8Array(0));
+    });
+
+    it("should round-trip with bytesToBase64", () => {
+      const original = new Uint8Array([1, 2, 3, 255, 0]);
+      const base64 = bytesToBase64(original);
+      const decoded = base64ToBytes(base64);
+
+      expect(decoded).toEqual(original);
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle large byte arrays", () => {
+      const largeArray = new Uint8Array(1000);
+      for (let i = 0; i < 1000; i++) {
+        largeArray[i] = i % 256;
+      }
+
+      const encoded = base64urlEncodeFromBytes(largeArray);
+      const decoded = base64urlDecodeToBytes(encoded);
+
+      expect(decoded).toEqual(largeArray);
+    });
+
+    it("should handle bytes with all zeros", () => {
+      const zeros = new Uint8Array([0, 0, 0, 0]);
+      const encoded = base64urlEncodeFromBytes(zeros);
+      const decoded = base64urlDecodeToBytes(encoded);
+
+      expect(decoded).toEqual(zeros);
+    });
+
+    it("should handle bytes with all 255s", () => {
+      const maxBytes = new Uint8Array([255, 255, 255, 255]);
+      const encoded = base64urlEncodeFromBytes(maxBytes);
+      const decoded = base64urlDecodeToBytes(encoded);
+
+      expect(decoded).toEqual(maxBytes);
+    });
+
+    it("should handle single byte", () => {
+      const single = new Uint8Array([42]);
+      const encoded = base64urlEncodeFromBytes(single);
+      const decoded = base64urlDecodeToBytes(encoded);
+
+      expect(decoded).toEqual(single);
+    });
+  });
+});