@worldcoin/idkit 0.4.9 → 0.5.1

package/build/src/components/IDKitWidget/experimental/components/CountryCodeSelect.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+type Props = {
+    value: string;
+    onChange: (value: string) => void;
+};
+declare const CountryCodeSelect: ({ value, onChange }: Props) => JSX.Element;
+export default CountryCodeSelect;

package/build/src/components/IDKitWidget/experimental/states/EnterPhoneState.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const EnterPhoneState: () => JSX.Element;
+export default EnterPhoneState;

package/build/src/components/IDKitWidget/experimental/states/SelectMethodState.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const SelectMethodState: () => JSX.Element;
+export default SelectMethodState;

package/build/src/components/IDKitWidget/experimental/states/VerifyCodeState.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const VerifyCodeState: () => JSX.Element;
+export default VerifyCodeState;

package/build/src/components/Icons/DevicePhoneMobileIcon.d.ts

@@ -0,0 +1,3 @@
+import type { FC, HTMLAttributes } from 'react';
+declare const DevicePhoneMobileIcon: FC<HTMLAttributes<SVGElement>>;
+export default DevicePhoneMobileIcon;

package/build/src/components/PhoneInput.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare const _default: import("react").MemoExoticComponent<({ disabled, onSubmit }: {
+    disabled?: boolean | undefined;
+    onSubmit?: (() => void | Promise<void>) | undefined;
+}) => JSX.Element>;
+export default _default;

package/build/src/components/ResendButton.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const _default: import("react").MemoExoticComponent<() => JSX.Element>;
+export default _default;

package/build/src/components/SMSCodeInput.d.ts

@@ -0,0 +1,6 @@
+import type { RefObject } from 'react';
+declare const _default: import("react").MemoExoticComponent<({ submitRef, disabled }: {
+    submitRef: RefObject<HTMLButtonElement>;
+    disabled?: boolean | undefined;
+}) => JSX.Element>;
+export default _default;

package/build/src/components/SignInWithWorldID.d.ts

@@ -1,6 +1,6 @@
 import type { FC } from 'react';
 import type { IDKitConfig, WidgetConfig } from '../types/config';
-type Props = Omit<WidgetConfig, 'autoClose'> & Pick<IDKitConfig, 'app_id' | 'walletConnectProjectId'> & {
+type Props = Omit<WidgetConfig, 'autoClose' | 'experimental_methods' | 'handleVerify'> & Pick<IDKitConfig, 'app_id' | 'walletConnectProjectId'> & {
     nonce?: string;
     onSuccess: (jwt: string) => void;
     children?: ({ open }: {

package/build/src/hooks/useIDKit.d.ts

@@ -1,5 +1,5 @@
 import type { Config } from '../types/config';
-type HookConfig = Pick<Config, 'handleVerify' | 'onSuccess'>;
+type HookConfig = Partial<Pick<Config, 'handleVerify' | 'onSuccess'>>;
 declare const useIDKit: ({ handleVerify, onSuccess }?: HookConfig) => {
     open: boolean;
     setOpen: (open: boolean) => void;

package/build/src/index.d.ts

@@ -4,6 +4,7 @@ import { CredentialType } from './types';
 import type { ISuccessResult } from './types';
 import { solidityEncode } from './lib/hashing';
 import IDKitWidget from './components/IDKitWidget';
+import SignInButton from './components/SignInButton';
 import type { WidgetProps, Config } from './types/config';
 import { VerificationState, AppErrorCodes } from './types/app';
 import SignInWithWorldID from './components/SignInWithWorldID';
@@ -29,5 +30,5 @@ declare const internal: {
     VerificationState: typeof VerificationState;
     AppErrorCodes: typeof AppErrorCodes;
 };
-export { IDKitWidget, useIDKit, solidityEncode, internal, SignInWithWorldID, CredentialType };
+export { IDKitWidget, useIDKit, solidityEncode, internal, SignInWithWorldID, CredentialType, SignInButton };
 export type { ISuccessResult, Config, WidgetProps };

package/build/src/lang/index.d.ts

@@ -0,0 +1,9 @@
+type CleanWord<T> = T extends `${string}${' ' | ',' | '!' | '?' | '.' | '`'}${string}` ? never : T extends '' ? never : T;
+type ExtractPlaceholders<S extends string> = S extends `${string}:${infer Placeholder}` ? Placeholder extends `${infer Word}${' ' | ',' | '!' | '?' | '.' | '`'}${infer Rest}` ? CleanWord<Word> | ExtractPlaceholders<Rest> : never : never;
+type NoPlaceholder<S extends string> = S extends `${string}:${string}` ? never : S;
+type PlaceholderValues<S extends string> = {
+    [K in ExtractPlaceholders<S>]: string;
+};
+export declare function __<S extends `${string}:${string}`>(str: S, params: PlaceholderValues<S>): string;
+export declare function __<S extends string>(str: NoPlaceholder<S>): string;
+export {};

package/build/src/lib/hashing.d.ts

@@ -1,11 +1,9 @@
-/// <reference types="node" />
 import type { AbiEncodedValue } from '../types';
 import type { IDKitConfig } from '../types/config';
-import type { BytesLike } from '@ethersproject/bytes';
-export interface HashFunctionOutput {
+export type HashFunctionOutput = {
     hash: BigInt;
-    digest: string;
-}
+    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
@@ -13,7 +11,7 @@ export interface HashFunctionOutput {
  * @param input Any string, hex-like string, bytes represented as a hex string.
  * @returns
  */
-export declare function hashToField(input: Buffer | BytesLike): HashFunctionOutput;
+export declare function hashToField(input: Uint8Array | string | `0x${string}`): HashFunctionOutput;
 export declare function packAndEncode(input: [string, unknown][]): HashFunctionOutput;
 export declare const validateABILikeEncoding: (value: string) => boolean;
 export declare const solidityEncode: (types: string[], values: unknown[]) => AbiEncodedValue;

package/build/src/lib/telemetry.d.ts

@@ -1,3 +1,6 @@
+import type { PhoneVerificationChannel } from '../types';
 export declare const getTelemetryId: () => string;
 export declare const initTelemetry: (enableTelemetry?: boolean) => void;
 export declare const telemetryModalOpened: () => void;
+export declare const telemetryPhoneTyped: () => void;
+export declare const telemetryRetryCode: (channel: PhoneVerificationChannel) => void;

package/build/src/services/phone.d.ts

@@ -0,0 +1,21 @@
+/**
+ * This module is fully experimental. Usage is not yet supported except as individually shared.
+ */
+import type { PhoneRequestErrorCodes, PhoneSignalProof, PhoneVerificationChannel } from '../types';
+export declare function requestCode(phone_number: string, app_id: string, channel: PhoneVerificationChannel, ph_distinct_id: string): Promise<void>;
+interface VerifyCodeSuccess extends Pick<PhoneSignalProof, 'signature' | 'timestamp'> {
+    success: true;
+    nullifier_hash: string;
+}
+export declare function verifyCode(phone_number: string, code: string, app_id: string, ph_distinct_id: string): Promise<VerifyCodeSuccess>;
+interface RequestCodeError {
+    code: PhoneRequestErrorCodes;
+    detail: string;
+}
+export declare function isRequestCodeError(error: unknown): error is RequestCodeError;
+export interface VerifyCodeError {
+    code: 'invalid_code';
+    details: string;
+}
+export declare function isVerifyCodeError(error: unknown): error is VerifyCodeError;
+export {};

package/build/src/store/idkit.d.ts

@@ -1,6 +1,7 @@
 import { IDKITStage } from '../types';
-import type { CallbackFn, IErrorState, ISuccessResult } from '../types';
+import type { VerificationMethods } from '../types/config';
 import type { Config, ConfigSource, IDKitConfig } from '../types/config';
+import type { CallbackFn, IErrorState, IExperimentalSuccessResult, ISuccessResult } from '../types';
 export type IDKitStore = {
     app_id: IDKitConfig['app_id'];
     action: IDKitConfig['action'];
@@ -8,30 +9,33 @@ export type IDKitStore = {
     action_description?: IDKitConfig['action_description'];
     walletConnectProjectId?: IDKitConfig['walletConnectProjectId'];
     credential_types?: IDKitConfig['credential_types'];
+    phoneNumber: string;
     code: string;
     open: boolean;
     stage: IDKITStage;
     autoClose: boolean;
     processing: boolean;
-    copy: Config['copy'];
     theme: Config['theme'];
-    result: ISuccessResult | null;
+    result: IExperimentalSuccessResult | ISuccessResult | null;
+    methods: VerificationMethods[];
     errorState: IErrorState | null;
-    verifyCallbacks: Record<ConfigSource, CallbackFn | undefined> | Record<string, never>;
-    successCallbacks: Record<ConfigSource, CallbackFn | undefined> | Record<string, never>;
+    verifyCallbacks: Record<ConfigSource, CallbackFn<IExperimentalSuccessResult> | CallbackFn<ISuccessResult> | undefined> | Record<string, never>;
+    successCallbacks: Record<ConfigSource, CallbackFn<IExperimentalSuccessResult> | CallbackFn<ISuccessResult> | undefined> | Record<string, never>;
     computed: {
         canGoBack: (stage: IDKITStage) => boolean;
+        getDefaultStage: (methods?: Config['experimental_methods']) => IDKITStage;
     };
     retryFlow: () => void;
     setCode: (code: string) => void;
     setStage: (stage: IDKITStage) => void;
     onOpenChange: (open: boolean) => void;
     setProcessing: (processing: boolean) => void;
-    handleVerify: (result: ISuccessResult) => void;
+    handleVerify: (result: IExperimentalSuccessResult | ISuccessResult) => void;
     setErrorState: (state: IErrorState | null) => void;
     setOptions: (options: Config, source: ConfigSource) => void;
-    addSuccessCallback: (cb: CallbackFn, source: ConfigSource) => void;
-    addVerificationCallback: (cb: CallbackFn, source: ConfigSource) => void;
+    addSuccessCallback: (cb: CallbackFn<IExperimentalSuccessResult> | CallbackFn<ISuccessResult>, source: ConfigSource) => void;
+    addVerificationCallback: (cb: CallbackFn<IExperimentalSuccessResult> | CallbackFn<ISuccessResult>, source: ConfigSource) => void;
+    setPhoneNumber: (phoneNumber: string) => void;
 };
 declare const useIDKitStore: import("zustand").UseBoundStore<import("zustand").StoreApi<IDKitStore>>;
 export default useIDKitStore;

package/build/src/types/app.d.ts

@@ -10,7 +10,8 @@ export declare enum AppErrorCodes {
     InclusionProofPending = "inclusion_proof_pending",
     UnexpectedResponse = "unexpected_response",
     FailedByHostApp = "failed_by_host_app",
-    GenericError = "generic_error"
+    GenericError = "generic_error",
+    InvalidPhoneOTP = "invalid_phone_otp"
 }
 export declare enum VerificationState {
     LoadingWidget = "loading_widget",

package/build/src/types/config.d.ts

@@ -1,31 +1,45 @@
 /// <reference types="react" />
-import type { AbiEncodedValue, CallbackFn, CredentialType } from '.';
+import type { AbiEncodedValue, CallbackFn, CredentialType, IExperimentalSuccessResult, ISuccessResult } from '.';
+export type VerificationMethods = 'orb' | 'phone';
 export declare enum ConfigSource {
     HOOK = "hook",
     PROPS = "props",
     MANUAL = "manual"
 }
 export 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;
-    walletConnectProjectId?: 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;
+    walletConnectProjectId?: string;
+    /** An array of credential types to allow for verification. Will accept any combination of "orb" & "phone". Defaults to orb. TypeScript apps can use the `CredentialType` enum. */
     credential_types?: CredentialType[];
 };
 export type WidgetConfig = {
+    /** Whether to automatically close the widget after a successful verification. Defaults to `false`. */
     autoClose?: boolean;
-    onSuccess?: CallbackFn;
+    /** The theme to apply to the widget's UI. Defaults to `light`. */
     theme?: 'dark' | 'light';
+    /** Whether opt-in telemetry is enabled. Very few events are sent, with no PII to help improve the project. Defaults to `false`. */
     enableTelemetry?: boolean;
-    handleVerify?: CallbackFn;
-    copy?: {
-        title?: string;
-        heading?: string;
-        subheading?: string;
-        success?: string;
-    };
-};
+} & ({
+    /** Optionally enable the experimental verification flow. This flow is not recommended for production apps. */
+    experimental_methods?: VerificationMethods[];
+    /** Function to trigger when verification is successful. Should receive a single parameter of type `IExperimentalSuccessResult` which contains the proof details. */
+    onSuccess: CallbackFn<IExperimentalSuccessResult>;
+    /** Called after the proof is returned from the World App, but before showing the success screen. Throwing an error in this screen will show the user a custom error. Used to perform additional validation when needed. */
+    handleVerify?: CallbackFn<IExperimentalSuccessResult>;
+} | {
+    experimental_methods?: never;
+    /** Function to trigger when verification is successful. Should receive a single parameter of type `ISuccessResult` which contains the proof details. */
+    onSuccess: CallbackFn<ISuccessResult>;
+    /** Called after the proof is returned from the World App, but before showing the success screen. Throwing in this screen will show the user a custom error. Used to perform additional validation when needed. */
+    handleVerify?: CallbackFn<ISuccessResult>;
+});
 export type Config = IDKitConfig & Required<Pick<IDKitConfig, 'action'>> & WidgetConfig;
 export type WidgetProps = Config & {
     children?: ({ open }: {

package/build/src/types/index.d.ts

@@ -1,4 +1,5 @@
 import type { AppErrorCodes } from './app';
+import type { VerificationMethods } from './config';
 declare const brand: unique symbol;
 type Brand<T, TBrand extends string> = T & {
     [brand]: TBrand;
@@ -8,6 +9,9 @@ export type AbiEncodedValue = Brand<{
     values: unknown[];
 }, 'AbiEncodedValue'>;
 export declare enum IDKITStage {
+    SELECT_METHOD = "SELECT_METHOD",
+    ENTER_PHONE = "ENTER_PHONE",
+    ENTER_CODE = "ENTER_CODE",
     WORLD_ID = "WORLD_ID",
     PRIVACY = "PRIVACY",
     SUCCESS = "SUCCESS",
@@ -18,13 +22,18 @@ export declare enum CredentialType {
     Orb = "orb",
     Phone = "phone"
 }
+export interface IExperimentalSuccessResult {
+    nullifier_hash: string;
+    credential_type: VerificationMethods;
+    proof_payload: OrbSignalProof | PhoneSignalProof;
+}
 export interface ISuccessResult {
     proof: string;
     merkle_root: string;
     nullifier_hash: string;
     credential_type: CredentialType;
 }
-export type CallbackFn = (result: ISuccessResult) => Promise<void> | void;
+export type CallbackFn<T> = (result: T) => Promise<void> | void;
 export interface ExpectedErrorResponse {
     message: string;
     stack: string;
@@ -33,4 +42,22 @@ export interface IErrorState {
     code: AppErrorCodes;
     message?: string;
 }
+export declare enum PhoneVerificationChannel {
+    SMS = "sms",
+    Call = "call"
+}
+export declare enum PhoneRequestErrorCodes {
+    MAX_ATTEMPTS = "max_attempts",
+    TIMEOUT = "timeout",
+    UNSUPPORTED_COUNTRY = "unsupported_country",
+    SERVER_ERROR = "server_error"
+}
+export interface OrbSignalProof {
+    merkle_root: string;
+    proof: string;
+}
+export interface PhoneSignalProof {
+    timestamp: number;
+    signature: string;
+}
 export {};