@kya-os/mcp-i-core 1.3.12 → 1.3.14

package/src/delegation/__tests__/did-key-resolver.test.ts

@@ -1,265 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  createDidKeyResolver,
-  isEd25519DidKey,
-  extractPublicKeyFromDidKey,
-  publicKeyToJwk,
-  resolveDidKeySync,
-} from "../did-key-resolver";
-import { base58Encode, base58Decode, isValidBase58 } from "../../utils/base58";
-
-/**
- * Tests for did:key resolver and base58 utilities
- *
- * These tests verify the Phase 3 VC verification infrastructure:
- * - Base58 encoding/decoding for multibase keys
- * - did:key resolution to DID Documents
- * - Ed25519 public key extraction
- */
-
-describe("Base58 Utilities", () => {
-  describe("base58Encode", () => {
-    it("should encode empty bytes", () => {
-      expect(base58Encode(new Uint8Array([]))).toBe("");
-    });
-
-    it("should encode single byte", () => {
-      expect(base58Encode(new Uint8Array([0]))).toBe("1");
-      expect(base58Encode(new Uint8Array([1])).length).toBeGreaterThan(0);
-    });
-
-    it("should encode known values", () => {
-      // 'Hello' in bytes
-      const helloBytes = new TextEncoder().encode("Hello");
-      const encoded = base58Encode(helloBytes);
-      expect(encoded.length).toBeGreaterThan(0);
-      expect(isValidBase58(encoded)).toBe(true);
-    });
-
-    it("should handle leading zeros", () => {
-      const withLeadingZeros = new Uint8Array([0, 0, 1, 2, 3]);
-      const encoded = base58Encode(withLeadingZeros);
-      // Leading zeros become '1' in base58
-      expect(encoded.startsWith("11")).toBe(true);
-    });
-  });
-
-  describe("base58Decode", () => {
-    it("should decode empty string", () => {
-      expect(base58Decode("")).toEqual(new Uint8Array([]));
-    });
-
-    it("should decode leading '1' as zero bytes", () => {
-      const result = base58Decode("111");
-      expect(result).toEqual(new Uint8Array([0, 0, 0]));
-    });
-
-    it("should throw on invalid characters", () => {
-      // '0', 'O', 'I', 'l' are not in base58 alphabet
-      expect(() => base58Decode("0invalid")).toThrow("Invalid base58 character");
-      expect(() => base58Decode("testO")).toThrow("Invalid base58 character");
-      expect(() => base58Decode("testI")).toThrow("Invalid base58 character");
-      expect(() => base58Decode("testl")).toThrow("Invalid base58 character");
-    });
-
-    it("should roundtrip with base58Encode", () => {
-      const originalBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
-      const encoded = base58Encode(originalBytes);
-      const decoded = base58Decode(encoded);
-      expect(decoded).toEqual(originalBytes);
-    });
-
-    it("should roundtrip Ed25519 key bytes", () => {
-      // Simulate a 32-byte Ed25519 public key with multicodec prefix
-      const ed25519Prefix = new Uint8Array([0xed, 0x01]);
-      const mockPublicKey = new Uint8Array(32).fill(42);
-      const fullBytes = new Uint8Array([...ed25519Prefix, ...mockPublicKey]);
-
-      const encoded = base58Encode(fullBytes);
-      const decoded = base58Decode(encoded);
-      expect(decoded).toEqual(fullBytes);
-    });
-  });
-
-  describe("isValidBase58", () => {
-    it("should return true for empty string", () => {
-      expect(isValidBase58("")).toBe(true);
-    });
-
-    it("should return true for valid base58 strings", () => {
-      expect(isValidBase58("123456789")).toBe(true);
-      expect(isValidBase58("ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")).toBe(true);
-    });
-
-    it("should return false for invalid characters", () => {
-      expect(isValidBase58("0")).toBe(false);
-      expect(isValidBase58("O")).toBe(false);
-      expect(isValidBase58("I")).toBe(false);
-      expect(isValidBase58("l")).toBe(false);
-    });
-  });
-});
-
-describe("did:key Resolver", () => {
-  // Known test vector for Ed25519 did:key
-  // This creates a deterministic did:key from known public key bytes
-  const createTestDidKey = (publicKeyBytes: Uint8Array): string => {
-    const prefix = new Uint8Array([0xed, 0x01]); // Ed25519 multicodec
-    const fullBytes = new Uint8Array([...prefix, ...publicKeyBytes]);
-    return `did:key:z${base58Encode(fullBytes)}`;
-  };
-
-  describe("isEd25519DidKey", () => {
-    it("should return true for Ed25519 did:key", () => {
-      // Ed25519 keys start with z6Mk
-      expect(isEd25519DidKey("did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK")).toBe(true);
-    });
-
-    it("should return false for non-did:key", () => {
-      expect(isEd25519DidKey("did:web:example.com")).toBe(false);
-      expect(isEd25519DidKey("did:example:123")).toBe(false);
-    });
-
-    it("should return false for non-Ed25519 did:key", () => {
-      // Secp256k1 keys start with z6Ls or other prefixes
-      expect(isEd25519DidKey("did:key:z7r8os")).toBe(false);
-      expect(isEd25519DidKey("did:key:zQ3s")).toBe(false);
-    });
-
-    it("should return false for invalid did:key format", () => {
-      expect(isEd25519DidKey("did:key:")).toBe(false);
-      expect(isEd25519DidKey("did:key:invalid")).toBe(false);
-    });
-  });
-
-  describe("extractPublicKeyFromDidKey", () => {
-    it("should extract public key bytes from valid did:key", () => {
-      const mockPublicKey = new Uint8Array(32).map((_, i) => i);
-      const didKey = createTestDidKey(mockPublicKey);
-
-      const extractedKey = extractPublicKeyFromDidKey(didKey);
-      expect(extractedKey).not.toBeNull();
-      expect(extractedKey).toEqual(mockPublicKey);
-    });
-
-    it("should return null for non-did:key", () => {
-      expect(extractPublicKeyFromDidKey("did:web:example.com")).toBeNull();
-    });
-
-    it("should return null for invalid multicodec prefix", () => {
-      // Create a did:key with wrong prefix (not Ed25519)
-      const wrongPrefix = new Uint8Array([0x00, 0x00]); // Not Ed25519
-      const mockPublicKey = new Uint8Array(32).fill(1);
-      const fullBytes = new Uint8Array([...wrongPrefix, ...mockPublicKey]);
-      const invalidDid = `did:key:z${base58Encode(fullBytes)}`;
-
-      expect(extractPublicKeyFromDidKey(invalidDid)).toBeNull();
-    });
-
-    it("should return null for too short key", () => {
-      const shortBytes = new Uint8Array([0xed, 0x01, 1, 2, 3]); // Only 3 bytes of key
-      const shortDid = `did:key:z${base58Encode(shortBytes)}`;
-
-      expect(extractPublicKeyFromDidKey(shortDid)).toBeNull();
-    });
-  });
-
-  describe("publicKeyToJwk", () => {
-    it("should convert public key bytes to JWK format", () => {
-      const publicKeyBytes = new Uint8Array(32).map((_, i) => i);
-      const jwk = publicKeyToJwk(publicKeyBytes);
-
-      expect(jwk.kty).toBe("OKP");
-      expect(jwk.crv).toBe("Ed25519");
-      expect(jwk.x).toBeDefined();
-      expect(typeof jwk.x).toBe("string");
-    });
-
-    it("should produce base64url-encoded x value", () => {
-      const publicKeyBytes = new Uint8Array(32).fill(0);
-      const jwk = publicKeyToJwk(publicKeyBytes);
-
-      // Base64url should not contain +, /, or =
-      expect(jwk.x).not.toMatch(/[+/=]/);
-    });
-  });
-
-  describe("createDidKeyResolver", () => {
-    it("should resolve Ed25519 did:key to DID Document", async () => {
-      const mockPublicKey = new Uint8Array(32).map((_, i) => i);
-      const didKey = createTestDidKey(mockPublicKey);
-
-      const resolver = createDidKeyResolver();
-      const didDoc = await resolver.resolve(didKey);
-
-      expect(didDoc).not.toBeNull();
-      expect(didDoc?.id).toBe(didKey);
-      expect(didDoc?.verificationMethod).toHaveLength(1);
-      expect(didDoc?.verificationMethod?.[0].type).toBe("Ed25519VerificationKey2020");
-      expect(didDoc?.verificationMethod?.[0].controller).toBe(didKey);
-      expect(didDoc?.verificationMethod?.[0].publicKeyJwk).toBeDefined();
-      expect(didDoc?.authentication).toContain(`${didKey}#keys-1`);
-      expect(didDoc?.assertionMethod).toContain(`${didKey}#keys-1`);
-    });
-
-    it("should return null for non-Ed25519 did:key", async () => {
-      const resolver = createDidKeyResolver();
-      const result = await resolver.resolve("did:key:z7r8os");
-
-      expect(result).toBeNull();
-    });
-
-    it("should return null for non-did:key DIDs", async () => {
-      const resolver = createDidKeyResolver();
-      const result = await resolver.resolve("did:web:example.com");
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("resolveDidKeySync", () => {
-    it("should synchronously resolve Ed25519 did:key", () => {
-      const mockPublicKey = new Uint8Array(32).map((_, i) => i);
-      const didKey = createTestDidKey(mockPublicKey);
-
-      const didDoc = resolveDidKeySync(didKey);
-
-      expect(didDoc).not.toBeNull();
-      expect(didDoc?.id).toBe(didKey);
-      expect(didDoc?.verificationMethod).toHaveLength(1);
-    });
-
-    it("should return null for invalid DIDs", () => {
-      expect(resolveDidKeySync("did:web:example.com")).toBeNull();
-      expect(resolveDidKeySync("did:key:invalid")).toBeNull();
-    });
-  });
-});
-
-describe("VC-JWT Roundtrip Integration", () => {
-  it("should correctly resolve did:key generated by UserDidManager pattern", async () => {
-    // This test simulates the pattern used in UserDidManager.generateKeyPair()
-    // which creates did:key DIDs for users
-
-    // Simulate generating a random Ed25519 key (32 bytes)
-    const mockPublicKey = crypto.getRandomValues(new Uint8Array(32));
-
-    // Encode as did:key (same pattern as UserDidManager)
-    const multicodecPrefix = new Uint8Array([0xed, 0x01]);
-    const multicodecBytes = new Uint8Array([...multicodecPrefix, ...mockPublicKey]);
-    const multibaseEncoded = base58Encode(multicodecBytes);
-    const didKey = `did:key:z${multibaseEncoded}`;
-
-    // Verify we can resolve this did:key back to get the public key
-    const resolver = createDidKeyResolver();
-    const didDoc = await resolver.resolve(didKey);
-
-    expect(didDoc).not.toBeNull();
-    expect(didDoc?.id).toBe(didKey);
-    expect(didDoc?.verificationMethod?.[0]?.publicKeyJwk).toBeDefined();
-
-    // Extract public key and verify it matches
-    const extractedKey = extractPublicKeyFromDidKey(didKey);
-    expect(extractedKey).toEqual(mockPublicKey);
-  });
-});

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

@@ -1,152 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { canonicalizeJSON } from "../utils.js";
-
-describe("canonicalizeJSON", () => {
-  it("should canonicalize null", () => {
-    expect(canonicalizeJSON(null)).toBe("null");
-  });
-
-  it("should canonicalize boolean true", () => {
-    expect(canonicalizeJSON(true)).toBe("true");
-  });
-
-  it("should canonicalize boolean false", () => {
-    expect(canonicalizeJSON(false)).toBe("false");
-  });
-
-  it("should canonicalize number zero", () => {
-    expect(canonicalizeJSON(0)).toBe("0");
-  });
-
-  it("should canonicalize positive number", () => {
-    expect(canonicalizeJSON(42)).toBe("42");
-  });
-
-  it("should canonicalize negative number", () => {
-    expect(canonicalizeJSON(-42)).toBe("-42");
-  });
-
-  it("should canonicalize decimal number", () => {
-    expect(canonicalizeJSON(3.14)).toBe("3.14");
-  });
-
-  it("should throw error for non-finite number (Infinity)", () => {
-    expect(() => canonicalizeJSON(Infinity)).toThrow("Cannot canonicalize non-finite number");
-  });
-
-  it("should throw error for non-finite number (NaN)", () => {
-    expect(() => canonicalizeJSON(NaN)).toThrow("Cannot canonicalize non-finite number");
-  });
-
-  it("should canonicalize empty string", () => {
-    expect(canonicalizeJSON("")).toBe('""');
-  });
-
-  it("should canonicalize string", () => {
-    expect(canonicalizeJSON("hello")).toBe('"hello"');
-  });
-
-  it("should canonicalize string with special characters", () => {
-    expect(canonicalizeJSON('hello "world"')).toBe('"hello \\"world\\""');
-  });
-
-  it("should canonicalize empty array", () => {
-    expect(canonicalizeJSON([])).toBe("[]");
-  });
-
-  it("should canonicalize array with primitives", () => {
-    const result = canonicalizeJSON([1, "two", true, null]);
-    expect(result).toBe('[1,"two",true,null]');
-  });
-
-  it("should canonicalize nested arrays", () => {
-    const result = canonicalizeJSON([[1, 2], [3, 4]]);
-    expect(result).toBe("[[1,2],[3,4]]");
-  });
-
-  it("should canonicalize empty object", () => {
-    expect(canonicalizeJSON({})).toBe("{}");
-  });
-
-  it("should canonicalize object with sorted keys", () => {
-    const obj = { z: 3, a: 1, m: 2 };
-    const result = canonicalizeJSON(obj);
-    expect(result).toBe('{"a":1,"m":2,"z":3}');
-  });
-
-  it("should canonicalize object with string values", () => {
-    const obj = { name: "test", value: "hello" };
-    const result = canonicalizeJSON(obj);
-    expect(result).toBe('{"name":"test","value":"hello"}');
-  });
-
-  it("should canonicalize nested objects", () => {
-    const obj = { a: { b: { c: 1 } } };
-    const result = canonicalizeJSON(obj);
-    expect(result).toBe('{"a":{"b":{"c":1}}}');
-  });
-
-  it("should canonicalize object with array values", () => {
-    const obj = { items: [1, 2, 3] };
-    const result = canonicalizeJSON(obj);
-    expect(result).toBe('{"items":[1,2,3]}');
-  });
-
-  it("should canonicalize complex nested structure", () => {
-    const obj = {
-      z: "last",
-      a: {
-        nested: [1, { deep: true }],
-        value: 42,
-      },
-      m: ["array", "values"],
-    };
-    const result = canonicalizeJSON(obj);
-    // Keys should be sorted: a, m, z
-    expect(result).toContain('"a"');
-    expect(result).toContain('"m"');
-    expect(result).toContain('"z"');
-    expect(result.indexOf('"a"')).toBeLessThan(result.indexOf('"m"'));
-    expect(result.indexOf('"m"')).toBeLessThan(result.indexOf('"z"'));
-  });
-
-  it("should produce identical output for same input (deterministic)", () => {
-    const obj = { z: 3, a: 1, m: 2 };
-    const result1 = canonicalizeJSON(obj);
-    const result2 = canonicalizeJSON(obj);
-    expect(result1).toBe(result2);
-  });
-
-  it("should handle object with null values", () => {
-    const obj = { a: null, b: "value" };
-    const result = canonicalizeJSON(obj);
-    expect(result).toBe('{"a":null,"b":"value"}');
-  });
-
-  it("should handle object with boolean values", () => {
-    const obj = { enabled: true, disabled: false };
-    const result = canonicalizeJSON(obj);
-    expect(result).toBe('{"disabled":false,"enabled":true}');
-  });
-
-  it("should throw error for undefined", () => {
-    expect(() => canonicalizeJSON(undefined)).toThrow("Cannot canonicalize type: undefined");
-  });
-
-  it("should throw error for function", () => {
-    expect(() => canonicalizeJSON(() => {})).toThrow("Cannot canonicalize type: function");
-  });
-
-  it("should handle unicode strings", () => {
-    const result = canonicalizeJSON("hello 世界");
-    expect(result).toBe('"hello 世界"');
-  });
-
-  it("should handle object with numeric keys (sorted as strings)", () => {
-    const obj = { "10": "ten", "2": "two", "1": "one" };
-    const result = canonicalizeJSON(obj);
-    // Keys sorted lexicographically: "1", "10", "2"
-    expect(result).toBe('{"1":"one","10":"ten","2":"two"}');
-  });
-});
-