@worldcoin/idkit-core 1.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2022 Worldcoin Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/build/chunk-25ALATTL.js

@@ -0,0 +1,54 @@
+// src/lib/hashing.ts
+import { Buffer } from "buffer/index";
+import { encodePacked, isBytes, isHex, keccak256 } from "viem";
+function hashToField(input) {
+  if (isBytes(input) || 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(encodePacked(types, values));
+}
+function hashString(input) {
+  const bytesInput = Buffer.from(input);
+  return hashEncodedBytes(bytesInput);
+}
+function hashEncodedBytes(input) {
+  const hash = BigInt(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(",");
+};
+
+export {
+  hashToField,
+  packAndEncode,
+  solidityEncode,
+  generateSignal,
+  encodeAction
+};

package/build/config-5feac22f.d.ts

@@ -0,0 +1,28 @@
+declare const brand: unique symbol;
+type Brand<T, TBrand extends string> = T & {
+    [brand]: TBrand;
+};
+type AbiEncodedValue = Brand<{
+    types: string[];
+    values: unknown[];
+}, 'AbiEncodedValue'>;
+declare enum CredentialType {
+    Orb = "orb",
+    Device = "device"
+}
+type IDKitConfig = {
+    /** Unique identifier for the app verifying the action. This should be the app ID obtained from the Developer Portal. */
+    app_id: string;
+    /** The description of the specific action (shown to users in World App). Only recommended for actions created on-the-fly. */
+    action_description?: string;
+    /** Encodes data into a proof that must match when validating. Read more on the [On-chain section](https://docs.worldcoin.org/advanced/on-chain). */
+    signal?: AbiEncodedValue | string;
+    /** Identifier for the action the user is performing. Should be left blank for [Sign in with Worldcoin](https://docs.worldcoin.org/id/sign-in). */
+    action?: AbiEncodedValue | string;
+    /** URL to a third-party bridge to use when connecting to the World App. Optional. */
+    bridge_url?: string;
+    /** An array of credential types to allow for verification. Will accept any combination of "orb" & "device". Defaults to orb. TypeScript apps can use the `CredentialType` enum. */
+    credential_types?: CredentialType[];
+};
+
+export { AbiEncodedValue as A, CredentialType as C, IDKitConfig as I };

package/build/index.d.ts

@@ -0,0 +1,52 @@
+import { C as CredentialType, I as IDKitConfig } from './config-5feac22f.js';
+export { A as AbiEncodedValue } from './config-5feac22f.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",
+    FailedByHostApp = "failed_by_host_app",
+    GenericError = "generic_error"
+}
+declare enum VerificationState {
+    PreparingClient = "loading_widget",
+    WaitingForConnection = "awaiting_connection",
+    WaitingForApp = "awaiting_app",
+    Confirmed = "confirmed",
+    Failed = "failed"
+}
+
+interface ISuccessResult {
+    proof: string;
+    merkle_root: string;
+    nullifier_hash: string;
+    credential_type: CredentialType;
+}
+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: (app_id: IDKitConfig['app_id'], action: IDKitConfig['action'], signal?: IDKitConfig['signal'], bridge_url?: IDKitConfig['bridge_url'], credential_types?: IDKitConfig['credential_types'], action_description?: IDKitConfig['action_description']) => Promise<void>;
+    pollForUpdates: () => Promise<void>;
+    reset: () => void;
+};
+declare const useWorldBridgeStore: zustand.UseBoundStore<zustand.StoreApi<WorldBridgeStore>>;
+
+export { AppErrorCodes, CredentialType, IDKitConfig, IErrorState, ISuccessResult, VerificationState, WorldBridgeStore, useWorldBridgeStore };

package/build/index.js

@@ -0,0 +1,154 @@
+import {
+  encodeAction,
+  generateSignal
+} from "./chunk-25ALATTL.js";
+
+// 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 || {});
+
+// src/bridge.ts
+import { create } from "zustand";
+
+// src/lib/utils.ts
+import { Buffer } from "buffer/index";
+var buffer_encode = (buffer) => {
+  return Buffer.from(buffer).toString("base64");
+};
+var buffer_decode = (encoded) => {
+  return Buffer.from(encoded, "base64");
+};
+
+// 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 = 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 (app_id, action, signal, bridge_url, credential_types, action_description) => {
+    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,
+            credential_types,
+            action_description,
+            action: encodeAction(action),
+            signal: generateSignal(signal).digest
+          })
+        )
+      )
+    });
+    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}`);
+    const { response, status } = await res.json();
+    if (status != "completed" /* Completed */) {
+      return set({
+        verificationState: status == "retrieved" /* Retrieved */ ? "awaiting_app" /* WaitingForApp */ : "awaiting_connection" /* WaitingForConnection */
+      });
+    }
+    const 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 */
+      });
+    }
+    set({ result, verificationState: "confirmed" /* Confirmed */, key: null, connectorURI: null, requestId: null });
+  },
+  reset: () => {
+    set({
+      iv: null,
+      key: null,
+      requestId: null,
+      connectorURI: null,
+      verificationState: "loading_widget" /* PreparingClient */
+    });
+  }
+}));
+export {
+  AppErrorCodes,
+  CredentialType,
+  VerificationState,
+  useWorldBridgeStore
+};

package/build/lib/hashing.d.ts

@@ -0,0 +1,20 @@
+import { A as AbiEncodedValue, I as IDKitConfig } from '../config-5feac22f.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/build/lib/hashing.js

@@ -0,0 +1,14 @@
+import {
+  encodeAction,
+  generateSignal,
+  hashToField,
+  packAndEncode,
+  solidityEncode
+} from "../chunk-25ALATTL.js";
+export {
+  encodeAction,
+  generateSignal,
+  hashToField,
+  packAndEncode,
+  solidityEncode
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@worldcoin/idkit-core",
+  "version": "1.0.0-alpha.0",
+  "homepage": "https://docs.worldcoin.org/id/idkit",
+  "license": "MIT",
+  "private": false,
+  "description": "The identity SDK. Privacy-preserving identity and proof of personhood with World ID.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/worldcoin/idkit-js",
+    "directory": "packages/core"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./build/index.js",
+      "types": "./build/index.d.ts"
+    },
+    "./hashing": {
+      "import": "./build/lib/hashing.js",
+      "types": "./build/lib/hashing.d.ts"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "hashing": [
+        "./build/lib/hashing.d.ts"
+      ],
+      "*": [
+        "./build/*/index.d.ts",
+        "./build/index.d.ts"
+      ]
+    }
+  },
+  "engines": {
+    "node": ">=12.4"
+  },
+  "files": [
+    "build/**",
+    "README.md"
+  ],
+  "keywords": [
+    "identity",
+    "ID",
+    "web3",
+    "proof-of-personhood",
+    "sybil resistance"
+  ],
+  "dependencies": {
+    "buffer": "^6.0.3",
+    "viem": "^1.14.0",
+    "zustand": "^4.3.3"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "6.7.4",
+    "@typescript-eslint/parser": "6.7.4",
+    "esbuild": "0.14.43",
+    "prettier": "^2.7.1",
+    "prettier-plugin-sort-imports-desc": "^1.0.0",
+    "tsup": "^7.2.0",
+    "typescript": "5.2.2"
+  },
+  "scripts": {
+    "lint": "eslint src --ext .ts",
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}