@worldcoin/idkit 0.0.1 → 0.0.2

package/build/lib/hashing.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import type { BytesLike } from '@ethersproject/bytes';
+import type { StringOrAdvanced } from '../types/config';
+export interface HashFunctionOutput {
+    hash: BigInt;
+    digest: 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
+ */
+export declare function worldIDHash(input: Buffer | BytesLike | StringOrAdvanced): HashFunctionOutput;
+/**
+ * Using `worldIDHash` is recommended! Use this if you're certain you want to hash a string.
+ * Converts an input to bytes and then hashes it with the World ID protocol hashing function.
+ * @param input - String to hash
+ * @returns hash
+ */
+export declare function hashString(input: string): HashFunctionOutput;
+/**
+ * Using `worldIDHash` is recommended! Use this if you're certain you want to hash raw bytes.
+ * Hashes raw bytes input using the `keccak256` hashing function used across the World ID protocol, to be used as
+ * a ZKP input. Example use cases include when you're hashing an address to be verified in a smart contract.
+ * @param input - Bytes represented as a hex string.
+ * @returns
+ */
+export declare function hashEncodedBytes(input: BytesLike): HashFunctionOutput;
+/**
+ * Partial implementation of `keccak256` hash from @ethersproject/solidity; only supports hashing a single BytesLike value
+ * @param value value to hash
+ * @returns
+ */
+export declare function keccak256(value: BytesLike): string;
+export declare const validateABILikeEncoding: (value: string) => boolean;

package/build/lib/qr.d.ts

@@ -0,0 +1,5 @@
+import type WalletConnect from '@walletconnect/client';
+/**
+ * Build data for QR Code
+ */
+export declare function buildQRData(connector: WalletConnect, returnUrl?: string): string;

package/build/lib/telemetry.d.ts

@@ -0,0 +1,4 @@
+export declare const getTelemetryId: () => string;
+export declare const initTelemetry: (enableTelemetry?: boolean) => void;
+export declare const telemetryModalOpened: () => void;
+export declare const telemetryPhoneTyped: () => void;

package/build/lib/utils.d.ts

@@ -1 +1,2 @@
-export declare const classNames: (...classes: Array<boolean | string | undefined>) => string;
+export declare const classNames: (...classes: unknown[]) => string;
+export declare const randomNumber: (min: number, max: number) => number;

package/build/services/phone.d.ts

@@ -1,6 +1,6 @@
 import type { PhoneSignalProof } from '../types';
 export declare function requestCode(phone_number: string, action_id: string, ph_distinct_id: string): Promise<void>;
-interface VerifyCodeSuccess extends Pick<PhoneSignalProof, 'timestamp' | 'signature'> {
+interface VerifyCodeSuccess extends Pick<PhoneSignalProof, 'signature' | 'timestamp'> {
     success: true;
     nullifier_hash: string;
 }

package/build/services/walletconnect.d.ts

@@ -0,0 +1,14 @@
+import type { OrbResponse } from '../types/orb';
+import type { StringOrAdvanced } from '../types/config';
+import { ErrorCodes, VerificationState } from '../types/orb';
+type UseOrbSignalResponse = {
+    result: OrbResponse | null;
+    errorCode: ErrorCodes | null;
+    verificationState: VerificationState;
+    qrData: {
+        default: string;
+        mobile: string;
+    } | null;
+};
+declare const useOrbSignal: (action_id: StringOrAdvanced, signal: StringOrAdvanced) => UseOrbSignalResponse;
+export default useOrbSignal;

package/build/store/idkit.d.ts

@@ -1,29 +1,30 @@
 import { IDKITStage } from '../types';
-import type { Config } from '../types/config';
 import type { CallbackFn, ErrorState, ISuccessResult } from '../types';
+import type { Config, ConfigSource, StringOrAdvanced } from '../types/config';
 export type IDKitStore = {
     code: string;
     open: boolean;
-    actionId: string;
     stage: IDKITStage;
     autoClose: boolean;
     phoneNumber: string;
-    copy: Config['copy'];
     processing: boolean;
+    copy: Config['copy'];
+    signal: StringOrAdvanced;
+    actionId: StringOrAdvanced;
+    stringifiedActionId: string;
     errorState: ErrorState | null;
-    successCallbacks: Array<CallbackFn>;
+    successCallbacks: Record<ConfigSource, CallbackFn | undefined> | Record<string, never>;
     retryFlow: () => void;
     setCode: (code: string) => void;
     setOpen: (open: boolean) => void;
     setStage: (stage: IDKITStage) => void;
-    setOptions: (options: Config) => void;
     onOpenChange: (open: boolean) => void;
-    setActionId: (actionId: string) => void;
     onSuccess: (result: ISuccessResult) => void;
     setProcessing: (processing: boolean) => void;
-    addSuccessCallback: (cb: CallbackFn) => void;
     setPhoneNumber: (phoneNumber: string) => void;
     setErrorState: (errorState: ErrorState | null) => void;
+    setOptions: (options: Config, source: ConfigSource) => void;
+    addSuccessCallback: (cb: CallbackFn, source: ConfigSource) => void;
 };
 declare const useIDKitStore: import("zustand").UseBoundStore<import("zustand").StoreApi<IDKitStore>>;
 export default useIDKitStore;