fix: w3id builder

Author: coodos

infrastructure/w3id/src/index.ts

@@ -11,7 +11,7 @@ import { generateRandomAlphaNum } from "./utils/rand";
 import { v4 as uuidv4 } from "uuid";
 import { generateUuid } from "./utils/uuid";
 
-class W3ID {
+export class W3ID {
     constructor(
         public id: string,
         public logs?: IDLogManager,
@@ -23,6 +23,7 @@ export class W3IDBuilder {
     private repository?: StorageSpec<LogEvent, LogEvent>;
     private entropy?: string;
     private namespace?: string;
+    private nextKeyHash?: string;
 
     public withEntropy(str: string): W3IDBuilder {
         this.entropy = str;
@@ -46,7 +47,12 @@ export class W3IDBuilder {
         return this;
     }
 
-    public build(): W3ID {
+    public withNextKeyHash(hash: string): W3IDBuilder {
+        this.nextKeyHash = hash;
+        return this;
+    }
+
+    public async build(): Promise<W3ID> {
         this.entropy = this.entropy ?? generateRandomAlphaNum();
         this.namespace = this.namespace ?? uuidv4();
         const id = generateUuid(this.entropy, this.namespace);
@@ -57,7 +63,16 @@ export class W3IDBuilder {
                 throw new Error(
                     "Repository is required, pass with \`withRepository\` method",
                 );
+
+            if (!this.nextKeyHash)
+                throw new Error(
+                    "NextKeyHash is required pass with \`withNextKeyHash\` method",
+                );
             const logs = new IDLogManager(this.repository, this.signer);
+            await logs.createLogEvent({
+                id,
+                nextKeyHashes: [this.nextKeyHash],
+            });
             return new W3ID(id, logs);
         }
     }

infrastructure/w3id/src/logs/log-manager.ts

@@ -132,9 +132,10 @@ export class IDLogManager {
 
     private async createGenesisEntry(options: GenesisLogOptions) {
         const { id, nextKeyHashes } = options;
+        const idTag = id.includes("@") ? id.split("@")[1] : id;
         const logEvent: LogEvent = {
             id,
-            versionId: `0-${id.split("@")[1]}`,
+            versionId: `0-${idTag}`,
             versionTime: new Date(Date.now()),
             updateKeys: [this.signer.pubKey],
             nextKeyHashes: nextKeyHashes,

infrastructure/w3id/tests/logs/log.test.ts

@@ -24,7 +24,7 @@ import {
     MalformedIndexChainError,
 } from "../../src/errors/errors.ts";
 
-class InMemoryStorage<T extends LogEvent, K extends LogEvent>
+export class InMemoryStorage<T extends LogEvent, K extends LogEvent>
     implements StorageSpec<T, K>
 {
     private data: K[] = [];
@@ -69,7 +69,7 @@ const signer = createSigner(keyPair);
 const logManager = new IDLogManager(InMemoryStorage.build(), signer);
 const w3id = `@${generateUuid("asdfa")}`;
 
-const verifierCallback: VerifierCallback = async (
+export const verifierCallback: VerifierCallback = async (
     message: string,
     signature: string,
     pubKey: string,
@@ -86,7 +86,7 @@ const verifierCallback: VerifierCallback = async (
     return isValid;
 };
 
-function createSigner(keyPair: nacl.SignKeyPair): Signer {
+export function createSigner(keyPair: nacl.SignKeyPair): Signer {
     const publicKey = uint8ArrayToHex(keyPair.publicKey);
     const signer: Signer = {
         pubKey: publicKey,

infrastructure/w3id/tests/w3id.test.ts

@@ -0,0 +1,74 @@
+import { W3ID, W3IDBuilder } from "../src";
+import { describe, test, expect } from "vitest";
+import falso from "@ngneat/falso";
+import nacl from "tweetnacl";
+import {
+    createSigner,
+    InMemoryStorage,
+    verifierCallback,
+} from "./logs/log.test";
+import { IDLogManager } from "../src/logs/log-manager";
+import { hash } from "../src/utils/hash";
+import { uint8ArrayToHex } from "../src/utils/codec";
+import { LogEvent } from "../src/logs/log.types";
+
+const keyPair = nacl.sign.keyPair();
+
+describe("W3IDBuilder", () => {
+    test("ID Generation: Create Basic ID", async () => {
+        const id = await new W3IDBuilder().build();
+        expect(id).toBeInstanceOf(W3ID);
+        expect(id.logs).toBeUndefined();
+    });
+
+    test("ID Generation: UUID is Deterministic", async () => {
+        const namespace = falso.randUuid();
+        const entropy = falso.randText();
+
+        const id1 = await new W3IDBuilder()
+            .withEntropy(entropy)
+            .withNamespace(namespace)
+            .build();
+
+        const id2 = await new W3IDBuilder()
+            .withEntropy(entropy)
+            .withNamespace(namespace)
+            .build();
+        expect(id1.id).toEqual(id2.id);
+        expect(id1.logs).toBeUndefined();
+    });
+
+    test("ID Generation: Creates IDLogManager", async () => {
+        const id = await new W3IDBuilder()
+            .withRepository(InMemoryStorage.build())
+            .withSigner(createSigner(keyPair))
+            .withNextKeyHash(falso.randText())
+            .build();
+        expect(id.logs).toBeInstanceOf(IDLogManager);
+        const genesisLog = (await id.logs?.repository.findMany({}))[0];
+        expect(genesisLog).toBeDefined();
+    });
+
+    test("ID Mutation: Key Rotation Works", async () => {
+        const nextKeyPair = nacl.sign.keyPair();
+        const nextKeyHash = await hash(uint8ArrayToHex(nextKeyPair.publicKey));
+
+        const id = await new W3IDBuilder()
+            .withRepository(InMemoryStorage.build())
+            .withSigner(createSigner(keyPair))
+            .withNextKeyHash(nextKeyHash)
+            .build();
+
+        await id.logs?.createLogEvent({
+            nextKeySigner: createSigner(nextKeyPair),
+            nextKeyHashes: [falso.randText()],
+        });
+
+        const logs = await id.logs?.repository.findMany({});
+        const result = await IDLogManager.validateLogChain(
+            logs as LogEvent[],
+            verifierCallback,
+        );
+        expect(result).toBe(true);
+    });
+});