@thurinlabs/identity-kit 0.1.0

package/dist/index.cjs

@@ -0,0 +1,759 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/provider.tsx
+var _react = require('react');
+var _wagmi = require('wagmi');
+var _chains = require('wagmi/chains');
+var _reactquery = require('@tanstack/react-query');
+
+// src/context.ts
+
+var defaultConfig = {
+  scryBaseUrl: "https://scry.thurin.id"
+};
+var IdentityKitContext = _react.createContext.call(void 0, defaultConfig);
+function useIdentityKitConfig() {
+  return _react.useContext.call(void 0, IdentityKitContext);
+}
+
+// src/provider.tsx
+var _jsxruntime = require('react/jsx-runtime');
+var defaultQueryClient = new (0, _reactquery.QueryClient)({
+  defaultOptions: {
+    queries: {
+      staleTime: 6e4,
+      retry: 1
+    }
+  }
+});
+function createDefaultWagmiConfig(rpcUrl) {
+  return _wagmi.createConfig.call(void 0, {
+    chains: [_chains.mainnet],
+    transports: {
+      [_chains.mainnet.id]: _wagmi.http.call(void 0, rpcUrl || "https://ethereum-rpc.publicnode.com")
+    }
+  });
+}
+function WagmiDetector({ children, rpcUrl }) {
+  let hasWagmi = false;
+  try {
+    _wagmi.useConfig.call(void 0, );
+    hasWagmi = true;
+  } catch (e) {
+  }
+  const wagmiConfig = _react.useMemo.call(void 0, () => createDefaultWagmiConfig(rpcUrl), [rpcUrl]);
+  if (hasWagmi) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children });
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _wagmi.WagmiProvider, { config: wagmiConfig, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _reactquery.QueryClientProvider, { client: defaultQueryClient, children }) });
+}
+function IdentityKitProvider({
+  children,
+  rpcUrl,
+  neynarApiKey,
+  scryBaseUrl = "https://scry.thurin.id"
+}) {
+  const config = _react.useMemo.call(void 0, 
+    () => ({ rpcUrl, neynarApiKey, scryBaseUrl }),
+    [rpcUrl, neynarApiKey, scryBaseUrl]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, IdentityKitContext.Provider, { value: config, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, WagmiDetector, { rpcUrl, children }) });
+}
+
+// src/hooks/useScryIdentity.ts
+
+
+var _ens = require('viem/ens');
+
+// src/hooks/useSignetClaims.ts
+
+
+
+var _viem = require('viem');
+
+// src/core/contract.ts
+var REGISTRY_ADDRESS = "0xf7a45BC662A78a6fb417ED5f52b3766cbf13EbBb";
+var CONTRACT_DEPLOY_BLOCK = 24515891n;
+var REGISTRY_ABI = [
+  {
+    name: "Attested",
+    type: "event",
+    inputs: [
+      { name: "ethAddress", type: "address", indexed: true },
+      { name: "fingerprintHash", type: "string", indexed: true },
+      { name: "fingerprint", type: "string", indexed: false },
+      { name: "pgpSignature", type: "string", indexed: false },
+      { name: "pgpPublicKey", type: "string", indexed: false },
+      { name: "index", type: "uint256", indexed: false },
+      { name: "timestamp", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "attestationCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "addr", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getAttestation",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "addr", type: "address" },
+      { name: "index", type: "uint256" }
+    ],
+    outputs: [
+      { name: "fingerprint", type: "string" },
+      { name: "createdAt", type: "uint256" },
+      { name: "revoked", type: "bool" }
+    ]
+  }
+];
+
+// src/core/logs.ts
+var LOG_CHUNK_SIZE = 49999n;
+async function getLogsChunked(client, params) {
+  const latest = await client.getBlockNumber();
+  const fromBlock = _nullishCoalesce(params.fromBlock, () => ( CONTRACT_DEPLOY_BLOCK));
+  const toBlock = params.toBlock === "latest" || !params.toBlock ? latest : params.toBlock;
+  const allLogs = [];
+  for (let start = fromBlock; start <= toBlock; start += LOG_CHUNK_SIZE) {
+    const end = start + LOG_CHUNK_SIZE - 1n > toBlock ? toBlock : start + LOG_CHUNK_SIZE - 1n;
+    const logs = await client.getLogs({
+      ...params,
+      fromBlock: start,
+      toBlock: end
+    });
+    allLogs.push(...logs);
+  }
+  return allLogs;
+}
+
+// src/core/pgp.ts
+async function parsePgpKey(armoredKey) {
+  try {
+    const { readKey } = await Promise.resolve().then(() => _interopRequireWildcard(require("openpgp")));
+    const key = await readKey({ armoredKey });
+    const fingerprint = key.getFingerprint().toUpperCase();
+    const userIDs = key.users.map((u) => _optionalChain([u, 'access', _2 => _2.userID, 'optionalAccess', _3 => _3.userID])).filter(Boolean);
+    const algorithm = String(key.keyPacket.algorithm);
+    const created = _nullishCoalesce(_optionalChain([key, 'access', _4 => _4.keyPacket, 'access', _5 => _5.created, 'optionalAccess', _6 => _6.toISOString, 'call', _7 => _7()]), () => ( null));
+    const expiration = await key.getExpirationTime();
+    const expires = expiration && expiration !== Infinity ? new Date(expiration).toISOString() : null;
+    const notations = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const user of key.users) {
+      if (!user.selfCertifications) continue;
+      for (const cert of user.selfCertifications) {
+        if (cert.rawNotations) {
+          for (const n of cert.rawNotations) {
+            const name = typeof n.name === "string" ? n.name : new TextDecoder().decode(n.name);
+            const value = n.value instanceof Uint8Array ? new TextDecoder().decode(n.value) : typeof n.value === "string" ? n.value : null;
+            if (value) {
+              const key2 = `${name}:${value}`;
+              if (!seen.has(key2)) {
+                seen.add(key2);
+                notations.push({ name, value });
+              }
+            }
+          }
+        }
+      }
+    }
+    const subkeys = key.subkeys.map((sk) => ({
+      algorithm: String(sk.keyPacket.algorithm),
+      created: _nullishCoalesce(_optionalChain([sk, 'access', _8 => _8.keyPacket, 'access', _9 => _9.created, 'optionalAccess', _10 => _10.toISOString, 'call', _11 => _11()]), () => ( null)),
+      fingerprint: sk.getFingerprint().toUpperCase()
+    }));
+    return { fingerprint, userIDs, algorithm, created, expires, notations, subkeys };
+  } catch (e2) {
+    return null;
+  }
+}
+async function verifyAttestation({
+  pgpPublicKey,
+  pgpSignature,
+  fingerprint,
+  ethAddress
+}) {
+  try {
+    if (!pgpPublicKey || !pgpSignature) {
+      return { verified: false, reason: "Missing PGP data" };
+    }
+    const { readKey, readCleartextMessage, verify } = await Promise.resolve().then(() => _interopRequireWildcard(require("openpgp")));
+    const publicKey = await readKey({ armoredKey: pgpPublicKey });
+    const keyFingerprint = publicKey.getFingerprint().toUpperCase();
+    if (keyFingerprint !== fingerprint.toUpperCase()) {
+      return { verified: false, reason: "Key fingerprint mismatch" };
+    }
+    const message = await readCleartextMessage({ cleartextMessage: pgpSignature });
+    const { signatures } = await verify({ message, verificationKeys: publicKey });
+    await signatures[0].verified;
+    const signedText = message.getText();
+    if (!signedText.toLowerCase().includes(ethAddress.toLowerCase())) {
+      return { verified: false, reason: "Signed message does not contain ETH address" };
+    }
+    return { verified: true };
+  } catch (e3) {
+    return { verified: false, reason: "Signature verification failed" };
+  }
+}
+var KEYSERVER_BASE = "https://keys.openpgp.org/vks/v1";
+async function fetchKeyByFingerprint(fingerprint) {
+  try {
+    const resp = await fetch(`${KEYSERVER_BASE}/by-fingerprint/${fingerprint}`);
+    if (!resp.ok) return null;
+    return await resp.text();
+  } catch (e4) {
+    return null;
+  }
+}
+async function fetchKeyByKeyId(keyId) {
+  try {
+    const resp = await fetch(`${KEYSERVER_BASE}/by-keyid/${keyId}`);
+    if (!resp.ok) return null;
+    return await resp.text();
+  } catch (e5) {
+    return null;
+  }
+}
+
+// src/hooks/useSignetClaims.ts
+function useSignetClaims(address) {
+  const config = useIdentityKitConfig();
+  const { data: count, isLoading: countLoading } = _wagmi.useReadContract.call(void 0, {
+    address: REGISTRY_ADDRESS,
+    abi: REGISTRY_ABI,
+    functionName: "attestationCount",
+    args: address ? [address] : void 0,
+    chainId: _chains.mainnet.id,
+    query: { enabled: !!address }
+  });
+  const attestationCount = count ? Number(count) : 0;
+  const contracts = address ? Array.from({ length: attestationCount }, (_, i) => ({
+    address: REGISTRY_ADDRESS,
+    abi: REGISTRY_ABI,
+    functionName: "getAttestation",
+    args: [address, BigInt(i)],
+    chainId: _chains.mainnet.id
+  })) : [];
+  const { data: attestations, isLoading: attestationsLoading } = _wagmi.useReadContracts.call(void 0, {
+    contracts,
+    query: { enabled: contracts.length > 0 }
+  });
+  const { data: eventData } = _reactquery.useQuery.call(void 0, {
+    queryKey: ["signet-logs", address],
+    queryFn: async () => {
+      if (!address) return [];
+      const client = _viem.createPublicClient.call(void 0, {
+        chain: _chains.mainnet,
+        transport: _viem.http.call(void 0, config.rpcUrl || "https://ethereum-rpc.publicnode.com")
+      });
+      const event = _viem.parseAbiItem.call(void 0, 
+        "event Attested(address indexed ethAddress, string indexed fingerprintHash, string fingerprint, string pgpSignature, string pgpPublicKey, uint256 index, uint256 timestamp)"
+      );
+      return getLogsChunked(client, {
+        address: REGISTRY_ADDRESS,
+        event,
+        args: { ethAddress: address },
+        fromBlock: CONTRACT_DEPLOY_BLOCK,
+        toBlock: "latest"
+      });
+    },
+    enabled: !!address && attestationCount > 0,
+    staleTime: 3e5
+  });
+  const { data: claims, isLoading: verifyLoading } = _reactquery.useQuery.call(void 0, {
+    queryKey: ["signet-claims", address, attestationCount, !!eventData],
+    queryFn: async () => {
+      if (!attestations || !address) return [];
+      const results = [];
+      for (let i = 0; i < attestations.length; i++) {
+        const att = attestations[i];
+        if (att.status !== "success") continue;
+        const [fingerprint, createdAt, revoked] = att.result;
+        const log = (eventData || [])[i];
+        const pgpSignature = _nullishCoalesce(_optionalChain([log, 'optionalAccess', _12 => _12.args, 'optionalAccess', _13 => _13.pgpSignature]), () => ( null));
+        const pgpPublicKey = _nullishCoalesce(_optionalChain([log, 'optionalAccess', _14 => _14.args, 'optionalAccess', _15 => _15.pgpPublicKey]), () => ( null));
+        const txHash = _nullishCoalesce(_optionalChain([log, 'optionalAccess', _16 => _16.transactionHash]), () => ( null));
+        let verification = null;
+        if (pgpPublicKey && pgpSignature) {
+          verification = await verifyAttestation({
+            pgpPublicKey,
+            pgpSignature,
+            fingerprint,
+            ethAddress: address
+          });
+        }
+        results.push({
+          index: i,
+          fingerprint,
+          createdAt: Number(createdAt),
+          revoked,
+          pgpSignature,
+          pgpPublicKey,
+          txHash,
+          verification
+        });
+      }
+      return results;
+    },
+    enabled: !!attestations && attestations.length > 0,
+    staleTime: 3e5
+  });
+  const isLoading = countLoading || attestationsLoading || verifyLoading;
+  const activeClaims = (claims || []).filter((c) => !c.revoked);
+  const currentFingerprint = activeClaims.length > 0 ? activeClaims[activeClaims.length - 1].fingerprint : null;
+  return {
+    claims: claims || [],
+    totalClaims: attestationCount,
+    activeClaims: activeClaims.length,
+    currentFingerprint,
+    isLoading
+  };
+}
+
+// src/hooks/useEFPGraph.ts
+
+
+// src/core/efp.ts
+var EFP_API = "https://api.ethfollow.xyz/api/v1";
+async function fetchEFPGraph(address) {
+  try {
+    const listsResp = await fetch(`${EFP_API}/users/${address}/lists`);
+    if (!listsResp.ok) return null;
+    const listsData = await listsResp.json();
+    const listId = listsData.primary_list;
+    if (!listId) return null;
+    const [followingResp, statsResp, top8Resp] = await Promise.all([
+      fetch(`${EFP_API}/lists/${listId}/following?limit=100`),
+      fetch(`${EFP_API}/users/${address}/stats`),
+      fetch(`${EFP_API}/lists/${listId}/following?limit=8&tags=top8`)
+    ]);
+    const followingData = followingResp.ok ? await followingResp.json() : { following: [] };
+    const statsData = statsResp.ok ? await statsResp.json() : {};
+    const top8Data = top8Resp.ok ? await top8Resp.json() : { following: [] };
+    return {
+      followers: parseInt(statsData.followers_count) || 0,
+      following: (followingData.following || []).length,
+      top8: (top8Data.following || []).map((f) => f.data),
+      hasEfp: true
+    };
+  } catch (e6) {
+    return null;
+  }
+}
+
+// src/hooks/useEFPGraph.ts
+function useEFPGraph(address) {
+  const { data, isLoading } = _reactquery.useQuery.call(void 0, {
+    queryKey: ["efp-graph", address],
+    queryFn: () => fetchEFPGraph(address),
+    enabled: !!address,
+    staleTime: 3e5
+  });
+  return {
+    efp: _nullishCoalesce(data, () => ( null)),
+    isLoading
+  };
+}
+
+// src/hooks/usePGPProofs.ts
+
+
+// src/core/proofs.ts
+var PROVIDERS = [
+  {
+    provider: "github",
+    label: "GitHub",
+    pattern: /^https:\/\/gist\.github\.com\/([^/]+)\/([a-f0-9]+)$/i,
+    parse: (m) => ({ user: m[1], gistId: m[2] })
+  },
+  {
+    provider: "dns",
+    label: "DNS",
+    pattern: /^dns:([^?]+)\?type=TXT$/i,
+    parse: (m) => ({ domain: m[1] })
+  },
+  {
+    provider: "farcaster",
+    label: "Farcaster",
+    pattern: /^https:\/\/farcaster\.xyz\/([^/]+)\/(0x[a-f0-9]+)$/i,
+    parse: (m) => ({ user: m[1], castHash: m[2] })
+  },
+  {
+    provider: "codeberg",
+    label: "Codeberg",
+    pattern: /^https:\/\/codeberg\.org\/([^/]+)\/([^/]+)$/i,
+    parse: (m) => ({ user: m[1], repo: m[2] })
+  },
+  {
+    provider: "mastodon",
+    label: "Mastodon",
+    pattern: /^https:\/\/([^/]+)\/@([^/]+)$/i,
+    parse: (m) => ({ instance: m[1], user: m[2] })
+  }
+];
+function identifyProof(notation) {
+  if (notation.name !== "proof@thurin.id") return null;
+  for (const { provider, label, pattern, parse } of PROVIDERS) {
+    const m = notation.value.match(pattern);
+    if (m) {
+      return { provider, label, url: notation.value, ...parse(m) };
+    }
+  }
+  return { provider: "unknown", label: "Unknown", url: notation.value };
+}
+function displayUrl(proof) {
+  if (proof.provider === "dns") return proof.domain;
+  if (proof.provider === "github") return proof.user;
+  if (proof.provider === "farcaster") return `@${proof.user}`;
+  if (proof.provider === "codeberg") return proof.user;
+  if (proof.provider === "mastodon") return `@${proof.user}@${proof.instance}`;
+  return proof.url;
+}
+function proofHref(proof) {
+  if (proof.provider === "dns") return `https://${proof.domain}`;
+  if (proof.provider === "github") return `https://github.com/${proof.user}`;
+  if (proof.provider === "farcaster") return `https://farcaster.xyz/${proof.user}`;
+  if (proof.provider === "codeberg") return `https://codeberg.org/${proof.user}`;
+  if (proof.provider === "mastodon") return `https://${proof.instance}/@${proof.user}`;
+  if (proof.url.startsWith("http")) return proof.url;
+  return null;
+}
+function proofSecondaryHref(proof) {
+  if (proof.provider === "github") return proof.url;
+  if (proof.provider === "farcaster") return proof.url;
+  if (proof.provider === "codeberg") return proof.url;
+  if (proof.provider === "mastodon") return proof.url;
+  return null;
+}
+var FPR_TOKEN = "OPENPGP4FPR:";
+function containsFingerprint(text, fingerprint) {
+  return text.toUpperCase().includes(FPR_TOKEN + fingerprint.toUpperCase());
+}
+function containsFingerprintUrl(text, fingerprint) {
+  return text.toUpperCase().includes(fingerprint.toUpperCase());
+}
+async function verifyGitHub(proof, fingerprint) {
+  try {
+    const resp = await fetch(`https://api.github.com/gists/${proof.gistId}`);
+    if (!resp.ok) return { verified: false, reason: `GitHub API returned ${resp.status}` };
+    const data = await resp.json();
+    for (const file of Object.values(data.files || {})) {
+      if (file.content && containsFingerprint(file.content, fingerprint)) {
+        return { verified: true };
+      }
+    }
+    return { verified: false, reason: "Fingerprint token not found in gist" };
+  } catch (err) {
+    return { verified: false, reason: `GitHub fetch failed: ${err.message}` };
+  }
+}
+async function verifyDNS(proof, fingerprint) {
+  try {
+    const resp = await fetch(
+      `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(proof.domain)}&type=TXT`,
+      { headers: { Accept: "application/dns-json" } }
+    );
+    if (!resp.ok) return { verified: false, reason: `DNS query returned ${resp.status}` };
+    const data = await resp.json();
+    for (const answer of data.Answer || []) {
+      if (answer.data && containsFingerprint(answer.data, fingerprint)) {
+        return { verified: true };
+      }
+    }
+    return { verified: false, reason: "Fingerprint token not found in TXT records" };
+  } catch (err) {
+    return { verified: false, reason: `DNS fetch failed: ${err.message}` };
+  }
+}
+var NEYNAR_HUB = "https://hub-api.neynar.com";
+async function resolveFid(username, apiKey) {
+  const resp = await fetch(
+    `${NEYNAR_HUB}/v1/userNameProofByName?name=${encodeURIComponent(username)}`,
+    { headers: { "x-api-key": apiKey } }
+  );
+  if (!resp.ok) return null;
+  const data = await resp.json();
+  return _nullishCoalesce(data.fid, () => ( null));
+}
+async function verifyFarcaster(proof, fingerprint, neynarApiKey) {
+  if (!neynarApiKey) {
+    return { verified: false, reason: "Farcaster verification requires a Neynar API key" };
+  }
+  try {
+    const fid = await resolveFid(proof.user, neynarApiKey);
+    if (!fid) return { verified: false, reason: `Could not resolve Farcaster user "${proof.user}"` };
+    const headers = { "x-api-key": neynarApiKey };
+    let pageToken = "";
+    for (let page = 0; page < 5; page++) {
+      const url = `${NEYNAR_HUB}/v1/castsByFid?fid=${fid}&pageSize=100&reverse=true${pageToken ? `&pageToken=${pageToken}` : ""}`;
+      const resp = await fetch(url, { headers });
+      if (!resp.ok) return { verified: false, reason: `Farcaster Hub returned ${resp.status}` };
+      const data = await resp.json();
+      for (const msg of data.messages || []) {
+        if (msg.hash && msg.hash.startsWith(proof.castHash)) {
+          const text = _optionalChain([msg, 'access', _17 => _17.data, 'optionalAccess', _18 => _18.castAddBody, 'optionalAccess', _19 => _19.text]) || "";
+          if (containsFingerprint(text, fingerprint)) {
+            return { verified: true };
+          }
+          return { verified: false, reason: "Cast found but fingerprint token not in text" };
+        }
+      }
+      if (!data.nextPageToken) break;
+      pageToken = data.nextPageToken;
+    }
+    return { verified: false, reason: "Cast not found" };
+  } catch (err) {
+    return { verified: false, reason: `Farcaster fetch failed: ${err.message}` };
+  }
+}
+async function verifyCodeberg(proof, fingerprint) {
+  try {
+    const resp = await fetch(
+      `https://codeberg.org/api/v1/repos/${encodeURIComponent(proof.user)}/${encodeURIComponent(proof.repo)}`
+    );
+    if (!resp.ok) return { verified: false, reason: `Codeberg API returned ${resp.status}` };
+    const data = await resp.json();
+    if (data.description && containsFingerprint(data.description, fingerprint)) {
+      return { verified: true };
+    }
+    return { verified: false, reason: "Fingerprint token not found in repo description" };
+  } catch (err) {
+    return { verified: false, reason: `Codeberg fetch failed: ${err.message}` };
+  }
+}
+async function verifyMastodon(proof, fingerprint) {
+  try {
+    const resp = await fetch(
+      `https://${proof.instance}/api/v1/accounts/lookup?acct=${encodeURIComponent(proof.user)}`
+    );
+    if (!resp.ok) return { verified: false, reason: `Mastodon API returned ${resp.status}` };
+    const data = await resp.json();
+    const keyId = fingerprint.slice(-16);
+    for (const field of data.fields || []) {
+      const text = field.value.replace(/<[^>]*>/g, "");
+      if (containsFingerprintUrl(text, fingerprint) || containsFingerprintUrl(text, keyId)) {
+        return { verified: true };
+      }
+    }
+    if (data.note) {
+      const text = data.note.replace(/<[^>]*>/g, "");
+      if (containsFingerprintUrl(text, fingerprint) || containsFingerprintUrl(text, keyId)) {
+        return { verified: true };
+      }
+    }
+    return { verified: false, reason: "Fingerprint not found in profile fields or bio" };
+  } catch (err) {
+    return { verified: false, reason: `Mastodon fetch failed: ${err.message}` };
+  }
+}
+var verifiers = {
+  github: verifyGitHub,
+  dns: verifyDNS,
+  farcaster: verifyFarcaster,
+  codeberg: verifyCodeberg,
+  mastodon: verifyMastodon
+};
+async function verifyProof(proof, fingerprint, neynarApiKey) {
+  const fn = verifiers[proof.provider];
+  if (!fn) return { verified: false, reason: "Unknown provider" };
+  return fn(proof, fingerprint, neynarApiKey);
+}
+
+// src/hooks/usePGPProofs.ts
+function usePGPProofs(fingerprint) {
+  const config = useIdentityKitConfig();
+  const { data, isLoading } = _reactquery.useQuery.call(void 0, {
+    queryKey: ["pgp-proofs", fingerprint],
+    queryFn: async () => {
+      if (!fingerprint) return { keyInfo: null, proofs: [] };
+      const armoredKey = await fetchKeyByFingerprint(fingerprint);
+      if (!armoredKey) return { keyInfo: null, proofs: [] };
+      const keyInfo = await parsePgpKey(armoredKey);
+      if (!keyInfo) return { keyInfo: null, proofs: [] };
+      const identified = keyInfo.notations.map((n) => identifyProof(n)).filter((p) => p !== null);
+      const proofs = await Promise.all(
+        identified.map(async (proof) => {
+          const result = await verifyProof(proof, fingerprint, config.neynarApiKey);
+          return {
+            provider: proof.provider,
+            label: proof.label,
+            url: proof.url,
+            displayUrl: displayUrl(proof),
+            href: proofHref(proof),
+            secondaryHref: proofSecondaryHref(proof),
+            status: result.verified ? "verified" : "unverified",
+            reason: result.reason
+          };
+        })
+      );
+      return { keyInfo, proofs };
+    },
+    enabled: !!fingerprint,
+    staleTime: 3e5
+  });
+  return {
+    keyInfo: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _20 => _20.keyInfo]), () => ( null)),
+    proofs: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _21 => _21.proofs]), () => ( [])),
+    isLoading
+  };
+}
+
+// src/hooks/useScryIdentity.ts
+function isAddress(value) {
+  return /^0x[0-9a-fA-F]{40}$/.test(value);
+}
+function safeNormalize(name) {
+  try {
+    return _ens.normalize.call(void 0, name);
+  } catch (e7) {
+    return void 0;
+  }
+}
+function useScryIdentity(ensOrAddress) {
+  const isAddr = ensOrAddress ? isAddress(ensOrAddress) : false;
+  const ensInput = ensOrAddress && !isAddr ? safeNormalize(ensOrAddress) : void 0;
+  const { data: resolvedAddress } = _wagmi.useEnsAddress.call(void 0, {
+    name: ensInput,
+    chainId: _chains.mainnet.id,
+    query: { enabled: !!ensInput }
+  });
+  const address = isAddr ? ensOrAddress : _nullishCoalesce(resolvedAddress, () => ( null));
+  const { data: ensName } = _wagmi.useEnsName.call(void 0, {
+    address,
+    chainId: _chains.mainnet.id,
+    query: { enabled: !!address }
+  });
+  const displayName = ensInput || ensName || null;
+  const { data: ensAvatar } = _wagmi.useEnsAvatar.call(void 0, {
+    name: displayName ? safeNormalize(displayName) : void 0,
+    chainId: _chains.mainnet.id,
+    query: { enabled: !!displayName }
+  });
+  const {
+    claims,
+    totalClaims,
+    activeClaims,
+    currentFingerprint,
+    isLoading: claimsLoading
+  } = useSignetClaims(address);
+  const {
+    keyInfo: pgpKeyInfo,
+    proofs,
+    isLoading: proofsLoading
+  } = usePGPProofs(currentFingerprint);
+  const { efp, isLoading: efpLoading } = useEFPGraph(address);
+  return {
+    address,
+    ensName: displayName,
+    ensAvatar: _nullishCoalesce(ensAvatar, () => ( null)),
+    claims,
+    totalClaims,
+    activeClaims,
+    currentFingerprint,
+    pgpKeyInfo,
+    proofs,
+    efp,
+    isLoading: claimsLoading || proofsLoading || efpLoading,
+    error: null
+  };
+}
+
+// src/components/ScryCard/ScryCard.tsx
+
+function ThurinLogo() {
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "svg", { className: "scry-card-avatar-placeholder", viewBox: "0 0 100 100", xmlns: "http://www.w3.org/2000/svg", children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "circle", { cx: "50", cy: "50", r: "50", fill: "var(--scry-surface-deep)" }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { d: "M25 80 Q25 25 50 25 Q75 25 75 50", fill: "none", stroke: "#7c9a3e", strokeWidth: "4", strokeLinecap: "round" }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { d: "M33 75 Q33 35 50 35 Q67 35 67 52", fill: "none", stroke: "#7c9a3e", strokeWidth: "4", strokeLinecap: "round" }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { d: "M41 70 Q41 45 50 45 Q59 45 59 55", fill: "none", stroke: "#c9a227", strokeWidth: "4", strokeLinecap: "round" }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { d: "M50 65 L50 53", fill: "none", stroke: "#c9a227", strokeWidth: "4", strokeLinecap: "round" })
+  ] });
+}
+function ScryCard({ ens, address, theme = "thurin" }) {
+  const input = ens || address;
+  const identity = useScryIdentity(input);
+  const config = useIdentityKitConfig();
+  const scryUrl = identity.address ? `${config.scryBaseUrl}/#/eth/${identity.address}` : ens ? `${config.scryBaseUrl}/#/ens/${ens}` : null;
+  if (identity.isLoading) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "scry-card", "data-scry-theme": theme, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "scry-card-loading", children: "Loading identity..." }) });
+  }
+  const displayAddress = identity.address || null;
+  const verifiedProofs = identity.proofs.filter((p) => p.status === "verified").length;
+  const hasVerifiedPgp = identity.claims.some((c) => _optionalChain([c, 'access', _22 => _22.verification, 'optionalAccess', _23 => _23.verified]) && !c.revoked);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card", "data-scry-theme": theme, children: [
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "a", { className: "scry-card-header", href: scryUrl || void 0, target: "_blank", rel: "noopener noreferrer", children: [
+      identity.ensAvatar ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        "img",
+        {
+          className: "scry-card-avatar",
+          src: identity.ensAvatar,
+          alt: identity.ensName || ""
+        }
+      ) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThurinLogo, {}),
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { children: [
+        identity.ensName && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "scry-card-name", children: identity.ensName }),
+        displayAddress && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "scry-card-address", children: displayAddress })
+      ] })
+    ] }),
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card-stats", children: [
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card-stat", children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-value", children: identity.activeClaims }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-label", children: "Seals" })
+      ] }),
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card-stat", children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-value", children: verifiedProofs }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-label", children: "Proofs" })
+      ] }),
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card-stat", children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-value", children: _nullishCoalesce(_optionalChain([identity, 'access', _24 => _24.efp, 'optionalAccess', _25 => _25.followers]), () => ( 0)) }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-label", children: "Followers" })
+      ] })
+    ] }),
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card-badges", children: [
+      hasVerifiedPgp && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-badge scry-card-badge--verified", children: "PGP Verified" }),
+      _optionalChain([identity, 'access', _26 => _26.efp, 'optionalAccess', _27 => _27.hasEfp]) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-badge scry-card-badge--verified", children: "EFP" }),
+      identity.proofs.map((p, i) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        "span",
+        {
+          className: `scry-card-badge scry-card-badge--${p.status === "verified" ? "verified" : "unverified"}`,
+          children: p.label
+        },
+        i
+      ))
+    ] }),
+    scryUrl && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "a",
+      {
+        className: "scry-card-link",
+        href: scryUrl,
+        target: "_blank",
+        rel: "noopener noreferrer",
+        children: "View on Scry"
+      }
+    )
+  ] });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CONTRACT_DEPLOY_BLOCK = CONTRACT_DEPLOY_BLOCK; exports.IdentityKitProvider = IdentityKitProvider; exports.REGISTRY_ABI = REGISTRY_ABI; exports.REGISTRY_ADDRESS = REGISTRY_ADDRESS; exports.ScryCard = ScryCard; exports.displayUrl = displayUrl; exports.fetchEFPGraph = fetchEFPGraph; exports.fetchKeyByFingerprint = fetchKeyByFingerprint; exports.fetchKeyByKeyId = fetchKeyByKeyId; exports.identifyProof = identifyProof; exports.parsePgpKey = parsePgpKey; exports.proofHref = proofHref; exports.proofSecondaryHref = proofSecondaryHref; exports.useEFPGraph = useEFPGraph; exports.usePGPProofs = usePGPProofs; exports.useScryIdentity = useScryIdentity; exports.useSignetClaims = useSignetClaims; exports.verifyAttestation = verifyAttestation; exports.verifyProof = verifyProof;
+//# sourceMappingURL=index.cjs.map