@idos-network/client 1.0.0-rc.1.0 → 1.0.0-rc.1.2

package/src/index.ts

@@ -1,59 +1,63 @@
 import {
-  base64Decode,
-  base64Encode,
-  hexEncodeSha256Hash,
-  utf8Decode,
-  utf8Encode,
-} from "@idos-network/core/codecs";
-import {
-  type AddWalletParams,
-  type GetGrantsParams,
-  type ShareableCredential,
+  type AddAttributeInput,
+  type AddWalletInput,
   addWallet,
   addWallets,
-  createAttribute,
+  addAttribute as createAttribute,
   createCredentialCopy,
+  type DagMessageInput,
+  dagMessage,
+  dwgMessage,
+  type GetGrantsPaginatedInput,
+  type GetWalletsOutput,
   getAccessGrantsOwned,
-  getAllCredentials,
   getAttributes,
-  getCredentialById,
   getCredentialOwned,
+  getCredentials,
   getGrants,
   getGrantsCount,
   getSharedCredential,
-  getUserProfile,
+  getUser,
   getWallets,
   hasProfile,
-  type idOSDAGSignatureParams,
+  type idOSCredential,
+  type idOSCredentialListItem,
+  type idOSDelegatedWriteGrant,
+  type idOSGrant,
+  type idOSUser,
+  type idOSUserAttribute,
+  type idOSWallet,
   removeCredential,
   removeWallet,
   removeWallets,
-  requestDAGMessage,
-  requestDWGMessage,
   revokeAccessGrant,
+  type ShareCredentialInput,
   shareCredential,
 } from "@idos-network/core/kwil-actions";
 import {
-  type KwilActionClient,
   createClientKwilSigner,
   createWebKwilClient,
+  type KwilActionClient,
+  signNearMessage,
 } from "@idos-network/core/kwil-infra";
-import { Store } from "@idos-network/core/store";
-import type {
-  DelegatedWriteGrant,
-  Wallet,
-  idOSCredential,
-  idOSGrant,
-  idOSUser,
-  idOSUserAttribute,
-  idOSWallet,
-} from "@idos-network/core/types";
+import type { Wallet } from "@idos-network/core/types";
 import { buildInsertableIDOSCredential } from "@idos-network/core/utils";
-import type { KwilSigner } from "@kwilteam/kwil-js";
+import type { KwilSigner } from "@idos-network/kwil-js";
+import {
+  base64Decode,
+  base64Encode,
+  hexEncodeSha256Hash,
+  utf8Decode,
+  utf8Encode,
+} from "@idos-network/utils/codecs";
+import type { BaseProvider, PublicEncryptionProfile } from "@idos-network/utils/enclave";
+import { LocalStorageStore, type Store } from "@idos-network/utils/store";
 import { negate } from "es-toolkit";
 import { every, get } from "es-toolkit/compat";
 import invariant from "tiny-invariant";
-import { type EnclaveOptions, type EnclaveProvider, IframeEnclave } from "./enclave";
+
+import { IframeEnclave } from "./enclave/iframe-enclave";
+export { IframeEnclave };
 
 type Properties<T> = {
   // biome-ignore lint/complexity/noBannedTypes: All functions are to be removed.
@@ -66,21 +70,38 @@ export type idOSClient =
   | idOSClientWithUserSigner
   | idOSClientLoggedIn;
 
-export class idOSClientConfiguration {
+export class idOSClientConfiguration<Provider extends BaseProvider = IframeEnclave> {
   readonly state: "configuration";
   readonly chainId?: string;
   readonly nodeUrl: string;
-  readonly enclaveOptions: Omit<EnclaveOptions, "mode">;
+  readonly enclaveOptions: Omit<Provider["options"], "mode">;
+  readonly store: Store;
+  readonly enclaveProvider: BaseProvider;
 
   constructor(params: {
     chainId?: string;
     nodeUrl: string;
-    enclaveOptions: Omit<EnclaveOptions, "mode">;
+    enclaveOptions: Omit<Provider["options"], "mode">;
+    enclaveProvider?: new (options: Omit<Provider["options"], "mode">) => Provider;
+    store?: Store;
   }) {
     this.state = "configuration";
     this.chainId = params.chainId;
     this.nodeUrl = params.nodeUrl;
     this.enclaveOptions = params.enclaveOptions;
+    this.store = params.store ?? new LocalStorageStore();
+
+    // TODO: This is a mess because of types...
+    if (params.enclaveProvider) {
+      this.enclaveProvider = new params.enclaveProvider({
+        ...params.enclaveOptions,
+        // Some of enclave providers require store to be passed in constructor
+        store: this.store,
+      });
+    } else {
+      // @ts-expect-error - In case of missing "container" in options, enclave will blow up
+      this.enclaveProvider = new IframeEnclave(params.enclaveOptions);
+    }
   }
 
   async createClient(): Promise<idOSClientIdle> {
@@ -92,30 +113,28 @@ export class idOSClientIdle {
   readonly state: "idle";
   readonly store: Store;
   readonly kwilClient: KwilActionClient;
-  readonly enclaveProvider: EnclaveProvider;
+  readonly enclaveProvider: BaseProvider;
 
-  constructor(store: Store, kwilClient: KwilActionClient, enclaveProvider: EnclaveProvider) {
+  constructor(store: Store, kwilClient: KwilActionClient, enclaveProvider: BaseProvider) {
     this.state = "idle";
     this.store = store;
     this.kwilClient = kwilClient;
     this.enclaveProvider = enclaveProvider;
   }
 
-  static async fromConfig(params: idOSClientConfiguration): Promise<idOSClientIdle> {
-    const store = new Store(window.localStorage);
+  static async fromConfig(params: idOSClientConfiguration<BaseProvider>): Promise<idOSClientIdle> {
     const kwilClient = await createWebKwilClient({
       nodeUrl: params.nodeUrl,
       chainId: params.chainId,
     });
 
-    const enclaveProvider = new IframeEnclave({ ...params.enclaveOptions });
-    await enclaveProvider.load();
+    await params.enclaveProvider.load();
 
-    return new idOSClientIdle(store, kwilClient, enclaveProvider);
+    return new idOSClientIdle(params.store, kwilClient, params.enclaveProvider);
   }
 
   async addressHasProfile(address: string): Promise<boolean> {
-    return hasProfile(this.kwilClient, address);
+    return hasProfile(this.kwilClient, { address }).then((res) => res.has_profile);
   }
 
   async withUserSigner(signer: Wallet): Promise<idOSClientWithUserSigner> {
@@ -124,6 +143,7 @@ export class idOSClientIdle {
       this.kwilClient,
       signer,
     );
+
     this.kwilClient.setSigner(kwilSigner);
 
     return new idOSClientWithUserSigner(this, signer, kwilSigner, walletIdentifier);
@@ -138,7 +158,7 @@ export class idOSClientWithUserSigner implements Omit<Properties<idOSClientIdle>
   readonly state: "with-user-signer";
   readonly store: Store;
   readonly kwilClient: KwilActionClient;
-  readonly enclaveProvider: EnclaveProvider;
+  readonly enclaveProvider: BaseProvider;
   readonly signer: Wallet;
   readonly kwilSigner: KwilSigner;
   readonly walletIdentifier: string;
@@ -156,6 +176,9 @@ export class idOSClientWithUserSigner implements Omit<Properties<idOSClientIdle>
     this.signer = signer;
     this.kwilSigner = kwilSigner;
     this.walletIdentifier = walletIdentifier;
+
+    // @ts-expect-error - TODO: Fix this
+    this.enclaveProvider.setSigner(this.signer);
   }
 
   async logOut(): Promise<idOSClientIdle> {
@@ -164,21 +187,35 @@ export class idOSClientWithUserSigner implements Omit<Properties<idOSClientIdle>
   }
 
   async hasProfile(): Promise<boolean> {
-    return hasProfile(this.kwilClient, this.walletIdentifier);
+    return hasProfile(this.kwilClient, { address: this.walletIdentifier }).then(
+      (x) => x.has_profile,
+    );
   }
 
-  async getUserEncryptionPublicKey(userId: string): Promise<string> {
-    await this.enclaveProvider.reconfigure({ mode: "new" });
-    const { userEncryptionPublicKey } =
-      await this.enclaveProvider.discoverUserEncryptionPublicKey(userId);
-    return userEncryptionPublicKey;
+  async createUserEncryptionProfile(userId: string): Promise<PublicEncryptionProfile> {
+    await this.enclaveProvider.reconfigure({
+      mode: "new",
+      userId,
+      walletAddress: this.walletIdentifier,
+      encryptionPasswordStore: undefined,
+      expectedUserEncryptionPublicKey: undefined,
+    });
+
+    return this.enclaveProvider.ensureUserEncryptionProfile();
   }
 
   async logIn(): Promise<idOSClientLoggedIn> {
     if (!(await this.hasProfile())) throw new Error("User does not have a profile");
 
-    await this.enclaveProvider.reconfigure({ mode: "existing" });
-    const kwilUser = await getUserProfile(this.kwilClient);
+    const kwilUser = await getUser(this.kwilClient);
+
+    await this.enclaveProvider.reconfigure({
+      mode: "existing",
+      userId: kwilUser.id,
+      expectedUserEncryptionPublicKey: kwilUser.recipient_encryption_public_key,
+      walletAddress: this.walletIdentifier,
+      encryptionPasswordStore: kwilUser.encryption_password_store,
+    });
 
     return new idOSClientLoggedIn(this, kwilUser);
   }
@@ -188,7 +225,7 @@ export class idOSClientLoggedIn implements Omit<Properties<idOSClientWithUserSig
   readonly state: "logged-in";
   readonly store: Store;
   readonly kwilClient: KwilActionClient;
-  readonly enclaveProvider: EnclaveProvider;
+  readonly enclaveProvider: BaseProvider;
   readonly signer: Wallet;
   readonly kwilSigner: KwilSigner;
   readonly walletIdentifier: string;
@@ -210,48 +247,47 @@ export class idOSClientLoggedIn implements Omit<Properties<idOSClientWithUserSig
     return new idOSClientIdle(this.store, this.kwilClient, this.enclaveProvider);
   }
 
-  async requestDWGMessage(params: DelegatedWriteGrant): Promise<string> {
-    return requestDWGMessage(this.kwilClient, params);
+  async requestDWGMessage(params: idOSDelegatedWriteGrant): Promise<string> {
+    return dwgMessage(this.kwilClient, params).then((res) => res.message);
   }
 
   async removeCredential(id: string): Promise<{ id: string }> {
-    return await removeCredential(this.kwilClient, id);
+    await removeCredential(this.kwilClient, { id });
+    return { id };
   }
 
   async getCredentialById(id: string): Promise<idOSCredential | undefined> {
-    return getCredentialById(this.kwilClient, id);
+    return getCredentialOwned(this.kwilClient, { id }).then((res) => res[0]);
   }
 
-  async shareCredential(credential: ShareableCredential): Promise<ShareableCredential> {
-    return shareCredential(this.kwilClient, credential);
+  async shareCredential(credential: ShareCredentialInput): Promise<ShareCredentialInput> {
+    await shareCredential(this.kwilClient, credential);
+    return credential;
   }
 
-  async getAllCredentials(): Promise<idOSCredential[]> {
-    return getAllCredentials(this.kwilClient);
+  async getAllCredentials(): Promise<idOSCredentialListItem[]> {
+    return getCredentials(this.kwilClient);
   }
 
   async getAccessGrantsOwned(): Promise<idOSGrant[]> {
     return getAccessGrantsOwned(this.kwilClient);
   }
 
-  async getCredentialOwned(id: string): Promise<idOSCredential | undefined> {
-    return getCredentialOwned(this.kwilClient, id);
-  }
-
   async getAttributes(): Promise<idOSUserAttribute[]> {
     return getAttributes(this.kwilClient);
   }
 
-  async createAttribute(attribute: idOSUserAttribute): Promise<idOSUserAttribute> {
-    return createAttribute(this.kwilClient, attribute);
+  async createAttribute(attribute: AddAttributeInput): Promise<AddAttributeInput> {
+    await createAttribute(this.kwilClient, attribute);
+    return attribute;
   }
 
   async getCredentialContentSha256Hash(id: string): Promise<string> {
-    const credential = await getCredentialById(this.kwilClient, id);
+    const credential = await this.getCredentialById(id);
 
     invariant(credential, `"idOSCredential" with id ${id} not found`);
 
-    await this.enclaveProvider.ready(this.user.id, this.user.recipient_encryption_public_key);
+    await this.enclaveProvider.ensureUserEncryptionProfile();
 
     const plaintext = await this.enclaveProvider.decrypt(
       base64Decode(credential.content),
@@ -261,21 +297,37 @@ export class idOSClientLoggedIn implements Omit<Properties<idOSClientWithUserSig
     return hexEncodeSha256Hash(plaintext);
   }
 
+  async getCredentialContent(id: string): Promise<string> {
+    const credential = await this.getCredentialById(id);
+
+    invariant(credential, `"idOSCredential" with id ${id} not found`);
+
+    await this.enclaveProvider.ensureUserEncryptionProfile();
+
+    const plaintext = await this.enclaveProvider.decrypt(
+      base64Decode(credential.content),
+      base64Decode(credential.encryptor_public_key),
+    );
+
+    return plaintext as any;
+  }
+
   async createCredentialCopy(
     id: string,
     consumerRecipientEncryptionPublicKey: string,
     consumerAddress: string,
     lockedUntil: number,
   ): Promise<{ id: string }> {
-    const originalCredential = await getCredentialById(this.kwilClient, id);
+    const originalCredential = await this.getCredentialById(id);
     invariant(originalCredential, `"idOSCredential" with id ${id} not found`);
 
-    await this.enclaveProvider.ready(this.user.id, this.user.recipient_encryption_public_key);
+    await this.enclaveProvider.ensureUserEncryptionProfile();
 
     const decryptedContent = await this.enclaveProvider.decrypt(
       base64Decode(originalCredential.content),
       base64Decode(originalCredential.encryptor_public_key),
     );
+
     const { content, encryptorPublicKey } = await this.enclaveProvider.encrypt(
       decryptedContent,
       base64Decode(consumerRecipientEncryptionPublicKey),
@@ -305,47 +357,56 @@ export class idOSClientLoggedIn implements Omit<Properties<idOSClientWithUserSig
     return { id: copyId };
   }
 
-  async requestDAGMessage(params: idOSDAGSignatureParams): Promise<string> {
-    return requestDAGMessage(this.kwilClient, params);
+  async requestDAGMessage(params: DagMessageInput): Promise<string> {
+    return dagMessage(this.kwilClient, params).then((res) => res.message);
   }
 
-  async getGrants(params: GetGrantsParams): Promise<{ grants: idOSGrant[]; totalCount: number }> {
+  async getGrants(
+    params: GetGrantsPaginatedInput,
+  ): Promise<{ grants: idOSGrant[]; totalCount: number }> {
     return {
       grants: await getGrants(this.kwilClient, params),
       totalCount: await this.getGrantsCount(),
     };
   }
 
-  async addWallets(params: AddWalletParams[]): Promise<AddWalletParams[]> {
-    return addWallets(this.kwilClient, params);
+  async addWallets(params: AddWalletInput[]): Promise<AddWalletInput[]> {
+    await addWallets(this.kwilClient, params);
+    return params;
   }
 
   async getGrantsCount(): Promise<number> {
-    return getGrantsCount(this.kwilClient);
+    return getGrantsCount(this.kwilClient, {
+      user_id: null,
+    }).then((res) => res.count);
   }
 
   async getSharedCredential(id: string): Promise<idOSCredential | undefined> {
-    return getSharedCredential(this.kwilClient, id);
+    return getSharedCredential(this.kwilClient, { id }).then((res) => res[0]);
   }
 
-  async revokeAccessGrant(grantId: string): Promise<{ id: string }> {
-    return revokeAccessGrant(this.kwilClient, grantId);
+  async revokeAccessGrant(id: string): Promise<{ id: string }> {
+    await revokeAccessGrant(this.kwilClient, { id });
+    return { id };
   }
 
-  async addWallet(params: AddWalletParams): Promise<AddWalletParams> {
-    return addWallet(this.kwilClient, params);
+  async addWallet(params: AddWalletInput): Promise<AddWalletInput> {
+    await addWallet(this.kwilClient, params);
+    return params;
   }
 
-  async getWallets(): Promise<idOSWallet[]> {
+  async getWallets(): Promise<GetWalletsOutput[]> {
     return getWallets(this.kwilClient);
   }
 
   async removeWallet(id: string): Promise<{ id: string }> {
-    return removeWallet(this.kwilClient, id);
+    await removeWallet(this.kwilClient, { id });
+    return { id };
   }
 
   async removeWallets(ids: string[]): Promise<string[]> {
-    return removeWallets(this.kwilClient, ids);
+    await removeWallets(this.kwilClient, ids);
+    return ids;
   }
 
   async filterCredentials(requirements: {
@@ -371,7 +432,7 @@ export class idOSClientLoggedIn implements Omit<Properties<idOSClientWithUserSig
       (cred) => !cred.original_id && !!cred.public_notes,
     );
 
-    invariant(originalCredentials.length, "No original credentials found");
+    // invariant(originalCredentials.length, "No original credentials found");
     let result = originalCredentials.filter((cred) => {
       return requirements.acceptedIssuers?.some(
         (issuer) => issuer.authPublicKey === cred.issuer_auth_public_key,
@@ -409,7 +470,7 @@ export class idOSClientLoggedIn implements Omit<Properties<idOSClientWithUserSig
       consumerAuthPublicKey,
     }: { consumerEncryptionPublicKey: string; consumerAuthPublicKey: string },
   ): Promise<idOSCredential> {
-    const credential = await getCredentialById(this.kwilClient, credentialId);
+    const credential = await this.getCredentialById(credentialId);
     const contentHash = await this.getCredentialContentSha256Hash(credentialId);
 
     invariant(credential, `"idOSCredential" with id ${credentialId} not found`);
@@ -421,7 +482,7 @@ export class idOSClientLoggedIn implements Omit<Properties<idOSClientWithUserSig
       ),
     );
 
-    await this.enclaveProvider.ready(this.user.id, this.user.recipient_encryption_public_key);
+    await this.enclaveProvider.ensureUserEncryptionProfile();
 
     const { content, encryptorPublicKey } = await this.enclaveProvider.encrypt(
       utf8Encode(plaintextContent),
@@ -451,20 +512,20 @@ export class idOSClientLoggedIn implements Omit<Properties<idOSClientWithUserSig
 }
 
 export type {
-  DelegatedWriteGrant,
+  idOSDelegatedWriteGrant,
   idOSCredential,
   idOSGrant,
   idOSUser,
   idOSUserAttribute,
   idOSWallet,
-  EnclaveOptions,
-  EnclaveProvider,
 };
 
+export { signNearMessage };
+
 export function createIDOSClient(params: {
   nodeUrl: string;
-  enclaveOptions: Omit<EnclaveOptions, "mode">;
-}): idOSClientConfiguration {
+  enclaveOptions: Omit<IframeEnclave["options"], "mode">;
+}): idOSClientConfiguration<IframeEnclave> {
   return new idOSClientConfiguration({
     nodeUrl: params.nodeUrl,
     enclaveOptions: params.enclaveOptions,

package/src/enclave/index.ts

@@ -1,3 +0,0 @@
-export { IframeEnclave } from "./iframe-enclave";
-export { MetaMaskSnapEnclave } from "./metamask-snap-enclave";
-export * from "./types";

package/src/enclave/metamask-snap-enclave.ts

@@ -1,91 +0,0 @@
-import type { idOSCredential } from "@idos-network/core";
-import type {
-  DiscoverUserEncryptionPublicKeyResponse,
-  EnclaveOptions,
-  EnclaveProvider,
-} from "./types";
-
-export class MetaMaskSnapEnclave implements EnclaveProvider {
-  // biome-ignore lint/suspicious/noExplicitAny: Types will be added later
-  enclaveHost: any;
-  snapId: string;
-
-  constructor(_?: Record<string, unknown>) {
-    // biome-ignore lint/suspicious/noExplicitAny: Types will be added later.
-    this.enclaveHost = (window as any).ethereum;
-    this.snapId = "npm:@idos-network/metamask-snap-enclave";
-  }
-  reconfigure(_options: Omit<EnclaveOptions, "container" | "url">): Promise<void> {
-    throw new Error("Method not implemented.");
-  }
-  filterCredentials(
-    credentials: idOSCredential[],
-    privateFieldFilters: { pick: Record<string, unknown[]>; omit: Record<string, unknown[]> },
-  ): Promise<idOSCredential[]> {
-    console.log(credentials, privateFieldFilters);
-    throw new Error("Method not implemented.");
-  }
-
-  async discoverUserEncryptionPublicKey(): Promise<DiscoverUserEncryptionPublicKeyResponse> {
-    throw new Error("Method not implemented.");
-  }
-
-  async load(): Promise<void> {
-    const snaps = await this.enclaveHost.request({ method: "wallet_getSnaps" });
-    // biome-ignore lint/suspicious/noExplicitAny: Types will be added later
-    const connected = Object.values(snaps).find((snap: any) => snap.id === this.snapId);
-
-    if (!connected)
-      await this.enclaveHost.request({
-        method: "wallet_requestSnaps",
-        params: { [this.snapId]: {} },
-      });
-  }
-
-  async ready(userId: string): Promise<Uint8Array> {
-    let { encryptionPublicKey } = JSON.parse(await this.invokeSnap("storage", { userId }));
-
-    encryptionPublicKey ||= await this.invokeSnap("init");
-    encryptionPublicKey &&= Uint8Array.from(Object.values(encryptionPublicKey));
-
-    return encryptionPublicKey;
-  }
-
-  // biome-ignore lint/suspicious/noExplicitAny: Using `any` to avoid type errors.
-  invokeSnap(method: string, params: unknown = {}): Promise<any> {
-    return this.enclaveHost.request({
-      method: "wallet_invokeSnap",
-      params: {
-        snapId: this.snapId,
-        request: { method, params },
-      },
-    });
-  }
-
-  async reset(): Promise<void> {
-    return this.invokeSnap("reset");
-  }
-
-  async confirm(message: string): Promise<boolean> {
-    return this.invokeSnap("confirm", { message });
-  }
-
-  async encrypt(
-    message: Uint8Array,
-    receiverPublicKey: Uint8Array,
-  ): Promise<{ content: Uint8Array; encryptorPublicKey: Uint8Array }> {
-    await this.invokeSnap("encrypt", { message, receiverPublicKey });
-
-    throw new Error("The Metamask Enclave needs to be updated");
-  }
-
-  async decrypt(message: Uint8Array, senderPublicKey: Uint8Array): Promise<Uint8Array> {
-    const decrypted = await this.invokeSnap("decrypt", { message, senderPublicKey });
-
-    return Uint8Array.from(Object.values(decrypted));
-  }
-
-  async backupPasswordOrSecret(): Promise<void> {
-    throw new Error("Method not implemented.");
-  }
-}

package/src/enclave/types.ts

@@ -1,44 +0,0 @@
-import type { idOSCredential } from "@idos-network/core";
-
-export type StoredData = {
-  encryptionPublicKey?: Uint8Array;
-  userId?: string;
-};
-
-export type DiscoverUserEncryptionPublicKeyResponse = {
-  userId: string;
-  userEncryptionPublicKey: string;
-};
-
-export type EnclaveOptions = {
-  container: string;
-  theme?: "light" | "dark";
-  mode?: "new" | "existing";
-  url?: string;
-  throwOnUserCancelUnlock?: boolean;
-};
-
-export interface EnclaveProvider {
-  load(): Promise<void>;
-  reconfigure(options: Omit<EnclaveOptions, "container" | "url">): Promise<void>;
-
-  ready(userId: string, currentUserEncryptionPublicKey?: string): Promise<Uint8Array>;
-  reset(): Promise<void>;
-  confirm(message: string): Promise<boolean>;
-  encrypt(
-    message: Uint8Array,
-    receiverPublicKey?: Uint8Array,
-  ): Promise<{ content: Uint8Array; encryptorPublicKey: Uint8Array }>;
-  decrypt(message: Uint8Array, senderPublicKey?: Uint8Array): Promise<Uint8Array>;
-  discoverUserEncryptionPublicKey(userId: string): Promise<DiscoverUserEncryptionPublicKeyResponse>;
-
-  filterCredentials(
-    credentials: idOSCredential[],
-    privateFieldFilters: {
-      pick: Record<string, unknown[]>;
-      omit: Record<string, unknown[]>;
-    },
-  ): Promise<idOSCredential[]>;
-
-  backupPasswordOrSecret(): Promise<void>;
-}