(refactor) (openai/gpt-5.5, reviewed T, tested T) make vfnode identity a class

Author: paoloanzn

packages/vfnode/src/Identity.ts

@@ -1,26 +1,47 @@
 import { randomUUID } from "node:crypto";
 import type { Address, Hex } from "viem";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import { err, ok, type Result } from "./result.js";
 
 export type NodeId = string & { readonly __brand: "nodeId" };
 
-export type Identity = {
-    readonly nodeId: NodeId;
-    readonly publicAddress: Address;
-    readonly privateKey: Hex;
-};
+export class Identity {
+    readonly #nodeId: NodeId;
+    readonly #publicAddress: Address;
+    readonly #privateKey: Hex;
 
-export function createNodeId(): NodeId {
-    return randomUUID() as NodeId;
-}
+    private constructor(nodeId: NodeId, publicAddress: Address, privateKey: Hex) {
+        this.#nodeId = nodeId;
+        this.#publicAddress = publicAddress;
+        this.#privateKey = privateKey;
+    }
+
+    static create(nodeId: NodeId): Result<Identity, "failed_to_create_identity"> {
+        try {
+            const privateKey = generatePrivateKey();
+            const account = privateKeyToAccount(privateKey);
+
+            return ok(new Identity(nodeId, account.address, privateKey));
+        } catch {
+            return err("failed_to_create_identity");
+        }
+    }
+
+    get nodeId(): NodeId {
+        return this.#nodeId;
+    }
 
-export function createIdentity(): Identity {
-    const privateKey = generatePrivateKey();
-    const account = privateKeyToAccount(privateKey);
+    get publicAddress(): Address {
+        return this.#publicAddress;
+    }
 
-    return {
-        nodeId: createNodeId(),
-        publicAddress: account.address,
-        privateKey,
-    };
+    async signMessage(message: string): Promise<Hex> {
+        const account = privateKeyToAccount(this.#privateKey);
+
+        return account.signMessage({ message });
+    }
+}
+
+export function createNodeId(): NodeId {
+    return randomUUID() as NodeId;
 }

packages/vfnode/src/SignedBay.ts

@@ -1,6 +1,5 @@
 import { TextDecoder, TextEncoder } from "node:util";
 import { isAddressEqual, recoverMessageAddress, toHex, type Address, type Hex } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
 import type { Bay, BayEndpoint, BayErrorListener, BayPacketListener } from "./Bay.js";
 import type { Identity, NodeId } from "./Identity.js";
 
@@ -33,11 +32,6 @@ export class SignedBay {
     #sequence = 0;
 
     constructor(options: SignedBayOptions) {
-        const account = privateKeyToAccount(options.identity.privateKey);
-        if (!isAddressEqual(account.address, options.identity.publicAddress)) {
-            throw new Error("Identity publicAddress does not match privateKey");
-        }
-
         this.#bay = options.bay;
         this.#identity = options.identity;
         this.#now = options.now ?? Date.now;
@@ -75,8 +69,7 @@ export class SignedBay {
             timestamp: this.#now(),
             payload: toHex(data),
         };
-        const account = privateKeyToAccount(this.#identity.privateKey);
-        const signature = await account.signMessage({ message: signedBayMessage(packet) });
+        const signature = await this.#identity.signMessage(signedBayMessage(packet));
 
         this.#sequence += 1;
 

packages/vfnode/src/index.ts

@@ -8,8 +8,8 @@ export type {
     BayRemote,
     BaySocketType,
 } from "./Bay.js";
-export { createIdentity, createNodeId } from "./Identity.js";
-export type { Identity, NodeId } from "./Identity.js";
+export { Identity, createNodeId } from "./Identity.js";
+export type { NodeId } from "./Identity.js";
 export {
     SignedBay,
     decodeSignedBayPacket,

packages/vfnode/src/result.ts

@@ -0,0 +1,6 @@
+export type Result<T, E = Error> =
+    | { readonly ok: true; readonly value: T }
+    | { readonly ok: false; readonly error: E };
+
+export const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
+export const err = <E>(error: E): Result<never, E> => ({ ok: false, error });