@worldcoin/idkit-core 2.1.0 → 4.0.0-dev.777cdbe

package/build/index.d.cts

@@ -1,37 +0,0 @@
-import { I as ISuccessResult, A as AppErrorCodes, V as VerificationState } from './result-BZ4QXOc2.cjs';
-export { a as IErrorState } from './result-BZ4QXOc2.cjs';
-import { I as IDKitConfig, V as VerificationLevel } from './config-fuwC_Hia.cjs';
-export { A as AbiEncodedValue, C as CredentialType } from './config-fuwC_Hia.cjs';
-import * as zustand from 'zustand';
-
-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;
-};
-/**
- * Single instance of the store
- */
-declare const useWorldBridgeStore: zustand.UseBoundStore<zustand.StoreApi<WorldBridgeStore>>;
-/**
- * Factory function to create a new instance of the store
- */
-declare const createWorldBridgeStore: () => 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, ISuccessResult, VerificationLevel, VerificationState, type WorldBridgeStore, createWorldBridgeStore, useWorldBridgeStore, verification_level_to_credential_types };

package/build/index.d.ts

@@ -1,37 +0,0 @@
-import { I as ISuccessResult, A as AppErrorCodes, V as VerificationState } from './result-CqgtArQe.js';
-export { a as IErrorState } from './result-CqgtArQe.js';
-import { I as IDKitConfig, V as VerificationLevel } from './config-fuwC_Hia.js';
-export { A as AbiEncodedValue, C as CredentialType } from './config-fuwC_Hia.js';
-import * as zustand from 'zustand';
-
-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;
-};
-/**
- * Single instance of the store
- */
-declare const useWorldBridgeStore: zustand.UseBoundStore<zustand.StoreApi<WorldBridgeStore>>;
-/**
- * Factory function to create a new instance of the store
- */
-declare const createWorldBridgeStore: () => 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, ISuccessResult, VerificationLevel, VerificationState, type WorldBridgeStore, createWorldBridgeStore, useWorldBridgeStore, verification_level_to_credential_types };

package/build/index.js

@@ -1,358 +0,0 @@
-import {
-  encodeAction,
-  generateSignal
-} from "./chunk-HZ2SQA5V.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["SecureDocument"] = "secure_document";
-  CredentialType2["Document"] = "document";
-  CredentialType2["Device"] = "device";
-  return CredentialType2;
-})(CredentialType || {});
-var VerificationLevel = /* @__PURE__ */ ((VerificationLevel2) => {
-  VerificationLevel2["Orb"] = "orb";
-  VerificationLevel2["SecureDocument"] = "secure_document";
-  VerificationLevel2["Document"] = "document";
-  VerificationLevel2["Device"] = "device";
-  return VerificationLevel2;
-})(VerificationLevel || {});
-
-// src/bridge.ts
-import { create } from "zustand";
-
-// src/lib/validation.ts
-function validate_bridge_url(bridge_url, is_staging) {
-  try {
-    new URL(bridge_url);
-  } catch (e) {
-    return { valid: false, errors: ["Failed to parse Bridge URL."] };
-  }
-  const test_url = new URL(bridge_url);
-  const errors = [];
-  if (is_staging && ["localhost", "127.0.0.1"].includes(test_url.hostname)) {
-    console.log("Using staging app_id with localhost bridge_url. Skipping validation.");
-    return { valid: true };
-  }
-  if (test_url.protocol !== "https:") {
-    errors.push("Bridge URL must use HTTPS.");
-  }
-  if (test_url.port) {
-    errors.push("Bridge URL must use the default port (443).");
-  }
-  if (test_url.pathname !== "/") {
-    errors.push("Bridge URL must not have a path.");
-  }
-  if (test_url.search) {
-    errors.push("Bridge URL must not have query parameters.");
-  }
-  if (test_url.hash) {
-    errors.push("Bridge URL must not have a fragment.");
-  }
-  if (!test_url.hostname.endsWith(".worldcoin.org") && !test_url.hostname.endsWith(".toolsforhumanity.com")) {
-    console.warn(
-      "Bridge URL should be a subdomain of worldcoin.org or toolsforhumanity.com. The user's identity wallet may refuse to connect. This is a temporary measure and may be removed in the future."
-    );
-  }
-  if (errors.length) {
-    return { valid: false, errors };
-  }
-  return { valid: true };
-}
-
-// src/lib/platform.ts
-import { isBrowser, isNode as isNodeBoolean } from "browser-or-node";
-var isReactNative = () => {
-  return typeof navigator !== "undefined" && navigator.product === "ReactNative";
-};
-var isWeb = () => {
-  return isBrowser;
-};
-var getGlobalObject = () => {
-  if (typeof globalThis !== "undefined") return globalThis;
-  if (typeof self !== "undefined") return self;
-  if (typeof window !== "undefined") return window;
-  throw new Error("Unable to locate global object");
-};
-var getCrypto = () => {
-  const globalObj = getGlobalObject();
-  if (typeof globalObj.crypto !== "undefined") {
-    return globalObj.crypto;
-  }
-  throw new Error("Crypto API not available. For React Native, ensure polyfills are set up properly.");
-};
-
-// src/lib/utils.ts
-import { Buffer } from "buffer/index.js";
-var DEFAULT_VERIFICATION_LEVEL = "orb" /* Orb */;
-var buffer_encode = (buffer) => {
-  return Buffer.from(buffer).toString("base64");
-};
-var buffer_decode = (encoded) => {
-  return Buffer.from(encoded, "base64");
-};
-var verification_level_to_credential_types = (verification_level) => {
-  switch (verification_level) {
-    case "device" /* Device */:
-      return ["orb" /* Orb */, "device" /* Device */];
-    case "document" /* Document */:
-      return ["document" /* Document */, "secure_document" /* SecureDocument */, "orb" /* Orb */];
-    case "secure_document" /* SecureDocument */:
-      return ["secure_document" /* SecureDocument */, "orb" /* Orb */];
-    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 "secure_document" /* SecureDocument */:
-      return "secure_document" /* SecureDocument */;
-    case "document" /* Document */:
-      return "document" /* Document */;
-    case "device" /* Device */:
-      return "device" /* Device */;
-    default:
-      throw new Error(`Unknown credential_type: ${credential_type}`);
-  }
-};
-
-// src/lib/adapters/web-crypto-adapter.ts
-var WebCryptoAdapter = class {
-  constructor() {
-    this.encoder = new TextEncoder();
-    this.decoder = new TextDecoder();
-  }
-  async generateKey() {
-    return {
-      iv: window.crypto.getRandomValues(new Uint8Array(12)),
-      key: await window.crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"])
-    };
-  }
-  async exportKey(key) {
-    return buffer_encode(await window.crypto.subtle.exportKey("raw", key));
-  }
-  async encryptRequest(key, iv, request) {
-    return {
-      iv: buffer_encode(iv),
-      payload: buffer_encode(
-        await window.crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, this.encoder.encode(request))
-      )
-    };
-  }
-  async decryptResponse(key, iv, payload) {
-    return this.decoder.decode(
-      await window.crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, buffer_decode(payload))
-    );
-  }
-};
-
-// src/lib/adapters/react-native-crypto-adapter.ts
-var ReactNativeCryptoAdapter = class {
-  constructor() {
-    this.encoder = new TextEncoder();
-    this.decoder = new TextDecoder();
-  }
-  async generateKey() {
-    const crypto = getCrypto();
-    return {
-      iv: crypto.getRandomValues(new Uint8Array(12)),
-      key: await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"])
-    };
-  }
-  async exportKey(key) {
-    const crypto = getCrypto();
-    return buffer_encode(await crypto.subtle.exportKey("raw", key));
-  }
-  async encryptRequest(key, iv, request) {
-    const crypto = getCrypto();
-    return {
-      iv: buffer_encode(iv),
-      payload: buffer_encode(
-        await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, this.encoder.encode(request))
-      )
-    };
-  }
-  async decryptResponse(key, iv, payload) {
-    const crypto = getCrypto();
-    return this.decoder.decode(await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, buffer_decode(payload)));
-  }
-};
-
-// src/lib/crypto.ts
-var cryptoAdapterInstance = null;
-var getCryptoAdapter = () => {
-  if (cryptoAdapterInstance) {
-    return cryptoAdapterInstance;
-  }
-  if (isWeb()) {
-    cryptoAdapterInstance = new WebCryptoAdapter();
-    return cryptoAdapterInstance;
-  }
-  if (isReactNative()) {
-    cryptoAdapterInstance = new ReactNativeCryptoAdapter();
-    return cryptoAdapterInstance;
-  }
-  throw new Error("Unsupported platform");
-};
-var generateKey = async () => {
-  return getCryptoAdapter().generateKey();
-};
-var exportKey = async (key) => {
-  return getCryptoAdapter().exportKey(key);
-};
-var encryptRequest = async (key, iv, request) => {
-  return getCryptoAdapter().encryptRequest(key, iv, request);
-};
-var decryptResponse = async (key, iv, payload) => {
-  return getCryptoAdapter().decryptResponse(key, iv, payload);
-};
-
-// src/bridge.ts
-var DEFAULT_BRIDGE_URL = "https://bridge.worldcoin.org";
-var createStoreImplementation = (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, partner }) => {
-    const { key, iv } = await generateKey();
-    if (bridge_url) {
-      const validation = validate_bridge_url(bridge_url, app_id.includes("staging"));
-      if (!validation.valid) {
-        console.error(validation.errors.join("\n"));
-        set({ verificationState: "failed" /* Failed */ });
-        throw new Error("Invalid bridge_url. Please check the console for more details.");
-      }
-    }
-    const res = await fetch(new URL("/request", bridge_url ?? DEFAULT_BRIDGE_URL), {
-      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://world.org/verify?t=wld&i=${request_id}&k=${encodeURIComponent(
-        await exportKey(key)
-      )}${bridge_url && bridge_url !== DEFAULT_BRIDGE_URL ? `&b=${encodeURIComponent(bridge_url)}` : ""}${partner ? `&partner=${encodeURIComponent(true)}` : ""}`
-    });
-  },
-  pollForUpdates: async () => {
-    const key = get().key;
-    if (!key) throw new Error("No keypair found. Please call `createClient` first.");
-    const res = await fetch(new URL(`/response/${get().requestId}`, get().bridge_url));
-    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 */
-    });
-  }
-});
-var useWorldBridgeStore = create(createStoreImplementation);
-var createWorldBridgeStore = () => create(createStoreImplementation);
-export {
-  AppErrorCodes,
-  CredentialType,
-  DEFAULT_VERIFICATION_LEVEL,
-  VerificationLevel,
-  VerificationState,
-  createWorldBridgeStore,
-  useWorldBridgeStore,
-  verification_level_to_credential_types
-};

package/build/lib/backend.cjs

@@ -1,71 +0,0 @@
-"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/backend.ts
-var backend_exports = {};
-__export(backend_exports, {
-  verifyCloudProof: () => verifyCloudProof
-});
-module.exports = __toCommonJS(backend_exports);
-
-// src/lib/hashing.ts
-var import_buffer = require("buffer/index.js");
-var import_ox = require("ox");
-function hashToField(input) {
-  if (import_ox.Bytes.validate(input) || import_ox.Hex.validate(input)) return hashEncodedBytes(input);
-  return hashString(input);
-}
-function hashString(input) {
-  const bytesInput = import_buffer.Buffer.from(input);
-  return hashEncodedBytes(bytesInput);
-}
-function hashEncodedBytes(input) {
-  const hash = BigInt(import_ox.Hash.keccak256(input, { as: "Hex" })) >> 8n;
-  const rawDigest = hash.toString(16);
-  return { hash, digest: `0x${rawDigest.padStart(64, "0")}` };
-}
-
-// src/lib/backend.ts
-var import_browser_or_node = require("browser-or-node");
-async function verifyCloudProof(proof, app_id, action, signal, endpoint, headers) {
-  if (import_browser_or_node.isBrowser) {
-    throw new Error("verifyCloudProof can only be used in the backend.");
-  }
-  const response = await fetch(endpoint ?? `https://developer.worldcoin.org/api/v2/verify/${app_id}`, {
-    method: "POST",
-    headers: {
-      ...headers ?? {},
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      ...proof,
-      action,
-      signal_hash: hashToField(signal ?? "").digest
-    })
-  });
-  if (response.ok) {
-    return { success: true };
-  } else {
-    return { success: false, ...await response.json() };
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  verifyCloudProof
-});

package/build/lib/backend.d.cts

@@ -1,12 +0,0 @@
-import { I as ISuccessResult } from '../result-BZ4QXOc2.cjs';
-import '../config-fuwC_Hia.cjs';
-
-interface IVerifyResponse {
-    success: boolean;
-    code?: string;
-    detail?: string;
-    attribute?: string | null;
-}
-declare function verifyCloudProof(proof: ISuccessResult, app_id: `app_${string}`, action: string, signal?: string, endpoint?: URL | string, headers?: Record<string, string>): Promise<IVerifyResponse>;
-
-export { type IVerifyResponse, verifyCloudProof };

package/build/lib/backend.d.ts

@@ -1,12 +0,0 @@
-import { I as ISuccessResult } from '../result-CqgtArQe.js';
-import '../config-fuwC_Hia.js';
-
-interface IVerifyResponse {
-    success: boolean;
-    code?: string;
-    detail?: string;
-    attribute?: string | null;
-}
-declare function verifyCloudProof(proof: ISuccessResult, app_id: `app_${string}`, action: string, signal?: string, endpoint?: URL | string, headers?: Record<string, string>): Promise<IVerifyResponse>;
-
-export { type IVerifyResponse, verifyCloudProof };

package/build/lib/backend.js

@@ -1,31 +0,0 @@
-import {
-  hashToField
-} from "../chunk-HZ2SQA5V.js";
-
-// src/lib/backend.ts
-import { isBrowser } from "browser-or-node";
-async function verifyCloudProof(proof, app_id, action, signal, endpoint, headers) {
-  if (isBrowser) {
-    throw new Error("verifyCloudProof can only be used in the backend.");
-  }
-  const response = await fetch(endpoint ?? `https://developer.worldcoin.org/api/v2/verify/${app_id}`, {
-    method: "POST",
-    headers: {
-      ...headers ?? {},
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      ...proof,
-      action,
-      signal_hash: hashToField(signal ?? "").digest
-    })
-  });
-  if (response.ok) {
-    return { success: true };
-  } else {
-    return { success: false, ...await response.json() };
-  }
-}
-export {
-  verifyCloudProof
-};

package/build/lib/hashing.cjs

@@ -1,78 +0,0 @@
-"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_ox = require("ox");
-function hashToField(input) {
-  if (import_ox.Bytes.validate(input) || import_ox.Hex.validate(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(import_ox.AbiParameters.encodePacked(types, values));
-}
-function hashString(input) {
-  const bytesInput = import_buffer.Buffer.from(input);
-  return hashEncodedBytes(bytesInput);
-}
-function hashEncodedBytes(input) {
-  const hash = BigInt(import_ox.Hash.keccak256(input, { as: "Hex" })) >> 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

@@ -1,21 +0,0 @@
-import { A as AbiEncodedValue, I as IDKitConfig } from '../config-fuwC_Hia.cjs';
-import { Bytes } from 'ox';
-
-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: Bytes.Bytes | 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 { type HashFunctionOutput, encodeAction, generateSignal, hashToField, packAndEncode, solidityEncode };

package/build/lib/hashing.d.ts

@@ -1,21 +0,0 @@
-import { A as AbiEncodedValue, I as IDKitConfig } from '../config-fuwC_Hia.js';
-import { Bytes } from 'ox';
-
-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: Bytes.Bytes | 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 { type HashFunctionOutput, encodeAction, generateSignal, hashToField, packAndEncode, solidityEncode };