@worldcoin/idkit-core 1.0.0-alpha.6 → 1.0.0

package/build/index.cjs

@@ -0,0 +1,277 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AppErrorCodes: () => AppErrorCodes,
+  CredentialType: () => CredentialType,
+  DEFAULT_VERIFICATION_LEVEL: () => DEFAULT_VERIFICATION_LEVEL,
+  VerificationLevel: () => VerificationLevel,
+  VerificationState: () => VerificationState,
+  useWorldBridgeStore: () => useWorldBridgeStore,
+  verification_level_to_credential_types: () => verification_level_to_credential_types
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types/bridge.ts
+var AppErrorCodes = /* @__PURE__ */ ((AppErrorCodes2) => {
+  AppErrorCodes2["ConnectionFailed"] = "connection_failed";
+  AppErrorCodes2["VerificationRejected"] = "verification_rejected";
+  AppErrorCodes2["MaxVerificationsReached"] = "max_verifications_reached";
+  AppErrorCodes2["CredentialUnavailable"] = "credential_unavailable";
+  AppErrorCodes2["MalformedRequest"] = "malformed_request";
+  AppErrorCodes2["InvalidNetwork"] = "invalid_network";
+  AppErrorCodes2["InclusionProofFailed"] = "inclusion_proof_failed";
+  AppErrorCodes2["InclusionProofPending"] = "inclusion_proof_pending";
+  AppErrorCodes2["UnexpectedResponse"] = "unexpected_response";
+  AppErrorCodes2["FailedByHostApp"] = "failed_by_host_app";
+  AppErrorCodes2["GenericError"] = "generic_error";
+  return AppErrorCodes2;
+})(AppErrorCodes || {});
+var VerificationState = /* @__PURE__ */ ((VerificationState2) => {
+  VerificationState2["PreparingClient"] = "loading_widget";
+  VerificationState2["WaitingForConnection"] = "awaiting_connection";
+  VerificationState2["WaitingForApp"] = "awaiting_app";
+  VerificationState2["Confirmed"] = "confirmed";
+  VerificationState2["Failed"] = "failed";
+  return VerificationState2;
+})(VerificationState || {});
+
+// src/types/config.ts
+var CredentialType = /* @__PURE__ */ ((CredentialType2) => {
+  CredentialType2["Orb"] = "orb";
+  CredentialType2["Device"] = "device";
+  return CredentialType2;
+})(CredentialType || {});
+var VerificationLevel = /* @__PURE__ */ ((VerificationLevel2) => {
+  VerificationLevel2["Lite"] = "lite";
+  VerificationLevel2["Orb"] = "orb";
+  return VerificationLevel2;
+})(VerificationLevel || {});
+
+// src/bridge.ts
+var import_zustand = require("zustand");
+
+// src/lib/hashing.ts
+var import_buffer = require("buffer/index.js");
+var import_viem = require("viem");
+function hashToField(input) {
+  if ((0, import_viem.isBytes)(input) || (0, import_viem.isHex)(input))
+    return hashEncodedBytes(input);
+  return hashString(input);
+}
+function packAndEncode(input) {
+  const [types, values] = input.reduce(
+    ([types2, values2], [type, value]) => {
+      types2.push(type);
+      values2.push(value);
+      return [types2, values2];
+    },
+    [[], []]
+  );
+  return hashEncodedBytes((0, import_viem.encodePacked)(types, values));
+}
+function hashString(input) {
+  const bytesInput = import_buffer.Buffer.from(input);
+  return hashEncodedBytes(bytesInput);
+}
+function hashEncodedBytes(input) {
+  const hash = BigInt((0, import_viem.keccak256)(input)) >> 8n;
+  const rawDigest = hash.toString(16);
+  return { hash, digest: `0x${rawDigest.padStart(64, "0")}` };
+}
+var generateSignal = (signal) => {
+  if (!signal || typeof signal === "string")
+    return hashToField(signal ?? "");
+  return packAndEncode(signal.types.map((type, index) => [type, signal.values[index]]));
+};
+var encodeAction = (action) => {
+  if (!action)
+    return "";
+  if (typeof action === "string")
+    return action;
+  return action.types.map((type, index) => `${type}(${action.values[index]})`).join(",");
+};
+
+// src/lib/utils.ts
+var import_buffer2 = require("buffer/index.js");
+var DEFAULT_VERIFICATION_LEVEL = "orb" /* Orb */;
+var buffer_encode = (buffer) => {
+  return import_buffer2.Buffer.from(buffer).toString("base64");
+};
+var buffer_decode = (encoded) => {
+  return import_buffer2.Buffer.from(encoded, "base64");
+};
+var verification_level_to_credential_types = (verification_level) => {
+  switch (verification_level) {
+    case "lite" /* Lite */:
+      return ["orb" /* Orb */, "device" /* Device */];
+    case "orb" /* Orb */:
+      return ["orb" /* Orb */];
+    default:
+      throw new Error(`Unknown verification level: ${verification_level}`);
+  }
+};
+var credential_type_to_verification_level = (credential_type) => {
+  switch (credential_type) {
+    case "orb" /* Orb */:
+      return "orb" /* Orb */;
+    case "device" /* Device */:
+      return "lite" /* Lite */;
+    default:
+      throw new Error(`Unknown credential_type: ${credential_type}`);
+  }
+};
+
+// src/lib/crypto.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var generateKey = async () => {
+  return {
+    iv: window.crypto.getRandomValues(new Uint8Array(12)),
+    key: await window.crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"])
+  };
+};
+var exportKey = async (key) => {
+  return buffer_encode(await window.crypto.subtle.exportKey("raw", key));
+};
+var encryptRequest = async (key, iv, request) => {
+  return {
+    iv: buffer_encode(iv),
+    payload: buffer_encode(
+      await window.crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, encoder.encode(request))
+    )
+  };
+};
+var decryptResponse = async (key, iv, payload) => {
+  return decoder.decode(await window.crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, buffer_decode(payload)));
+};
+
+// src/bridge.ts
+var DEFAULT_BRIDGE_URL = "https://bridge.worldcoin.org";
+var useWorldBridgeStore = (0, import_zustand.create)((set, get) => ({
+  iv: null,
+  key: null,
+  result: null,
+  errorCode: null,
+  requestId: null,
+  connectorURI: null,
+  bridge_url: DEFAULT_BRIDGE_URL,
+  verificationState: "loading_widget" /* PreparingClient */,
+  createClient: async ({ bridge_url, app_id, verification_level, action_description, action, signal }) => {
+    const { key, iv } = await generateKey();
+    const res = await fetch(`${bridge_url ?? DEFAULT_BRIDGE_URL}/request`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(
+        await encryptRequest(
+          key,
+          iv,
+          JSON.stringify({
+            app_id,
+            action_description,
+            action: encodeAction(action),
+            signal: generateSignal(signal).digest,
+            credential_types: verification_level_to_credential_types(
+              verification_level ?? DEFAULT_VERIFICATION_LEVEL
+            ),
+            verification_level: verification_level ?? DEFAULT_VERIFICATION_LEVEL
+          })
+        )
+      )
+    });
+    if (!res.ok) {
+      set({ verificationState: "failed" /* Failed */ });
+      throw new Error("Failed to create client");
+    }
+    const { request_id } = await res.json();
+    set({
+      iv,
+      key,
+      requestId: request_id,
+      bridge_url: bridge_url ?? DEFAULT_BRIDGE_URL,
+      verificationState: "awaiting_connection" /* WaitingForConnection */,
+      connectorURI: `https://worldcoin.org/verify?t=wld&i=${request_id}&k=${encodeURIComponent(
+        await exportKey(key)
+      )}${bridge_url && bridge_url !== DEFAULT_BRIDGE_URL ? `&b=${encodeURIComponent(bridge_url)}` : ""}`
+    });
+  },
+  pollForUpdates: async () => {
+    const key = get().key;
+    if (!key)
+      throw new Error("No keypair found. Please call `createClient` first.");
+    const res = await fetch(`${get().bridge_url}/response/${get().requestId}`);
+    if (!res.ok) {
+      return set({
+        errorCode: "connection_failed" /* ConnectionFailed */,
+        verificationState: "failed" /* Failed */
+      });
+    }
+    const { response, status } = await res.json();
+    if (status != "completed" /* Completed */) {
+      return set({
+        verificationState: status == "retrieved" /* Retrieved */ ? "awaiting_app" /* WaitingForApp */ : "awaiting_connection" /* WaitingForConnection */
+      });
+    }
+    let result = JSON.parse(
+      await decryptResponse(key, buffer_decode(response.iv), response.payload)
+    );
+    if ("error_code" in result) {
+      return set({
+        errorCode: result.error_code,
+        verificationState: "failed" /* Failed */
+      });
+    }
+    if ("credential_type" in result) {
+      result = {
+        verification_level: credential_type_to_verification_level(result.credential_type),
+        ...result
+      };
+    }
+    set({
+      result,
+      key: null,
+      requestId: null,
+      connectorURI: null,
+      verificationState: "confirmed" /* Confirmed */
+    });
+  },
+  reset: () => {
+    set({
+      iv: null,
+      key: null,
+      result: null,
+      errorCode: null,
+      requestId: null,
+      connectorURI: null,
+      verificationState: "loading_widget" /* PreparingClient */
+    });
+  }
+}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppErrorCodes,
+  CredentialType,
+  DEFAULT_VERIFICATION_LEVEL,
+  VerificationLevel,
+  VerificationState,
+  useWorldBridgeStore,
+  verification_level_to_credential_types
+});

package/build/index.d.cts

@@ -0,0 +1,60 @@
+import { V as VerificationLevel, I as IDKitConfig } from './config-a2bbeb0d.js';
+export { A as AbiEncodedValue, C as CredentialType } from './config-a2bbeb0d.js';
+import * as zustand from 'zustand';
+
+declare enum AppErrorCodes {
+    ConnectionFailed = "connection_failed",
+    VerificationRejected = "verification_rejected",
+    MaxVerificationsReached = "max_verifications_reached",
+    CredentialUnavailable = "credential_unavailable",
+    MalformedRequest = "malformed_request",
+    InvalidNetwork = "invalid_network",
+    InclusionProofFailed = "inclusion_proof_failed",
+    InclusionProofPending = "inclusion_proof_pending",
+    UnexpectedResponse = "unexpected_response",// NOTE: when the World app returns an unexpected response
+    FailedByHostApp = "failed_by_host_app",// NOTE: Host app failed/rejected verification (does not come from World App / simulator)
+    GenericError = "generic_error"
+}
+declare enum VerificationState {
+    PreparingClient = "loading_widget",
+    WaitingForConnection = "awaiting_connection",// Awaiting connection from the wallet
+    WaitingForApp = "awaiting_app",// Awaiting user confirmation in wallet
+    Confirmed = "confirmed",
+    Failed = "failed"
+}
+
+interface ISuccessResult {
+    proof: string;
+    merkle_root: string;
+    nullifier_hash: string;
+    verification_level: VerificationLevel;
+}
+interface IErrorState {
+    code: AppErrorCodes;
+    message?: string;
+}
+
+type WorldBridgeStore = {
+    bridge_url: string;
+    iv: Uint8Array | null;
+    key: CryptoKey | null;
+    requestId: string | null;
+    connectorURI: string | null;
+    result: ISuccessResult | null;
+    errorCode: AppErrorCodes | null;
+    verificationState: VerificationState;
+    createClient: (config: IDKitConfig) => Promise<void>;
+    pollForUpdates: () => Promise<void>;
+    reset: () => void;
+};
+declare const useWorldBridgeStore: zustand.UseBoundStore<zustand.StoreApi<WorldBridgeStore>>;
+
+declare const DEFAULT_VERIFICATION_LEVEL = VerificationLevel.Orb;
+/**
+ * @dev use to convert verification level to accepted credential types for proof request
+ * @param verification_level
+ * @returns
+ */
+declare const verification_level_to_credential_types: (verification_level: VerificationLevel) => string[];
+
+export { AppErrorCodes, DEFAULT_VERIFICATION_LEVEL, IDKitConfig, IErrorState, ISuccessResult, VerificationLevel, VerificationState, WorldBridgeStore, useWorldBridgeStore, verification_level_to_credential_types };

package/build/lib/hashing.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/hashing.ts
+var hashing_exports = {};
+__export(hashing_exports, {
+  encodeAction: () => encodeAction,
+  generateSignal: () => generateSignal,
+  hashToField: () => hashToField,
+  packAndEncode: () => packAndEncode,
+  solidityEncode: () => solidityEncode
+});
+module.exports = __toCommonJS(hashing_exports);
+var import_buffer = require("buffer/index.js");
+var import_viem = require("viem");
+function hashToField(input) {
+  if ((0, import_viem.isBytes)(input) || (0, import_viem.isHex)(input))
+    return hashEncodedBytes(input);
+  return hashString(input);
+}
+function packAndEncode(input) {
+  const [types, values] = input.reduce(
+    ([types2, values2], [type, value]) => {
+      types2.push(type);
+      values2.push(value);
+      return [types2, values2];
+    },
+    [[], []]
+  );
+  return hashEncodedBytes((0, import_viem.encodePacked)(types, values));
+}
+function hashString(input) {
+  const bytesInput = import_buffer.Buffer.from(input);
+  return hashEncodedBytes(bytesInput);
+}
+function hashEncodedBytes(input) {
+  const hash = BigInt((0, import_viem.keccak256)(input)) >> 8n;
+  const rawDigest = hash.toString(16);
+  return { hash, digest: `0x${rawDigest.padStart(64, "0")}` };
+}
+var solidityEncode = (types, values) => {
+  if (types.length !== values.length) {
+    throw new Error("Types and values arrays must have the same length.");
+  }
+  return { types, values };
+};
+var generateSignal = (signal) => {
+  if (!signal || typeof signal === "string")
+    return hashToField(signal ?? "");
+  return packAndEncode(signal.types.map((type, index) => [type, signal.values[index]]));
+};
+var encodeAction = (action) => {
+  if (!action)
+    return "";
+  if (typeof action === "string")
+    return action;
+  return action.types.map((type, index) => `${type}(${action.values[index]})`).join(",");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  encodeAction,
+  generateSignal,
+  hashToField,
+  packAndEncode,
+  solidityEncode
+});

package/build/lib/hashing.d.cts

@@ -0,0 +1,20 @@
+import { A as AbiEncodedValue, I as IDKitConfig } from '../config-a2bbeb0d.js';
+
+interface HashFunctionOutput {
+    hash: bigint;
+    digest: `0x${string}`;
+}
+/**
+ * Hashes an input using the `keccak256` hashing function used across the World ID protocol, to be used as
+ * a ZKP input. The function will try to determine the best hashing mechanism, if the string already looks like hex-encoded
+ * bytes (e.g. `0x0000000000000000000000000000000000000000`), it will be hashed directly.
+ * @param input Any string, hex-like string, bytes represented as a hex string.
+ * @returns
+ */
+declare function hashToField(input: Uint8Array | string): HashFunctionOutput;
+declare function packAndEncode(input: [string, unknown][]): HashFunctionOutput;
+declare const solidityEncode: (types: string[], values: unknown[]) => AbiEncodedValue;
+declare const generateSignal: (signal: IDKitConfig['signal']) => HashFunctionOutput;
+declare const encodeAction: (action: IDKitConfig['action']) => string;
+
+export { HashFunctionOutput, encodeAction, generateSignal, hashToField, packAndEncode, solidityEncode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worldcoin/idkit-core",
-  "version": "1.0.0-alpha.6",
+  "version": "1.0.0",
   "homepage": "https://docs.worldcoin.org/id/idkit",
   "license": "MIT",
   "private": false,
@@ -14,11 +14,13 @@
   "exports": {
     ".": {
       "import": "./build/index.js",
-      "types": "./build/index.d.ts"
+      "types": "./build/index.d.ts",
+      "require": "./build/index.cjs"
     },
     "./hashing": {
       "import": "./build/lib/hashing.js",
-      "types": "./build/lib/hashing.d.ts"
+      "types": "./build/lib/hashing.d.ts",
+      "require": "./build/lib/hashing.cjs"
     }
   },
   "typesVersions": {
@@ -27,7 +29,6 @@
         "./build/lib/hashing.d.ts"
       ],
       "*": [
-        "./build/*/index.d.ts",
         "./build/index.d.ts"
       ]
     }