@thurinlabs/identity-kit 1.0.4 → 1.1.1

package/dist/index.js

@@ -1,1241 +1,45 @@
+import {
+  AUTHORIZATION_TYPES,
+  EIP712_NAME,
+  EIP712_VERSION,
+  NETWORKS,
+  REGISTRY_ABI,
+  REGISTRY_ADDRESS,
+  attestTypedData,
+  authorizationDigest,
+  bytesToFingerprint,
+  chainFor,
+  displayUrl,
+  fetchEFPGraph,
+  fetchKeyByFingerprint,
+  fetchKeyByKeyId,
+  fingerprintHash,
+  fingerprintToBytes,
+  getRegistry,
+  hasEmailUserID,
+  identifyProof,
+  isNetworkName,
+  keyIdOf,
+  keyIdToBytes,
+  normalizeFingerprint,
+  parsePgpKey,
+  proofHref,
+  proofSecondaryHref,
+  reattestTypedData,
+  recordKind,
+  registryDomain,
+  revokeTypedData,
+  setRecordTypedData,
+  stripEmailUserIDs,
+  updateKeyTypedData,
+  verifyAttestation,
+  verifyProof
+} from "./chunk-GKL42VHZ.js";
+
 // src/provider.tsx
 import { useMemo } from "react";
 import { WagmiProvider, createConfig, http, useConfig } from "wagmi";
 import { mainnet, sepolia, foundry } from "wagmi/chains";
-
-// src/core/abi.ts
-var REGISTRY_ABI = [
-  {
-    "type": "function",
-    "name": "ATTEST_TYPEHASH",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "DOMAIN_SEPARATOR",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "EIP712_NAME",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "EIP712_VERSION",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "string",
-        "internalType": "string"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "MAX_KEY_BYTES",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "MAX_RECORD_BYTES",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "MAX_SIG_BYTES",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "MESSAGE_VERSION",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint8",
-        "internalType": "uint8"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "REATTEST_TYPEHASH",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "REVOKE_TYPEHASH",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "SET_RECORD_TYPEHASH",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "UPDATE_KEY_TYPEHASH",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "VERSION",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint8",
-        "internalType": "uint8"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "addressesFor",
-    "inputs": [
-      {
-        "name": "fingerprintHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "addressesForCount",
-    "inputs": [
-      {
-        "name": "fingerprintHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "addressesForRange",
-    "inputs": [
-      {
-        "name": "fingerprintHash",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "start",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "count",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "out",
-        "type": "address[]",
-        "internalType": "address[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "attest",
-    "inputs": [
-      {
-        "name": "fingerprint",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "pgpSignature",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "pgpPublicKey",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "attestFor",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "fingerprint",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "pgpSignature",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "pgpPublicKey",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "signature",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "attestationCount",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "attestationsOf",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "tuple[]",
-        "internalType": "struct PGPRegistry.Attestation[]",
-        "components": [
-          {
-            "name": "fingerprint",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "createdAt",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "revokedAt",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "messageVersion",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "keyPtr",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sigPtr",
-            "type": "address",
-            "internalType": "address"
-          }
-        ]
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "attestationsOfRange",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "start",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "count",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "out",
-        "type": "tuple[]",
-        "internalType": "struct PGPRegistry.Attestation[]",
-        "components": [
-          {
-            "name": "fingerprint",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "createdAt",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "revokedAt",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "messageVersion",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "keyPtr",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sigPtr",
-            "type": "address",
-            "internalType": "address"
-          }
-        ]
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "cancelAuthorization",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "current",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "found",
-        "type": "bool",
-        "internalType": "bool"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "attestation",
-        "type": "tuple",
-        "internalType": "struct PGPRegistry.Attestation",
-        "components": [
-          {
-            "name": "fingerprint",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "createdAt",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "revokedAt",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "messageVersion",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "keyPtr",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sigPtr",
-            "type": "address",
-            "internalType": "address"
-          }
-        ]
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "fingerprintsForKeyId",
-    "inputs": [
-      {
-        "name": "keyId",
-        "type": "bytes8",
-        "internalType": "bytes8"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "fingerprintsForKeyIdCount",
-    "inputs": [
-      {
-        "name": "keyId",
-        "type": "bytes8",
-        "internalType": "bytes8"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "fingerprintsForKeyIdRange",
-    "inputs": [
-      {
-        "name": "keyId",
-        "type": "bytes8",
-        "internalType": "bytes8"
-      },
-      {
-        "name": "start",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "count",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "out",
-        "type": "bytes[]",
-        "internalType": "bytes[]"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getAttestation",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "tuple",
-        "internalType": "struct PGPRegistry.Attestation",
-        "components": [
-          {
-            "name": "fingerprint",
-            "type": "bytes",
-            "internalType": "bytes"
-          },
-          {
-            "name": "createdAt",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "revokedAt",
-            "type": "uint64",
-            "internalType": "uint64"
-          },
-          {
-            "name": "messageVersion",
-            "type": "uint8",
-            "internalType": "uint8"
-          },
-          {
-            "name": "keyPtr",
-            "type": "address",
-            "internalType": "address"
-          },
-          {
-            "name": "sigPtr",
-            "type": "address",
-            "internalType": "address"
-          }
-        ]
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "getPayload",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "pgpSignature",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "pgpPublicKey",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "nonces",
-    "inputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "reattest",
-    "inputs": [
-      {
-        "name": "revokeIndex",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "fingerprint",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "pgpSignature",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "pgpPublicKey",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "reattestFor",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "revokeIndex",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "fingerprint",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "pgpSignature",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "pgpPublicKey",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "signature",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "record",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "kind",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "revoke",
-    "inputs": [
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "revokeFor",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "signature",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setRecord",
-    "inputs": [
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "kind",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "value",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setRecordFor",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "kind",
-        "type": "bytes32",
-        "internalType": "bytes32"
-      },
-      {
-        "name": "value",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "signature",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "updateKey",
-    "inputs": [
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "pgpPublicKey",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "updateKeyFor",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "pgpPublicKey",
-        "type": "bytes",
-        "internalType": "bytes"
-      },
-      {
-        "name": "deadline",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "signature",
-        "type": "bytes",
-        "internalType": "bytes"
-      }
-    ],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "event",
-    "name": "Attested",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "fingerprintHash",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "indexed": true,
-        "internalType": "uint256"
-      },
-      {
-        "name": "fingerprint",
-        "type": "bytes",
-        "indexed": false,
-        "internalType": "bytes"
-      },
-      {
-        "name": "messageVersion",
-        "type": "uint8",
-        "indexed": false,
-        "internalType": "uint8"
-      },
-      {
-        "name": "keyPtr",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "sigPtr",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "submitter",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "KeyUpdated",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "fingerprintHash",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "indexed": true,
-        "internalType": "uint256"
-      },
-      {
-        "name": "oldKeyPtr",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "newKeyPtr",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      },
-      {
-        "name": "submitter",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "NonceUsed",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "nonce",
-        "type": "uint256",
-        "indexed": false,
-        "internalType": "uint256"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "RecordSet",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "indexed": true,
-        "internalType": "uint256"
-      },
-      {
-        "name": "kind",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "submitter",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "event",
-    "name": "Revoked",
-    "inputs": [
-      {
-        "name": "owner",
-        "type": "address",
-        "indexed": true,
-        "internalType": "address"
-      },
-      {
-        "name": "fingerprintHash",
-        "type": "bytes32",
-        "indexed": true,
-        "internalType": "bytes32"
-      },
-      {
-        "name": "index",
-        "type": "uint256",
-        "indexed": true,
-        "internalType": "uint256"
-      },
-      {
-        "name": "submitter",
-        "type": "address",
-        "indexed": false,
-        "internalType": "address"
-      }
-    ],
-    "anonymous": false
-  },
-  {
-    "type": "error",
-    "name": "AlreadyRevoked",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "AuthorizationExpired",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "DeploymentFailed",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "DuplicateActiveFingerprint",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "EmptyPublicKey",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "EmptySignature",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "IndexOutOfBounds",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidAuthorization",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidFingerprintLength",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidPointer",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "PublicKeyTooLarge",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "RecordTooLarge",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "SignatureTooLarge",
-    "inputs": []
-  }
-];
-
-// src/core/contract.ts
-var REGISTRY_ADDRESS = "0x9302E02e2869e129aC8516fE5eFFd51EA3082c09";
-var NETWORKS = {
-  mainnet: {
-    chainId: 1,
-    address: REGISTRY_ADDRESS,
-    deployBlock: 25962908n,
-    // 2026-09-12, tx 0xda4c3a19cae4e71ffb02559a048403f664d5a7967c19d42158c39600ec63bad8
-    explorerUrl: "https://etherscan.io",
-    defaultRpcUrl: "https://ethereum-rpc.publicnode.com"
-  },
-  sepolia: {
-    chainId: 11155111,
-    address: REGISTRY_ADDRESS,
-    deployBlock: 11683667n,
-    // 2026-09-11, tx 0x3e40e8f5b9fbf82a4b8943561bcc9b964b2987de10640ac8ff3a1b4ef0725322
-    explorerUrl: "https://sepolia.etherscan.io",
-    defaultRpcUrl: "https://ethereum-sepolia-rpc.publicnode.com"
-  },
-  /** A local anvil instance (`anvil`, chain id 31337). Deploy with pgp-registry's Deploy script. */
-  local: {
-    chainId: 31337,
-    address: REGISTRY_ADDRESS,
-    deployBlock: 0n,
-    explorerUrl: "",
-    defaultRpcUrl: "http://127.0.0.1:8545"
-  }
-};
-function isNetworkName(value) {
-  return value === "mainnet" || value === "sepolia" || value === "local";
-}
-function getRegistry(network = "mainnet", addressOverride) {
-  const r = NETWORKS[network];
-  if (!r) throw new Error(`Unknown network: ${network}`);
-  if (addressOverride && /^0x[0-9a-fA-F]{40}$/.test(addressOverride)) {
-    return { ...r, address: addressOverride };
-  }
-  return r;
-}
-
-// src/provider.tsx
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 
 // src/context.ts
@@ -1259,11 +63,6 @@ var defaultQueryClient = new QueryClient({
     }
   }
 });
-function chainFor(network = "mainnet") {
-  if (network === "sepolia") return sepolia;
-  if (network === "local") return foundry;
-  return mainnet;
-}
 function createDefaultWagmiConfig(rpcUrl, network) {
   const url = rpcUrl || getRegistry(network).defaultRpcUrl;
   if (network === "sepolia") return createConfig({ chains: [sepolia], transports: { [sepolia.id]: http(url) } });
@@ -1306,218 +105,6 @@ import { normalize } from "viem/ens";
 import { useReadContract, useReadContracts } from "wagmi";
 import { useQuery } from "@tanstack/react-query";
 import { hexToString } from "viem";
-
-// src/core/fingerprint.ts
-import { keccak256 } from "viem";
-var FINGERPRINT_HEX = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
-function normalizeFingerprint(input) {
-  const hex = input.replace(/^0x/i, "").replace(/\s+/g, "").toLowerCase();
-  return FINGERPRINT_HEX.test(hex) ? hex : null;
-}
-function fingerprintToBytes(fingerprint) {
-  const hex = normalizeFingerprint(fingerprint);
-  if (!hex) throw new Error(`Invalid PGP fingerprint: ${fingerprint}`);
-  return `0x${hex}`;
-}
-function bytesToFingerprint(bytes) {
-  return bytes.replace(/^0x/i, "").toLowerCase();
-}
-function fingerprintHash(fingerprint) {
-  return keccak256(fingerprintToBytes(fingerprint));
-}
-function keyIdOf(fingerprint) {
-  const hex = normalizeFingerprint(fingerprint);
-  if (!hex) throw new Error(`Invalid PGP fingerprint: ${fingerprint}`);
-  return `0x${keyIdHex(hex)}`;
-}
-function keyIdHex(normalizedFingerprint) {
-  return normalizedFingerprint.length === 64 ? normalizedFingerprint.slice(0, 16) : normalizedFingerprint.slice(-16);
-}
-function keyIdToBytes(keyId) {
-  const hex = keyId.replace(/^0x/i, "").replace(/\s+/g, "").toLowerCase();
-  return /^[0-9a-f]{16}$/.test(hex) ? `0x${hex}` : null;
-}
-
-// src/core/pgp.ts
-function pgpConfig(openpgp) {
-  return { ...openpgp.config, rejectCurves: /* @__PURE__ */ new Set() };
-}
-function algorithmName(keyOrSubkey) {
-  try {
-    const info = keyOrSubkey.getAlgorithmInfo();
-    const curve = (info.curve || "").toLowerCase();
-    if (curve.startsWith("ed25519") || info.algorithm === "ed25519" || info.algorithm === "eddsaLegacy") return "Ed25519";
-    if (curve.startsWith("curve25519") || info.algorithm === "x25519") return "Cv25519";
-    if (curve.startsWith("ed448")) return "Ed448";
-    if (curve.startsWith("curve448") || info.algorithm === "x448") return "X448";
-    if (curve.startsWith("nistp") || curve.startsWith("p")) return `NIST P-${curve.replace(/\D/g, "")}`;
-    if (curve.startsWith("secp")) return curve;
-    if (curve.startsWith("brainpool")) return curve;
-    if (info.algorithm.startsWith("rsa")) return info.bits ? `RSA ${info.bits}` : "RSA";
-    if (info.algorithm.startsWith("dsa")) return info.bits ? `DSA ${info.bits}` : "DSA";
-    if (info.algorithm.startsWith("elgamal")) return info.bits ? `ElGamal ${info.bits}` : "ElGamal";
-    return info.curve || info.algorithm;
-  } catch {
-    return String(keyOrSubkey.keyPacket?.algorithm ?? "unknown");
-  }
-}
-async function parsePgpKey(armoredKey) {
-  try {
-    const openpgp = await import("openpgp");
-    const { readKey } = openpgp;
-    const config = pgpConfig(openpgp);
-    const key = await readKey({ armoredKey });
-    const fingerprint = key.getFingerprint().toUpperCase();
-    const algorithm = algorithmName(key);
-    const created = key.keyPacket.created?.toISOString() ?? null;
-    const expiration = await key.getExpirationTime();
-    const expires = expiration && expiration !== Infinity ? new Date(expiration).toISOString() : null;
-    const userIDs = [];
-    const notations = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const user of key.users) {
-      const certs = user.selfCertifications;
-      if (!certs || certs.length === 0) continue;
-      let userVerified = false;
-      for (const cert of certs) {
-        try {
-          await cert.verify(
-            key.keyPacket,
-            cert.signatureType,
-            { userID: user.userID, key: key.keyPacket },
-            void 0,
-            // date: now
-            void 0,
-            // detached
-            config
-          );
-        } catch {
-          continue;
-        }
-        userVerified = true;
-        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) {
-              if (!seen.has(value)) {
-                seen.add(value);
-                notations.push({ name, value });
-              }
-            }
-          }
-        }
-      }
-      if (userVerified) {
-        const uid = user.userID?.userID;
-        if (uid) userIDs.push(uid);
-      }
-    }
-    const subkeys = key.subkeys.map((sk) => ({
-      algorithm: algorithmName(sk),
-      created: sk.keyPacket.created?.toISOString() ?? null,
-      fingerprint: sk.getFingerprint().toUpperCase()
-    }));
-    return { fingerprint, userIDs, algorithm, created, expires, notations, subkeys };
-  } catch {
-    return null;
-  }
-}
-async function verifyAttestation({
-  pgpPublicKey,
-  pgpSignature,
-  fingerprint,
-  ethAddress
-}) {
-  try {
-    if (!pgpPublicKey || !pgpSignature) {
-      return { verified: false, reason: "Missing PGP data" };
-    }
-    const openpgp = await import("openpgp");
-    const { readKey, readCleartextMessage, LiteralDataPacket } = openpgp;
-    const config = pgpConfig(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 msg = message;
-    const now = /* @__PURE__ */ new Date();
-    let signed = false;
-    for (const sig of msg.signature.packets) {
-      if (!publicKey.getKeys(sig.issuerKeyID).length) continue;
-      const signingKey = await publicKey.getSigningKey(sig.issuerKeyID, now, void 0, config);
-      const literal = new LiteralDataPacket();
-      literal.setText(msg.text ?? message.getText().replace(/\r?\n/g, "\r\n"));
-      await sig.verify(signingKey.keyPacket, sig.signatureType, literal, now, true, config);
-      signed = true;
-      break;
-    }
-    if (!signed) return { verified: false, reason: "Message is not signed by this key" };
-    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 {
-    return { verified: false, reason: "Signature verification failed" };
-  }
-}
-var EMAIL_UID = /@/;
-async function stripEmailUserIDs(armoredKey) {
-  try {
-    const { readKey } = await import("openpgp");
-    const key = await readKey({ armoredKey });
-    const kept = [];
-    const removed = [];
-    const users = key.users.filter((u) => {
-      const uid = u.userID?.userID;
-      if (!uid) return false;
-      if (EMAIL_UID.test(uid)) {
-        removed.push(uid);
-        return false;
-      }
-      kept.push(uid);
-      return true;
-    });
-    if (users.length === 0) return null;
-    key.users = users;
-    return { armored: key.armor(), kept, removed };
-  } catch {
-    return null;
-  }
-}
-async function hasEmailUserID(armoredKey) {
-  try {
-    const { readKey } = await import("openpgp");
-    const key = await readKey({ armoredKey });
-    return key.users.some((u) => EMAIL_UID.test(u.userID?.userID ?? ""));
-  } catch {
-    return false;
-  }
-}
-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 {
-    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 {
-    return null;
-  }
-}
-
-// src/hooks/useAttestations.ts
 function useAttestations(address) {
   const config = useIdentityKitConfig();
   const registry = getRegistry(config.network, config.registryAddress);
@@ -1594,39 +181,6 @@ function useAttestations(address) {
 
 // src/hooks/useEFPGraph.ts
 import { useQuery as useQuery2 } from "@tanstack/react-query";
-
-// src/core/efp.ts
-var EFP_API = "https://api.ethfollow.xyz/api/v1";
-async function fetchEFPGraph(address) {
-  try {
-    const [statsResp, listsResp] = await Promise.all([
-      fetch(`${EFP_API}/users/${address}/stats`),
-      fetch(`${EFP_API}/users/${address}/lists`)
-    ]);
-    if (!statsResp.ok && !listsResp.ok) return null;
-    const statsData = statsResp.ok ? await statsResp.json() : {};
-    const listsData = listsResp.ok ? await listsResp.json() : {};
-    const followers = parseInt(statsData.followers_count) || 0;
-    const listId = listsData.primary_list;
-    let following = 0;
-    let top8 = [];
-    if (listId) {
-      const [followingResp, top8Resp] = await Promise.all([
-        fetch(`${EFP_API}/lists/${listId}/following?limit=100`),
-        fetch(`${EFP_API}/lists/${listId}/following?limit=8&tags=top8`)
-      ]);
-      const followingData = followingResp.ok ? await followingResp.json() : { following: [] };
-      const top8Data = top8Resp.ok ? await top8Resp.json() : { following: [] };
-      following = (followingData.following || []).length;
-      top8 = (top8Data.following || []).map((f) => f.data);
-    }
-    return { followers, following, top8, hasEfp: !!listId || followers > 0 };
-  } catch {
-    return null;
-  }
-}
-
-// src/hooks/useEFPGraph.ts
 function useEFPGraph(address) {
   const { data, isLoading } = useQuery2({
     queryKey: ["efp-graph", address],
@@ -1642,246 +196,6 @@ function useEFPGraph(address) {
 
 // src/hooks/usePGPProofs.ts
 import { useQuery as useQuery3 } from "@tanstack/react-query";
-
-// 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] })
-  },
-  {
-    // A repository's description — the form an organisation can use, since
-    // gists belong to user accounts only. Same shape as the Codeberg proof.
-    provider: "github",
-    label: "GitHub",
-    pattern: /^https:\/\/github\.com\/([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+)$/i,
-    parse: (m) => ({ user: m[1], repo: m[2] })
-  },
-  {
-    provider: "dns",
-    label: "DNS",
-    // domain is restricted to a hostname (labels may include underscores for
-    // records like _thurin.example.com); rejects slashes, userinfo, and spaces.
-    pattern: /^dns:([a-z0-9._-]+)\?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",
-    // instance is restricted to a bare hostname (optional port) so a value
-    // like "mastodon.social@evil.com" can't redirect the lookup elsewhere.
-    pattern: /^https:\/\/([a-z0-9.-]+(?::\d+)?)\/@([^/@?#\s]+)$/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) {
-  if (proof.repo) return verifyGitHubRepo(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();
-    if (data.owner?.login?.toLowerCase() !== proof.user.toLowerCase()) {
-      return { verified: false, reason: "Gist owner does not match claimed user" };
-    }
-    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 verifyGitHubRepo(proof, fingerprint) {
-  try {
-    const resp = await fetch(
-      `https://api.github.com/repos/${encodeURIComponent(proof.user)}/${encodeURIComponent(proof.repo)}`
-    );
-    if (!resp.ok) return { verified: false, reason: `GitHub API returned ${resp.status}` };
-    const data = await resp.json();
-    if (data.owner?.login?.toLowerCase() !== proof.user.toLowerCase()) {
-      return { verified: false, reason: "Repository owner does not match claimed account" };
-    }
-    if (data.description && containsFingerprint(data.description, fingerprint)) {
-      return { verified: true };
-    }
-    return { verified: false, reason: "Fingerprint token not found in repository description" };
-  } 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.type !== 16) continue;
-      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 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 = msg.data?.castAddBody?.text || "";
-          if (containsFingerprint(text, fingerprint)) {
-            return { verified: true };
-          }
-        }
-      }
-      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 {
-    if (!proof.instance || !/^[a-z0-9.-]+(?::\d+)?$/i.test(proof.instance)) {
-      return { verified: false, reason: "Invalid Mastodon instance host" };
-    }
-    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 = keyIdHex(fingerprint.replace(/^0x/i, "").replace(/\s+/g, "").toLowerCase());
-    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, armoredKey) {
   const config = useIdentityKitConfig();
   const { data } = useQuery3({
@@ -2071,108 +385,6 @@ function ThurinCard({ ens, address, theme = "thurin" }) {
     )
   ] });
 }
-
-// src/core/authorization.ts
-import { hashTypedData, keccak256 as keccak2562, stringToHex } from "viem";
-var EIP712_NAME = "Thurin PGPRegistry";
-var EIP712_VERSION = "2";
-function registryDomain(chainId, verifyingContract) {
-  return { name: EIP712_NAME, version: EIP712_VERSION, chainId, verifyingContract };
-}
-var AUTHORIZATION_TYPES = {
-  Attest: [
-    { name: "owner", type: "address" },
-    { name: "fingerprint", type: "bytes" },
-    { name: "pgpSignature", type: "bytes" },
-    { name: "pgpPublicKey", type: "bytes" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" }
-  ],
-  Reattest: [
-    { name: "owner", type: "address" },
-    { name: "revokeIndex", type: "uint256" },
-    { name: "fingerprint", type: "bytes" },
-    { name: "pgpSignature", type: "bytes" },
-    { name: "pgpPublicKey", type: "bytes" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" }
-  ],
-  UpdateKey: [
-    { name: "owner", type: "address" },
-    { name: "index", type: "uint256" },
-    { name: "pgpPublicKey", type: "bytes" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" }
-  ],
-  Revoke: [
-    { name: "owner", type: "address" },
-    { name: "index", type: "uint256" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" }
-  ],
-  SetRecord: [
-    { name: "owner", type: "address" },
-    { name: "index", type: "uint256" },
-    { name: "kind", type: "bytes32" },
-    { name: "value", type: "bytes" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" }
-  ]
-};
-function attestTypedData(chainId, registry, a) {
-  return {
-    domain: registryDomain(chainId, registry),
-    types: { Attest: AUTHORIZATION_TYPES.Attest },
-    primaryType: "Attest",
-    message: {
-      owner: a.owner,
-      fingerprint: fingerprintToBytes(a.fingerprint),
-      pgpSignature: stringToHex(a.pgpSignature),
-      pgpPublicKey: stringToHex(a.pgpPublicKey),
-      nonce: a.nonce,
-      deadline: a.deadline
-    }
-  };
-}
-function reattestTypedData(chainId, registry, a) {
-  const base = attestTypedData(chainId, registry, a);
-  return {
-    domain: base.domain,
-    types: { Reattest: AUTHORIZATION_TYPES.Reattest },
-    primaryType: "Reattest",
-    message: { ...base.message, revokeIndex: a.revokeIndex }
-  };
-}
-function updateKeyTypedData(chainId, registry, a) {
-  return {
-    domain: registryDomain(chainId, registry),
-    types: { UpdateKey: AUTHORIZATION_TYPES.UpdateKey },
-    primaryType: "UpdateKey",
-    message: { owner: a.owner, index: a.index, pgpPublicKey: stringToHex(a.pgpPublicKey), nonce: a.nonce, deadline: a.deadline }
-  };
-}
-function revokeTypedData(chainId, registry, a) {
-  return {
-    domain: registryDomain(chainId, registry),
-    types: { Revoke: AUTHORIZATION_TYPES.Revoke },
-    primaryType: "Revoke",
-    message: { owner: a.owner, index: a.index, nonce: a.nonce, deadline: a.deadline }
-  };
-}
-function setRecordTypedData(chainId, registry, a) {
-  return {
-    domain: registryDomain(chainId, registry),
-    types: { SetRecord: AUTHORIZATION_TYPES.SetRecord },
-    primaryType: "SetRecord",
-    message: { owner: a.owner, index: a.index, kind: a.kind, value: a.value, nonce: a.nonce, deadline: a.deadline }
-  };
-}
-function authorizationDigest(typedData) {
-  return hashTypedData(typedData);
-}
-function recordKind(name) {
-  return keccak2562(stringToHex(name));
-}
 export {
   AUTHORIZATION_TYPES,
   EIP712_NAME,