@p2pdotme/sdk 1.0.0

package/dist/zkkyc.cjs

@@ -0,0 +1,868 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/zkkyc/index.ts
+var zkkyc_exports = {};
+__export(zkkyc_exports, {
+  DEFAULT_RECLAIM_PROVIDER_IDS: () => DEFAULT_RECLAIM_PROVIDER_IDS,
+  RECLAIM_APP_LINKS: () => RECLAIM_APP_LINKS,
+  SOCIAL_PLATFORM_NAMES: () => SOCIAL_PLATFORM_NAMES,
+  ZK_PASSPORT_APP_LINKS: () => ZK_PASSPORT_APP_LINKS,
+  ZkkycError: () => ZkkycError,
+  createReclaimFlow: () => createReclaimFlow,
+  createZkPassportFlow: () => createZkPassportFlow,
+  createZkkyc: () => createZkkyc
+});
+module.exports = __toCommonJS(zkkyc_exports);
+
+// src/contracts/reputation-manager/writes.ts
+var import_neverthrow2 = require("neverthrow");
+var import_viem3 = require("viem");
+
+// src/validation/errors.ts
+var SdkError = class extends Error {
+  code;
+  cause;
+  context;
+  constructor(message, options) {
+    super(message);
+    this.name = "SdkError";
+    this.code = options.code;
+    this.cause = options.cause;
+    this.context = options.context;
+  }
+};
+
+// src/validation/schemas.ts
+var import_neverthrow = require("neverthrow");
+var import_viem = require("viem");
+var import_zod = require("zod");
+var ZodAddressSchema = import_zod.z.string().refine((s) => (0, import_viem.isAddress)(s), { message: "Invalid Ethereum address" });
+var ZodCurrencySchema = import_zod.z.enum([
+  "IDR",
+  "INR",
+  "BRL",
+  "ARS",
+  "MEX",
+  "VEN",
+  "EUR",
+  "NGN",
+  "USD"
+]);
+function validate(schema, data, toError) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return (0, import_neverthrow.ok)(result.data);
+  }
+  return (0, import_neverthrow.err)(toError(import_zod.z.prettifyError(result.error), result.error, data));
+}
+
+// src/zkkyc/errors.ts
+var ZkkycError = class extends SdkError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ZkkycError";
+  }
+};
+
+// src/zkkyc/validation.ts
+var import_zod2 = require("zod");
+var ZodAnonAadharProofParamsSchema = import_zod2.z.object({
+  nullifierSeed: import_zod2.z.bigint(),
+  nullifier: import_zod2.z.bigint(),
+  timestamp: import_zod2.z.bigint(),
+  signal: import_zod2.z.bigint(),
+  revealArray: import_zod2.z.tuple([import_zod2.z.bigint(), import_zod2.z.bigint(), import_zod2.z.bigint(), import_zod2.z.bigint()]),
+  packedGroth16Proof: import_zod2.z.tuple([
+    import_zod2.z.bigint(),
+    import_zod2.z.bigint(),
+    import_zod2.z.bigint(),
+    import_zod2.z.bigint(),
+    import_zod2.z.bigint(),
+    import_zod2.z.bigint(),
+    import_zod2.z.bigint(),
+    import_zod2.z.bigint()
+  ])
+});
+var ZodSocialVerifyParamsSchema = import_zod2.z.object({
+  _socialName: import_zod2.z.string(),
+  proofs: import_zod2.z.array(
+    import_zod2.z.object({
+      claimInfo: import_zod2.z.object({
+        provider: import_zod2.z.string(),
+        parameters: import_zod2.z.string(),
+        context: import_zod2.z.string()
+      }),
+      signedClaim: import_zod2.z.object({
+        claim: import_zod2.z.object({
+          identifier: import_zod2.z.string(),
+          owner: ZodAddressSchema,
+          timestampS: import_zod2.z.number(),
+          epoch: import_zod2.z.number()
+        }),
+        signatures: import_zod2.z.array(import_zod2.z.string())
+      })
+    })
+  )
+});
+var ZodSolidityVerifierParametersSchema = import_zod2.z.object({
+  version: import_zod2.z.string().refine((val) => val.startsWith("0x"), {
+    message: "Version must be a hex string"
+  }),
+  proofVerificationData: import_zod2.z.object({
+    vkeyHash: import_zod2.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+      message: "Invalid bytes32 hex string"
+    }),
+    proof: import_zod2.z.string().refine((val) => val.startsWith("0x"), {
+      message: "Proof must be a hex string"
+    }),
+    publicInputs: import_zod2.z.array(
+      import_zod2.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+        message: "Each public input must be a valid bytes32 hex string"
+      })
+    )
+  }),
+  committedInputs: import_zod2.z.string().refine((val) => val.startsWith("0x"), {
+    message: "Committed inputs must be a hex string"
+  }),
+  serviceConfig: import_zod2.z.object({
+    validityPeriodInSeconds: import_zod2.z.number().int().nonnegative(),
+    domain: import_zod2.z.string(),
+    scope: import_zod2.z.string(),
+    devMode: import_zod2.z.boolean()
+  })
+});
+var ZodZkPassportRegisterParamsSchema = import_zod2.z.object({
+  params: ZodSolidityVerifierParametersSchema,
+  isIDCard: import_zod2.z.boolean()
+});
+
+// src/contracts/abis/index.ts
+var import_viem2 = require("viem");
+
+// src/contracts/abis/order-flow-facet.ts
+var orderFlowFacetAbi = [
+  {
+    inputs: [
+      { internalType: "uint256", name: "circleId", type: "uint256" },
+      { internalType: "uint256", name: "assignUpto", type: "uint256" },
+      { internalType: "bytes32", name: "currency", type: "bytes32" },
+      { internalType: "address", name: "user", type: "address" },
+      { internalType: "uint256", name: "usdtAmount", type: "uint256" },
+      { internalType: "uint256", name: "fiatAmount", type: "uint256" },
+      { internalType: "int256", name: "orderType", type: "int256" },
+      { internalType: "uint256", name: "preferredPCConfigId", type: "uint256" }
+    ],
+    name: "getAssignableMerchantsFromCircle",
+    outputs: [{ internalType: "address[]", name: "", type: "address[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "_user", type: "address" },
+      { internalType: "bytes32", name: "_nativeCurrency", type: "bytes32" }
+    ],
+    name: "userTxLimit",
+    outputs: [
+      { internalType: "uint256", name: "", type: "uint256" },
+      { internalType: "uint256", name: "", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/contracts/abis/p2p-config-facet.ts
+var p2pConfigFacetAbi = [
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "_currency",
+        type: "bytes32"
+      }
+    ],
+    name: "getPriceConfig",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "buyPrice",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "sellPrice",
+            type: "uint256"
+          },
+          {
+            internalType: "int256",
+            name: "buyPriceOffset",
+            type: "int256"
+          },
+          {
+            internalType: "uint256",
+            name: "baseSpread",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct P2pConfigStorage.PriceConfig",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "_nativeCurrency",
+        type: "bytes32"
+      }
+    ],
+    name: "getRpPerUsdtLimitRational",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "numerator",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "denominator",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/contracts/abis/reputation-manager.ts
+var reputationManagerAbi = [
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "_socialName",
+        type: "string"
+      },
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: "string",
+                name: "provider",
+                type: "string"
+              },
+              {
+                internalType: "string",
+                name: "parameters",
+                type: "string"
+              },
+              {
+                internalType: "string",
+                name: "context",
+                type: "string"
+              }
+            ],
+            internalType: "struct IReclaimSDK.ClaimInfo",
+            name: "claimInfo",
+            type: "tuple"
+          },
+          {
+            components: [
+              {
+                components: [
+                  {
+                    internalType: "bytes32",
+                    name: "identifier",
+                    type: "bytes32"
+                  },
+                  {
+                    internalType: "address",
+                    name: "owner",
+                    type: "address"
+                  },
+                  {
+                    internalType: "uint32",
+                    name: "timestampS",
+                    type: "uint32"
+                  },
+                  {
+                    internalType: "uint32",
+                    name: "epoch",
+                    type: "uint32"
+                  }
+                ],
+                internalType: "struct IReclaimSDK.CompleteClaimData",
+                name: "claim",
+                type: "tuple"
+              },
+              {
+                internalType: "bytes[]",
+                name: "signatures",
+                type: "bytes[]"
+              }
+            ],
+            internalType: "struct IReclaimSDK.SignedClaim",
+            name: "signedClaim",
+            type: "tuple"
+          }
+        ],
+        internalType: "struct IReclaimSDK.Proof[]",
+        name: "proofs",
+        type: "tuple[]"
+      }
+    ],
+    name: "socialVerify",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "nullifierSeed",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "nullifier",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "timestamp",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "signal",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256[4]",
+        name: "revealArray",
+        type: "uint256[4]"
+      },
+      {
+        internalType: "uint256[8]",
+        name: "groth16Proof",
+        type: "uint256[8]"
+      }
+    ],
+    name: "submitAnonAadharProof",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "bytes32",
+            name: "version",
+            type: "bytes32"
+          },
+          {
+            components: [
+              {
+                internalType: "bytes32",
+                name: "vkeyHash",
+                type: "bytes32"
+              },
+              {
+                internalType: "bytes",
+                name: "proof",
+                type: "bytes"
+              },
+              {
+                internalType: "bytes32[]",
+                name: "publicInputs",
+                type: "bytes32[]"
+              }
+            ],
+            internalType: "struct ProofVerificationData",
+            name: "proofVerificationData",
+            type: "tuple"
+          },
+          {
+            internalType: "bytes",
+            name: "committedInputs",
+            type: "bytes"
+          },
+          {
+            components: [
+              {
+                internalType: "uint256",
+                name: "validityPeriodInSeconds",
+                type: "uint256"
+              },
+              {
+                internalType: "string",
+                name: "domain",
+                type: "string"
+              },
+              {
+                internalType: "string",
+                name: "scope",
+                type: "string"
+              },
+              {
+                internalType: "bool",
+                name: "devMode",
+                type: "bool"
+              }
+            ],
+            internalType: "struct ServiceConfig",
+            name: "serviceConfig",
+            type: "tuple"
+          }
+        ],
+        internalType: "struct ProofVerificationParams",
+        name: "params",
+        type: "tuple"
+      },
+      {
+        internalType: "bool",
+        name: "isIDCard",
+        type: "bool"
+      }
+    ],
+    name: "zkPassportRegister",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/contracts/abis/index.ts
+var DIAMOND_ABI = [...orderFlowFacetAbi, ...p2pConfigFacetAbi];
+var ABIS = {
+  DIAMOND: DIAMOND_ABI,
+  FACETS: {
+    ORDER_FLOW: orderFlowFacetAbi,
+    CONFIG: p2pConfigFacetAbi
+  },
+  EXTERNAL: {
+    USDC: import_viem2.erc20Abi,
+    REPUTATION_MANAGER: reputationManagerAbi
+  }
+};
+
+// src/contracts/reputation-manager/writes.ts
+function prepareSocialVerify(reputationManagerAddress, params) {
+  return validate(
+    ZodSocialVerifyParamsSchema,
+    params,
+    (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
+  ).andThen(
+    (validated) => import_neverthrow2.Result.fromThrowable(
+      () => ({
+        to: reputationManagerAddress,
+        data: (0, import_viem3.encodeFunctionData)({
+          abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
+          functionName: "socialVerify",
+          args: [
+            validated._socialName,
+            validated.proofs.map((proof) => ({
+              ...proof,
+              signedClaim: {
+                ...proof.signedClaim,
+                claim: {
+                  ...proof.signedClaim.claim,
+                  identifier: proof.signedClaim.claim.identifier
+                },
+                signatures: proof.signedClaim.signatures
+              }
+            }))
+          ]
+        })
+      }),
+      (error) => new ZkkycError("Failed to encode socialVerify", {
+        code: "ENCODE_ERROR",
+        cause: error
+      })
+    )()
+  );
+}
+function prepareSubmitAnonAadharProof(reputationManagerAddress, params) {
+  return validate(
+    ZodAnonAadharProofParamsSchema,
+    params,
+    (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
+  ).andThen(
+    (validated) => import_neverthrow2.Result.fromThrowable(
+      () => ({
+        to: reputationManagerAddress,
+        data: (0, import_viem3.encodeFunctionData)({
+          abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
+          functionName: "submitAnonAadharProof",
+          args: [
+            validated.nullifierSeed,
+            validated.nullifier,
+            validated.timestamp,
+            validated.signal,
+            validated.revealArray,
+            validated.packedGroth16Proof
+          ]
+        })
+      }),
+      (error) => new ZkkycError("Failed to encode submitAnonAadharProof", {
+        code: "ENCODE_ERROR",
+        cause: error
+      })
+    )()
+  );
+}
+function prepareZkPassportRegister(reputationManagerAddress, params) {
+  return validate(
+    ZodZkPassportRegisterParamsSchema,
+    params,
+    (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
+  ).andThen(
+    (validated) => import_neverthrow2.Result.fromThrowable(
+      () => {
+        const { proofVerificationData, serviceConfig, committedInputs, version } = validated.params;
+        const proofVerificationParams = {
+          version,
+          proofVerificationData: {
+            vkeyHash: proofVerificationData.vkeyHash,
+            proof: proofVerificationData.proof,
+            publicInputs: proofVerificationData.publicInputs
+          },
+          committedInputs,
+          serviceConfig: {
+            validityPeriodInSeconds: BigInt(serviceConfig.validityPeriodInSeconds),
+            domain: serviceConfig.domain,
+            scope: serviceConfig.scope,
+            devMode: serviceConfig.devMode
+          }
+        };
+        return {
+          to: reputationManagerAddress,
+          data: (0, import_viem3.encodeFunctionData)({
+            abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
+            functionName: "zkPassportRegister",
+            args: [proofVerificationParams, validated.isIDCard]
+          })
+        };
+      },
+      (error) => new ZkkycError("Failed to encode zkPassportRegister", {
+        code: "ENCODE_ERROR",
+        cause: error
+      })
+    )()
+  );
+}
+
+// src/zkkyc/client.ts
+function createZkkyc(config) {
+  const { reputationManagerAddress } = config;
+  return {
+    prepareSocialVerify: (params) => prepareSocialVerify(reputationManagerAddress, params),
+    prepareSubmitAnonAadharProof: (params) => prepareSubmitAnonAadharProof(reputationManagerAddress, params),
+    prepareZkPassportRegister: (params) => prepareZkPassportRegister(reputationManagerAddress, params)
+  };
+}
+
+// src/zkkyc/orchestrators/constants.ts
+var DEFAULT_RECLAIM_PROVIDER_IDS = {
+  linkedin: "6a86edbe-a0fe-420b-8db2-3155220cc949",
+  github: "033f0c06-2eb3-48c8-894c-5599c3356d1c",
+  x: "aad95818-f726-4a34-be97-8d1f47631b03",
+  instagram: "7e5b59a9-56c5-490c-a169-82a443f9b507",
+  facebook: "2701510b-c835-4820-84f0-d9e74569656b"
+};
+var ZK_PASSPORT_APP_LINKS = {
+  IOS: "https://apps.apple.com/us/app/zkpassport/id6477371975",
+  ANDROID: "https://play.google.com/store/apps/details?id=app.zkpassport.zkpassport"
+};
+var RECLAIM_APP_LINKS = {
+  ANDROID: "https://play.google.com/store/apps/details?id=org.reclaimprotocol.app"
+};
+
+// src/zkkyc/orchestrators/reclaim.ts
+var import_neverthrow3 = require("neverthrow");
+
+// src/zkkyc/orchestrators/types.ts
+var SOCIAL_PLATFORM_NAMES = {
+  linkedin: "LinkedIn",
+  github: "GitHub",
+  x: "X",
+  instagram: "Instagram",
+  facebook: "Facebook"
+};
+
+// src/zkkyc/orchestrators/reclaim.ts
+var RECLAIM_SESSION_API = "https://api.reclaimprotocol.org/api/sdk/session";
+function createReclaimFlow(config, options) {
+  return import_neverthrow3.ResultAsync.fromPromise(
+    (async () => {
+      const mod = await import("@reclaimprotocol/js-sdk").catch(() => {
+        throw new ZkkycError(
+          "Missing peer dependency: @reclaimprotocol/js-sdk. Install it with: npm install @reclaimprotocol/js-sdk",
+          { code: "PEER_DEPENDENCY_MISSING" }
+        );
+      });
+      const { ReclaimProofRequest, transformForOnchain } = mod;
+      const {
+        platform,
+        walletAddress,
+        redirectUrl,
+        sessionId: existingSessionId,
+        contextDescription,
+        onStatus,
+        signal,
+        pollingIntervalMs = 5e3
+      } = options;
+      const socialName = SOCIAL_PLATFORM_NAMES[platform];
+      const providerId = config.providerIds[platform];
+      let sessionId;
+      if (existingSessionId) {
+        sessionId = existingSessionId;
+      } else {
+        const reclaimProofRequest = await ReclaimProofRequest.init(
+          config.appId,
+          config.appSecret,
+          providerId,
+          { launchOptions: { canUseDeferredDeepLinksFlow: true } }
+        );
+        const statusUrl = reclaimProofRequest.getStatusUrl();
+        sessionId = statusUrl.split("/").pop() || "";
+        if (redirectUrl) {
+          const separator = redirectUrl.includes("?") ? "&" : "?";
+          reclaimProofRequest.setRedirectUrl(
+            `${redirectUrl}${separator}sessionId=${sessionId}&socialPlatform=${socialName}`
+          );
+        }
+        reclaimProofRequest.addContext(
+          walletAddress,
+          contextDescription ?? `Social verification for ${socialName}`
+        );
+        const requestUrl = await reclaimProofRequest.getRequestUrl();
+        onStatus?.({ type: "session_created", sessionId, requestUrl });
+        if (typeof window !== "undefined") {
+          reclaimProofRequest.triggerReclaimFlow();
+        }
+      }
+      onStatus?.({ type: "polling_started", sessionId });
+      while (true) {
+        if (signal?.aborted) {
+          throw new ZkkycError("Reclaim polling aborted", {
+            code: "RECLAIM_POLLING_ABORTED"
+          });
+        }
+        const response = await fetch(`${RECLAIM_SESSION_API}/${sessionId}`);
+        const data = await response.json();
+        if (data?.session?.proofs?.length > 0) {
+          const proofs = data.session.proofs;
+          onStatus?.({ type: "proof_received" });
+          if (platform === "github" && proofs.length > 0) {
+            const first = proofs[0];
+            if (first?.publicData && Object.keys(first.publicData).length === 0) {
+              throw new ZkkycError("GitHub verification eligibility criteria not met", {
+                code: "RECLAIM_PROOF_INVALID"
+              });
+            }
+          }
+          const transformedProofs = proofs.map((proof) => transformForOnchain(proof));
+          onStatus?.({ type: "proof_transformed" });
+          return {
+            _socialName: socialName,
+            proofs: transformedProofs,
+            sessionId
+          };
+        }
+        if (data?.message?.includes("Session not found")) {
+          throw new ZkkycError("Reclaim session not found", {
+            code: "RECLAIM_SESSION_NOT_FOUND",
+            context: { sessionId }
+          });
+        }
+        if (data?.session?.statusV2 === "PROOF_GENERATION_FAILED") {
+          throw new ZkkycError("Reclaim proof generation failed", {
+            code: "RECLAIM_PROOF_GENERATION_FAILED",
+            context: { sessionId }
+          });
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+      }
+    })(),
+    (error) => {
+      if (error instanceof ZkkycError) return error;
+      return new ZkkycError("Reclaim verification flow failed", {
+        code: "RECLAIM_INIT_FAILED",
+        cause: error
+      });
+    }
+  );
+}
+
+// src/zkkyc/orchestrators/zk-passport.ts
+var import_neverthrow4 = require("neverthrow");
+function createZkPassportFlow(config, options) {
+  return import_neverthrow4.ResultAsync.fromPromise(
+    (async () => {
+      const mod = await import("@zkpassport/sdk").catch(() => {
+        throw new ZkkycError(
+          "Missing peer dependency: @zkpassport/sdk. Install it with: npm install @zkpassport/sdk",
+          { code: "PEER_DEPENDENCY_MISSING" }
+        );
+      });
+      const { ZKPassport } = mod;
+      const zkPassport = new ZKPassport(config.domain ?? "app.p2p.me");
+      const queryBuilder = await zkPassport.request({
+        name: config.name ?? "ZKPassport",
+        logo: config.logo ?? "https://app.p2p.lol/favicon.svg",
+        purpose: config.purpose ?? "Prove your personhood",
+        scope: "personhood",
+        mode: "compressed-evm"
+      });
+      const {
+        url,
+        onRequestReceived,
+        onGeneratingProof,
+        onProofGenerated,
+        onResult,
+        onReject,
+        onError
+      } = queryBuilder.gte("age", 18).disclose("document_type").disclose("nationality").bind("user_address", options.walletAddress).done();
+      options.onStatus?.({ type: "request_created", url });
+      let aborted = false;
+      const resultPromise = new Promise((resolve, reject) => {
+        let proof = null;
+        onRequestReceived(() => {
+          if (aborted) return;
+          options.onStatus?.({ type: "request_received" });
+        });
+        onGeneratingProof(() => {
+          if (aborted) return;
+          options.onStatus?.({ type: "generating_proof" });
+        });
+        onProofGenerated(async (result) => {
+          if (aborted) return;
+          options.onStatus?.({ type: "proof_generated" });
+          proof = result;
+        });
+        onResult(
+          async ({
+            result,
+            uniqueIdentifier,
+            verified
+          }) => {
+            if (aborted) return;
+            options.onStatus?.({ type: "result_received" });
+            if (!verified || !proof || !uniqueIdentifier) {
+              reject(
+                new ZkkycError("ZK Passport verification failed", {
+                  code: "ZK_PASSPORT_VERIFICATION_FAILED"
+                })
+              );
+              return;
+            }
+            try {
+              const verifierParams = zkPassport.getSolidityVerifierParameters({
+                proof,
+                scope: "personhood",
+                devMode: false
+              });
+              const isIDCard = result.document_type?.disclose?.result !== "passport";
+              resolve({ params: verifierParams, isIDCard });
+            } catch (error) {
+              reject(
+                new ZkkycError("Failed to extract ZK Passport verifier parameters", {
+                  code: "ZK_PASSPORT_VERIFICATION_FAILED",
+                  cause: error
+                })
+              );
+            }
+          }
+        );
+        onReject(() => {
+          options.onStatus?.({ type: "rejected" });
+          reject(
+            new ZkkycError("User rejected ZK Passport verification", {
+              code: "ZK_PASSPORT_REJECTED"
+            })
+          );
+        });
+        onError((error) => {
+          reject(
+            new ZkkycError(typeof error === "string" ? error : "ZK Passport verification error", {
+              code: "ZK_PASSPORT_VERIFICATION_FAILED",
+              cause: error
+            })
+          );
+        });
+      });
+      const session = {
+        url,
+        result: import_neverthrow4.ResultAsync.fromPromise(resultPromise, (error) => {
+          if (error instanceof ZkkycError) return error;
+          return new ZkkycError("ZK Passport flow failed", {
+            code: "ZK_PASSPORT_VERIFICATION_FAILED",
+            cause: error
+          });
+        }),
+        abort: () => {
+          aborted = true;
+        }
+      };
+      return session;
+    })(),
+    (error) => {
+      if (error instanceof ZkkycError) return error;
+      return new ZkkycError("Failed to initialize ZK Passport", {
+        code: "ZK_PASSPORT_INIT_FAILED",
+        cause: error
+      });
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_RECLAIM_PROVIDER_IDS,
+  RECLAIM_APP_LINKS,
+  SOCIAL_PLATFORM_NAMES,
+  ZK_PASSPORT_APP_LINKS,
+  ZkkycError,
+  createReclaimFlow,
+  createZkPassportFlow,
+  createZkkyc
+});
+//# sourceMappingURL=zkkyc.cjs.map