@renown/sdk 0.1.0

package/README.md

@@ -0,0 +1,3 @@
+# Renown SDK
+
+This package contains methods to interact with Renown and manage the user's session.

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@renown/sdk",
+  "version": "0.1.0",
+  "description": "",
+  "license": "AGPL-3.0-only",
+  "private": false,
+  "type": "module",
+  "main": "./src/index.browser.ts",
+  "types": "./src/index.browser.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "node": "./src/index.node.ts",
+      "default": "./src/index.browser.ts"
+    }
+  },
+  "files": [
+    "/src",
+    "tsconfig.base.json",
+    "tsconfig.browser.json",
+    "tsconfig.node.json"
+  ],
+  "nx-release-publish": {
+    "options": {
+      "packageRoot": "dist/{projectRoot}"
+    }
+  },
+  "peerDependencies": {
+    "document-model": "2.14.0"
+  },
+  "devDependencies": {
+    "document-model": "2.14.0"
+  },
+  "scripts": {
+    "check-types": "tsc -p tsconfig.node.json --noEmit && tsc -p tsconfig.browser.json --noEmit",
+    "check-types:node": "tsc -p tsconfig.node.json --noEmit",
+    "check-types:brower": "tsc -p tsconfig.browser.json --noEmit",
+    "build": "tsc -p tsconfig.node.json && tsc -p tsconfig.browser.json",
+    "build:browser": "tsc -p tsconfig.browser.json",
+    "build:node": "tsc -p tsconfig.node.json",
+    "clean": "rimraf dist/",
+    "clean:node_modules": "rimraf node_modules"
+  }
+}

package/src/common.ts

@@ -0,0 +1,136 @@
+import {
+  IRenown,
+  PowerhouseVerifiableCredential,
+  RenownEventEmitter,
+  RenownEvents,
+  RenownStorage,
+  User,
+} from "./types";
+import { DEFAULT_RENOWN_URL } from "./constants";
+import { parsePkhDid } from "./utils";
+
+export class Renown implements IRenown {
+  #baseUrl: string;
+  #store: RenownStorage;
+  #connectId: string;
+  #eventEmitter: RenownEventEmitter;
+
+  constructor(
+    store: RenownStorage,
+    eventEmitter: RenownEventEmitter,
+    connectId: string,
+    baseUrl = DEFAULT_RENOWN_URL,
+  ) {
+    this.#store = store;
+    this.#eventEmitter = eventEmitter;
+    this.#connectId = connectId;
+    this.#baseUrl = baseUrl;
+
+    if (this.user) {
+      this.login(this.user.did).catch(() => void 0);
+    }
+  }
+
+  get user() {
+    return this.#store.get("user");
+  }
+
+  #updateUser(user: User | undefined) {
+    if (user) {
+      this.#store.set("user", user);
+    } else {
+      this.#store.delete("user");
+    }
+    this.#eventEmitter.emit("user", user);
+  }
+
+  set connectId(connectId: string) {
+    this.#connectId = connectId;
+    const user = this.user;
+
+    this.#updateUser(undefined);
+
+    // tries to login with new connectId
+    if (user) {
+      this.login(user.did).catch((e: unknown) => {
+        console.log("User no longer authenticated:", e);
+      });
+    }
+  }
+
+  async login(did: string): Promise<User> {
+    try {
+      const result = parsePkhDid(did);
+
+      const credential = await this.#getCredential(
+        result.address,
+        result.chainId,
+        this.#connectId,
+      );
+      if (!credential) {
+        this.#updateUser(undefined);
+        throw new Error("Credential not found");
+      }
+      const user: User = {
+        ...result,
+        did,
+        credential,
+      };
+
+      // TODO
+      //   getEnsInfo(user.address, user.chainId)
+      //     .then((ens) => {
+      //       if (
+      //         this.user?.address === user.address &&
+      //         this.user.chainId === user.chainId
+      //       ) {
+      //         this.#updateUser({ ...this.user, ens });
+      //       }
+      //     })
+      //     .catch(logger.error);
+
+      this.#updateUser(user);
+      return user;
+    } catch (error) {
+      this.#updateUser(undefined);
+      throw error;
+    }
+  }
+
+  logout() {
+    this.#updateUser(undefined);
+    return Promise.resolve();
+  }
+
+  on<K extends keyof RenownEvents>(
+    event: K,
+    listener: (data: RenownEvents[K]) => void,
+  ): () => void {
+    return this.#eventEmitter.on(event, listener);
+  }
+
+  async #getCredential(
+    address: string,
+    chainId: number,
+    connectId: string,
+  ): Promise<PowerhouseVerifiableCredential | undefined> {
+    if (!this.#baseUrl) {
+      throw new Error("RENOWN_URL is not set");
+    }
+    const url = new URL(
+      `/api/auth/credential?address=${encodeURIComponent(address)}&chainId=${encodeURIComponent(chainId)}&connectId=${encodeURIComponent(connectId)}`,
+      this.#baseUrl,
+    );
+    const response = await fetch(url, {
+      method: "GET",
+    });
+    if (response.ok) {
+      const result = (await response.json()) as {
+        credential: PowerhouseVerifiableCredential;
+      };
+      return result.credential;
+    } else {
+      throw new Error("Failed to get credential");
+    }
+  }
+}

package/src/constants.ts

@@ -0,0 +1,45 @@
+export const DEFAULT_RENOWN_URL = "https://www.renown.id";
+export const DEFAULT_RENOWN_NETWORK_ID = "eip155";
+export const DEFAULT_RENOWN_CHAIN_ID = "1";
+
+export const DOMAIN_TYPE = [
+  { name: "name", type: "string" },
+  { name: "version", type: "string" },
+  { name: "chainId", type: "uint256" },
+  { name: "verifyingContract", type: "address" },
+] as const;
+
+export const VERIFIABLE_CREDENTIAL_EIP712_TYPE = [
+  { name: "@context", type: "string[]" },
+  { name: "type", type: "string[]" },
+  { name: "id", type: "string" },
+  { name: "issuer", type: "Issuer" },
+  { name: "credentialSubject", type: "CredentialSubject" },
+  { name: "credentialSchema", type: "CredentialSchema" },
+  { name: "issuanceDate", type: "string" },
+  { name: "expirationDate", type: "string" },
+] as const;
+
+export const CREDENTIAL_SCHEMA_EIP712_TYPE = [
+  { name: "id", type: "string" },
+  { name: "type", type: "string" },
+] as const;
+
+export const CREDENTIAL_SUBJECT_TYPE = [
+  { name: "app", type: "string" },
+  { name: "id", type: "string" },
+  { name: "name", type: "string" },
+] as const;
+
+export const ISSUER_TYPE = [
+  { name: "id", type: "string" },
+  { name: "ethereumAddress", type: "string" },
+] as const;
+
+export const CREDENTIAL_TYPES = {
+  EIP712Domain: DOMAIN_TYPE,
+  VerifiableCredential: VERIFIABLE_CREDENTIAL_EIP712_TYPE,
+  CredentialSchema: CREDENTIAL_SCHEMA_EIP712_TYPE,
+  CredentialSubject: CREDENTIAL_SUBJECT_TYPE,
+  Issuer: ISSUER_TYPE,
+} as const;

package/src/event/event.browser.ts

@@ -0,0 +1,34 @@
+import { IEventEmitter } from "./types";
+
+export class TypedCustomEvent<T> extends CustomEvent<T> {
+  constructor(type: string, detail?: T) {
+    super(type, { detail });
+  }
+}
+
+export class BrowserEventEmitter<Events extends Record<string, unknown>>
+  implements IEventEmitter<Events>
+{
+  #eventTarget = new EventTarget();
+
+  on<K extends keyof Events>(
+    event: K,
+    listener: (data: Events[K]) => void,
+  ): () => void {
+    const wrappedListener = (e: Event) => {
+      if (e instanceof TypedCustomEvent) {
+        listener(e.detail as Events[K]);
+      }
+    };
+
+    this.#eventTarget.addEventListener(event.toString(), wrappedListener);
+    return () => {
+      this.#eventTarget.removeEventListener(event.toString(), wrappedListener);
+    };
+  }
+
+  emit<K extends keyof Events>(event: K, data: Events[K]): void {
+    const customEvent = new TypedCustomEvent(event.toString(), data);
+    this.#eventTarget.dispatchEvent(customEvent);
+  }
+}

package/src/event/event.node.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from "node:events";
+import { IEventEmitter } from "./types.js";
+
+export class NodeEventEmitter<Events extends Record<string, unknown>>
+  implements IEventEmitter<Events>
+{
+  #emitter = new EventEmitter();
+
+  constructor() {
+    this.#emitter.setMaxListeners(0);
+  }
+
+  on<K extends keyof Events>(
+    event: K,
+    listener: (data: Events[K]) => void,
+  ): () => void {
+    this.#emitter.on(event as string, listener);
+    return () => {
+      this.#emitter.removeListener(event.toString(), listener);
+    };
+  }
+
+  emit<K extends keyof Events>(event: K, data: Events[K]): void {
+    this.#emitter.emit(event.toString(), data);
+  }
+}

package/src/event/types.ts

@@ -0,0 +1,19 @@
+export interface IEventEmitter<Events extends Record<string, unknown>> {
+  /**
+   * Registers a listener for the specified event.
+   * @param event - The event name.
+   * @param listener - The listener function for the event.
+   * @returns A function to remove the listener.
+   */
+  on<K extends keyof Events>(
+    event: K,
+    listener: (data: Events[K]) => void,
+  ): () => void;
+
+  /**
+   * Emits an event with the specified data.
+   * @param event - The event name.
+   * @param data - The data to pass to listeners.
+   */
+  emit<K extends keyof Events>(event: K, data: Events[K]): void;
+}

package/src/index.browser.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { initRenown } from "./init.browser";

package/src/index.node.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { initRenown } from "./init.node";

package/src/init.browser.ts

@@ -0,0 +1,12 @@
+import { Renown } from "./common";
+import { RenownEvents, RenownStorageMap } from "./types";
+import { BrowserEventEmitter } from "./event/event.browser";
+import { BrowserStorage } from "./storage/storage.browser";
+
+export function initRenown(connectId: string, basename: string | undefined) {
+  return new Renown(
+    new BrowserStorage<RenownStorageMap>("renown", basename),
+    new BrowserEventEmitter<RenownEvents>(),
+    connectId,
+  );
+}

package/src/init.node.ts

@@ -0,0 +1,13 @@
+import { Renown } from "./common";
+import { NodeEventEmitter } from "./event/event.node";
+import { NodeStorage } from "./storage/storage.node";
+import { RenownEvents, RenownStorageMap } from "./types";
+
+export function initRenown(
+  connectId: string,
+  filePath: string,
+  namespace: string,
+) {
+  const storage = new NodeStorage<RenownStorageMap>(filePath, namespace);
+  return new Renown(storage, new NodeEventEmitter<RenownEvents>(), connectId);
+}

package/src/storage/common.ts

@@ -0,0 +1,18 @@
+export interface IStorage<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> {
+  get<Key extends keyof T>(key: Key): T[Key] | undefined;
+  set<Key extends keyof T>(key: Key, value?: T[Key]): void;
+  delete(key: keyof T): void;
+}
+
+export abstract class BaseStorage<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> implements IStorage<T>
+{
+  protected constructor(protected namespace: string) {}
+
+  abstract get<Key extends keyof T>(key: Key): T[Key] | undefined;
+  abstract set<Key extends keyof T>(key: Key, value?: T[Key]): void;
+  abstract delete(key: keyof T): void;
+}

package/src/storage/storage.browser.ts

@@ -0,0 +1,30 @@
+import { BaseStorage } from "./common";
+
+export class BrowserStorage<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> extends BaseStorage<T> {
+  constructor(namespace: string, basename: string | undefined) {
+    super(`${basename}:${namespace}`);
+  }
+
+  #buildKey(key: keyof T): string {
+    return `${this.namespace}:${key.toString()}`;
+  }
+  get<Key extends keyof T>(key: Key): T[Key] | undefined {
+    const value = localStorage.getItem(this.#buildKey(key));
+    if (value) {
+      return JSON.parse(value) as T[Key];
+    }
+    return undefined;
+  }
+
+  set<Key extends keyof T>(key: Key, value?: T[Key] | undefined): void {
+    return value
+      ? localStorage.setItem(this.#buildKey(key), JSON.stringify(value))
+      : localStorage.removeItem(this.#buildKey(key));
+  }
+
+  delete(key: keyof T): void {
+    return localStorage.removeItem(this.#buildKey(key));
+  }
+}

package/src/storage/storage.node.ts

@@ -0,0 +1,53 @@
+import { writeFileSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { BaseStorage } from "./common";
+
+export class NodeStorage<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> extends BaseStorage<T> {
+  private readonly filePath: string;
+
+  constructor(filePath: string, namespace: string) {
+    super(namespace);
+    this.filePath = filePath;
+
+    if (!existsSync(this.filePath)) {
+      writeFileSync(this.filePath, JSON.stringify({}));
+    }
+  }
+
+  private readData(): T {
+    const data = readFileSync(this.filePath, "utf-8");
+    return JSON.parse(data) as T;
+  }
+
+  private writeData(data: T): void {
+    writeFileSync(
+      join(this.filePath, `$this.namespace}.json`),
+      JSON.stringify(data, null, 2),
+    );
+  }
+
+  get<Key extends keyof T>(key: Key): T[Key] | undefined {
+    const data = this.readData();
+    return data[key];
+  }
+
+  set<Key extends keyof T>(key: Key, value?: T[Key]): void {
+    const data = this.readData();
+    if (value === undefined) {
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete data[key];
+    } else {
+      data[key] = value;
+    }
+    this.writeData(data);
+  }
+
+  delete(key: keyof T): void {
+    const data = this.readData();
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete data[key];
+    this.writeData(data);
+  }
+}

package/src/types.ts

@@ -0,0 +1,96 @@
+import type { User as EditorUser } from "document-model/document";
+import { CREDENTIAL_TYPES } from "./constants";
+import { IStorage } from "./storage/common";
+import { IEventEmitter } from "./event/types";
+
+export type User = EditorUser & {
+  did: string;
+  credential: PowerhouseVerifiableCredential | undefined;
+};
+
+export type Unsubscribe = () => void;
+
+export type RenownStorageMap = { user: User | undefined };
+
+export type RenownStorage = IStorage<RenownStorageMap>;
+
+export type RenownEvents = {
+  user: User | undefined;
+};
+
+export type RenownEventEmitter = IEventEmitter<RenownEvents>;
+
+export interface IRenown extends Pick<RenownEventEmitter, "on"> {
+  user: User | undefined;
+  login: (did: string) => Promise<User | undefined>;
+  logout: () => Promise<void>;
+}
+
+type IssuerType<T> = {
+  id: string;
+} & T;
+
+type CredentialSubjecType<T> = {
+  id?: string;
+} & T;
+
+interface CredentialStatus {
+  id: string;
+  type: string;
+}
+
+interface CredentialSchema {
+  id: string;
+  type: string;
+}
+
+interface IVerifiableCredentialPayload<Subject, Issuer> {
+  "@context": string[];
+  id: string;
+  type: string[];
+  issuer: IssuerType<Issuer>;
+  issuanceDate: string;
+  expirationDate?: string;
+  credentialSubject: CredentialSubjecType<Subject>;
+  credentialStatus?: CredentialStatus;
+  credentialSchema: CredentialSchema;
+}
+
+interface IProof {
+  verificationMethod: string;
+  ethereumAddress: `0x${string}`;
+  created: string;
+  proofPurpose: string;
+  type: string;
+  proofValue: string;
+  eip712: {
+    domain: {
+      name: string;
+      version: string;
+      chainId: number;
+      verifyingContract: string;
+    };
+    types: typeof CREDENTIAL_TYPES;
+    primaryType: "VerifiableCredential";
+  };
+}
+
+export interface IVerifiableCredential<Subject, Issuer>
+  extends IVerifiableCredentialPayload<Subject, Issuer> {
+  proof: IProof;
+}
+
+export interface IPowerhouseCredentialSubject {
+  id: string;
+  app: string;
+  name?: string;
+}
+
+export interface IPowerhouseIssuerType {
+  ethereumAddress: `0x${string}`;
+}
+
+export type PowerhouseVerifiableCredential = IVerifiableCredential<
+  IPowerhouseCredentialSubject,
+  IPowerhouseIssuerType
+>;

package/src/utils.ts

@@ -0,0 +1,28 @@
+export type PKHDid = {
+  networkId: string;
+  chainId: number;
+  address: `0x${string}`;
+};
+
+export function parsePkhDid(did: string): PKHDid {
+  const parts = did.split(":");
+  if (!did.startsWith("did:pkh:") || parts.length !== 5) {
+    throw new Error("Invalid pkh did");
+  }
+  const [, , networkId, chainIdStr, address] = parts;
+
+  if (!address.startsWith("0x")) {
+    throw new Error(`Invalid address: ${address}`);
+  }
+
+  const chainId = Number(chainIdStr);
+  if (isNaN(chainId)) {
+    throw new Error(`Invalid chain id: ${chainIdStr}`);
+  }
+
+  return {
+    chainId,
+    networkId,
+    address: address as PKHDid["address"],
+  };
+}

package/tsconfig.base.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.options.json",
+  "compilerOptions": {
+    "composite": true,
+    "lib": ["ESNext"],
+    "rootDir": "./src",
+    "baseUrl": "./src"
+  },
+  "exclude": ["dist/**/*"]
+}

package/tsconfig.browser.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist/browser",
+    "lib": ["DOM", "ESNext"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.node.ts"]
+}

package/tsconfig.node.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist/node",
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.browser.ts"]
+}