@thurinlabs/identity-kit 1.0.3 → 1.1.0

package/dist/index.cjs

@@ -1,1241 +1,45 @@
-"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');
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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/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;
-}
+
+
+
+var _chunkNL4LHKJXcjs = require('./chunk-NL4LHKJX.cjs');
 
 // 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
@@ -1259,13 +63,8 @@ var defaultQueryClient = new (0, _reactquery.QueryClient)({
     }
   }
 });
-function chainFor(network = "mainnet") {
-  if (network === "sepolia") return _chains.sepolia;
-  if (network === "local") return _chains.foundry;
-  return _chains.mainnet;
-}
 function createDefaultWagmiConfig(rpcUrl, network) {
-  const url = rpcUrl || getRegistry(network).defaultRpcUrl;
+  const url = rpcUrl || _chunkNL4LHKJXcjs.getRegistry.call(void 0, network).defaultRpcUrl;
   if (network === "sepolia") return _wagmi.createConfig.call(void 0, { chains: [_chains.sepolia], transports: { [_chains.sepolia.id]: _wagmi.http.call(void 0, url) } });
   if (network === "local") return _wagmi.createConfig.call(void 0, { chains: [_chains.foundry], transports: { [_chains.foundry.id]: _wagmi.http.call(void 0, url) } });
   return _wagmi.createConfig.call(void 0, { chains: [_chains.mainnet], transports: { [_chains.mainnet.id]: _wagmi.http.call(void 0, url) } });
@@ -1306,235 +105,23 @@ var _ens = require('viem/ens');
 
 
 var _viem = require('viem');
-
-// src/core/fingerprint.ts
-
-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 _viem.keccak256.call(void 0, 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 (e2) {
-    return String(_nullishCoalesce(_optionalChain([keyOrSubkey, 'access', _2 => _2.keyPacket, 'optionalAccess', _3 => _3.algorithm]), () => ( "unknown")));
-  }
-}
-async function parsePgpKey(armoredKey) {
-  try {
-    const openpgp = await Promise.resolve().then(() => _interopRequireWildcard(require("openpgp")));
-    const { readKey } = openpgp;
-    const config = pgpConfig(openpgp);
-    const key = await readKey({ armoredKey });
-    const fingerprint = key.getFingerprint().toUpperCase();
-    const algorithm = algorithmName(key);
-    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 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 (e3) {
-          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 = _optionalChain([user, 'access', _8 => _8.userID, 'optionalAccess', _9 => _9.userID]);
-        if (uid) userIDs.push(uid);
-      }
-    }
-    const subkeys = key.subkeys.map((sk) => ({
-      algorithm: algorithmName(sk),
-      created: _nullishCoalesce(_optionalChain([sk, 'access', _10 => _10.keyPacket, 'access', _11 => _11.created, 'optionalAccess', _12 => _12.toISOString, 'call', _13 => _13()]), () => ( null)),
-      fingerprint: sk.getFingerprint().toUpperCase()
-    }));
-    return { fingerprint, userIDs, algorithm, created, expires, notations, subkeys };
-  } catch (e4) {
-    return null;
-  }
-}
-async function verifyAttestation({
-  pgpPublicKey,
-  pgpSignature,
-  fingerprint,
-  ethAddress
-}) {
-  try {
-    if (!pgpPublicKey || !pgpSignature) {
-      return { verified: false, reason: "Missing PGP data" };
-    }
-    const openpgp = await Promise.resolve().then(() => _interopRequireWildcard(require("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(_nullishCoalesce(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 (e5) {
-    return { verified: false, reason: "Signature verification failed" };
-  }
-}
-var EMAIL_UID = /@/;
-async function stripEmailUserIDs(armoredKey) {
-  try {
-    const { readKey } = await Promise.resolve().then(() => _interopRequireWildcard(require("openpgp")));
-    const key = await readKey({ armoredKey });
-    const kept = [];
-    const removed = [];
-    const users = key.users.filter((u) => {
-      const uid = _optionalChain([u, 'access', _14 => _14.userID, 'optionalAccess', _15 => _15.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 (e6) {
-    return null;
-  }
-}
-async function hasEmailUserID(armoredKey) {
-  try {
-    const { readKey } = await Promise.resolve().then(() => _interopRequireWildcard(require("openpgp")));
-    const key = await readKey({ armoredKey });
-    return key.users.some((u) => EMAIL_UID.test(_nullishCoalesce(_optionalChain([u, 'access', _16 => _16.userID, 'optionalAccess', _17 => _17.userID]), () => ( ""))));
-  } catch (e7) {
-    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 (e8) {
-    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 (e9) {
-    return null;
-  }
-}
-
-// src/hooks/useAttestations.ts
 function useAttestations(address) {
   const config = useIdentityKitConfig();
-  const registry = getRegistry(config.network, config.registryAddress);
-  const chain = chainFor(config.network);
+  const registry = _chunkNL4LHKJXcjs.getRegistry.call(void 0, config.network, config.registryAddress);
+  const chain = _chunkNL4LHKJXcjs.chainFor.call(void 0, config.network);
   const owner = address;
   const { data: rows, isLoading: rowsLoading } = _wagmi.useReadContract.call(void 0, {
     address: registry.address,
-    abi: REGISTRY_ABI,
+    abi: _chunkNL4LHKJXcjs.REGISTRY_ABI,
     functionName: "attestationsOf",
     args: owner ? [owner] : void 0,
     chainId: chain.id,
     query: { enabled: !!owner }
   });
-  const count = _nullishCoalesce(_optionalChain([rows, 'optionalAccess', _18 => _18.length]), () => ( 0));
+  const count = _nullishCoalesce(_optionalChain([rows, 'optionalAccess', _2 => _2.length]), () => ( 0));
   const contracts = owner && rows ? rows.map((_, i) => ({
     address: registry.address,
-    abi: REGISTRY_ABI,
+    abi: _chunkNL4LHKJXcjs.REGISTRY_ABI,
     functionName: "getPayload",
     args: [owner, BigInt(i)],
     chainId: chain.id
@@ -1551,7 +138,7 @@ function useAttestations(address) {
       const results = [];
       for (let i = 0; i < rows.length; i++) {
         const row = rows[i];
-        const payload = _optionalChain([payloads, 'optionalAccess', _19 => _19[i]]);
+        const payload = _optionalChain([payloads, 'optionalAccess', _3 => _3[i]]);
         let pgpSignature = null;
         let pgpPublicKey = null;
         if (payload && payload.status === "success") {
@@ -1559,8 +146,8 @@ function useAttestations(address) {
           pgpSignature = _viem.hexToString.call(void 0, sigHex);
           pgpPublicKey = _viem.hexToString.call(void 0, keyHex);
         }
-        const fingerprint = bytesToFingerprint(row.fingerprint);
-        const verification = pgpPublicKey && pgpSignature ? await verifyAttestation({ pgpPublicKey, pgpSignature, fingerprint, ethAddress: address }) : null;
+        const fingerprint = _chunkNL4LHKJXcjs.bytesToFingerprint.call(void 0, row.fingerprint);
+        const verification = pgpPublicKey && pgpSignature ? await _chunkNL4LHKJXcjs.verifyAttestation.call(void 0, { pgpPublicKey, pgpSignature, fingerprint, ethAddress: address }) : null;
         const revokedAt = Number(row.revokedAt);
         results.push({
           index: i,
@@ -1581,7 +168,7 @@ function useAttestations(address) {
   });
   const isLoading = rowsLoading || payloadsLoading || verifyLoading || !!owner && rows !== void 0 && !payloadsReady;
   const activeClaims = (claims || []).filter((c) => !c.revoked);
-  const verifiedClaims = activeClaims.filter((c) => _optionalChain([c, 'access', _20 => _20.verification, 'optionalAccess', _21 => _21.verified]));
+  const verifiedClaims = activeClaims.filter((c) => _optionalChain([c, 'access', _4 => _4.verification, 'optionalAccess', _5 => _5.verified]));
   const currentFingerprint = verifiedClaims.length > 0 ? verifiedClaims[verifiedClaims.length - 1].fingerprint : null;
   return {
     claims: claims || [],
@@ -1594,40 +181,10 @@ function useAttestations(address) {
 
 // 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 (e10) {
-    return null;
-  }
-}
-
-// src/hooks/useEFPGraph.ts
 function useEFPGraph(address) {
   const { data, isLoading } = _reactquery.useQuery.call(void 0, {
     queryKey: ["efp-graph", address],
-    queryFn: () => fetchEFPGraph(address),
+    queryFn: () => _chunkNL4LHKJXcjs.fetchEFPGraph.call(void 0, address),
     enabled: !!address,
     staleTime: 3e5
   });
@@ -1639,267 +196,27 @@ function useEFPGraph(address) {
 
 // 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] })
-  },
-  {
-    // 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 (_optionalChain([data, 'access', _22 => _22.owner, 'optionalAccess', _23 => _23.login, 'optionalAccess', _24 => _24.toLowerCase, 'call', _25 => _25()]) !== 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 (_optionalChain([data, 'access', _26 => _26.owner, 'optionalAccess', _27 => _27.login, 'optionalAccess', _28 => _28.toLowerCase, 'call', _29 => _29()]) !== 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 _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', _30 => _30.data, 'optionalAccess', _31 => _31.castAddBody, 'optionalAccess', _32 => _32.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 } = _reactquery.useQuery.call(void 0, {
     // The key is large; key the query on its length + fingerprint, which
     // changes whenever a different attestation's key is supplied.
-    queryKey: ["pgp-proofs", fingerprint, _nullishCoalesce(_optionalChain([armoredKey, 'optionalAccess', _33 => _33.length]), () => ( 0))],
+    queryKey: ["pgp-proofs", fingerprint, _nullishCoalesce(_optionalChain([armoredKey, 'optionalAccess', _6 => _6.length]), () => ( 0))],
     queryFn: async () => {
       if (!fingerprint || !armoredKey) return { keyInfo: null, proofs: [] };
-      const keyInfo = await parsePgpKey(armoredKey);
+      const keyInfo = await _chunkNL4LHKJXcjs.parsePgpKey.call(void 0, armoredKey);
       if (!keyInfo) return { keyInfo: null, proofs: [] };
-      const identified = keyInfo.notations.map((n) => identifyProof(n)).filter((p) => p !== null && p.provider !== "unknown");
+      const identified = keyInfo.notations.map((n) => _chunkNL4LHKJXcjs.identifyProof.call(void 0, n)).filter((p) => p !== null && p.provider !== "unknown");
       const proofs = await Promise.all(
         identified.map(async (proof) => {
-          const result = await verifyProof(proof, fingerprint, config.neynarApiKey);
+          const result = await _chunkNL4LHKJXcjs.verifyProof.call(void 0, proof, fingerprint, config.neynarApiKey);
           return {
             provider: proof.provider,
             label: proof.label,
             url: proof.url,
-            displayUrl: displayUrl(proof),
-            href: proofHref(proof),
-            secondaryHref: proofSecondaryHref(proof),
+            displayUrl: _chunkNL4LHKJXcjs.displayUrl.call(void 0, proof),
+            href: _chunkNL4LHKJXcjs.proofHref.call(void 0, proof),
+            secondaryHref: _chunkNL4LHKJXcjs.proofSecondaryHref.call(void 0, proof),
             status: result.verified ? "verified" : "unverified",
             reason: result.reason
           };
@@ -1919,8 +236,8 @@ function usePGPProofs(fingerprint, armoredKey) {
     staleTime: 3e5
   });
   return {
-    keyInfo: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _34 => _34.keyInfo]), () => ( null)),
-    proofs: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _35 => _35.proofs]), () => ( [])),
+    keyInfo: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _7 => _7.keyInfo]), () => ( null)),
+    proofs: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _8 => _8.proofs]), () => ( [])),
     // Report loading whenever a fingerprint is set but its proofs haven't
     // resolved yet. Using react-query's own isLoading leaves a gap while the
     // query is enabling (fingerprint just became known), during which the card
@@ -1936,12 +253,12 @@ function isAddress(value) {
 function safeNormalize(name) {
   try {
     return _ens.normalize.call(void 0, name);
-  } catch (e11) {
+  } catch (e2) {
     return void 0;
   }
 }
 function useThurinIdentity(ensOrAddress) {
-  const chain = chainFor(useIdentityKitConfig().network);
+  const chain = _chunkNL4LHKJXcjs.chainFor.call(void 0, useIdentityKitConfig().network);
   const isAddr = ensOrAddress ? isAddress(ensOrAddress) : false;
   const ensInput = ensOrAddress && !isAddr ? safeNormalize(ensOrAddress) : void 0;
   const { data: resolvedAddress } = _wagmi.useEnsAddress.call(void 0, {
@@ -1969,13 +286,13 @@ function useThurinIdentity(ensOrAddress) {
     isLoading: claimsLoading
   } = useAttestations(address);
   const currentClaim = [...claims].reverse().find(
-    (c) => !c.revoked && _optionalChain([c, 'access', _36 => _36.verification, 'optionalAccess', _37 => _37.verified]) && c.fingerprint === currentFingerprint
+    (c) => !c.revoked && _optionalChain([c, 'access', _9 => _9.verification, 'optionalAccess', _10 => _10.verified]) && c.fingerprint === currentFingerprint
   );
   const {
     keyInfo: pgpKeyInfo,
     proofs,
     isLoading: proofsLoading
-  } = usePGPProofs(currentFingerprint, _nullishCoalesce(_optionalChain([currentClaim, 'optionalAccess', _38 => _38.pgpPublicKey]), () => ( null)));
+  } = usePGPProofs(currentFingerprint, _nullishCoalesce(_optionalChain([currentClaim, 'optionalAccess', _11 => _11.pgpPublicKey]), () => ( null)));
   const { efp, isLoading: efpLoading } = useEFPGraph(address);
   return {
     address,
@@ -2014,7 +331,7 @@ function ThurinCard({ ens, address, theme = "thurin" }) {
   }
   const displayAddress = identity.address || null;
   const verifiedProofs = identity.proofs.filter((p) => p.status === "verified").length;
-  const hasVerifiedPgp = identity.claims.some((c) => _optionalChain([c, 'access', _39 => _39.verification, 'optionalAccess', _40 => _40.verified]) && !c.revoked);
+  const hasVerifiedPgp = identity.claims.some((c) => _optionalChain([c, 'access', _12 => _12.verification, 'optionalAccess', _13 => _13.verified]) && !c.revoked);
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "thurin-card", "data-thurin-theme": theme, children: [
     /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "a", { className: "thurin-card-header", href: profileUrl || void 0, target: "_blank", rel: "noopener noreferrer", children: [
       identity.ensAvatar ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
@@ -2040,13 +357,13 @@ function ThurinCard({ ens, address, theme = "thurin" }) {
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "thurin-card-stat-label", children: "Proofs" })
       ] }),
       /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "thurin-card-stat", children: [
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "thurin-card-stat-value", children: _nullishCoalesce(_optionalChain([identity, 'access', _41 => _41.efp, 'optionalAccess', _42 => _42.followers]), () => ( 0)) }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "thurin-card-stat-value", children: _nullishCoalesce(_optionalChain([identity, 'access', _14 => _14.efp, 'optionalAccess', _15 => _15.followers]), () => ( 0)) }),
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "thurin-card-stat-label", children: "Followers" })
       ] })
     ] }),
     /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "thurin-card-badges", children: [
       hasVerifiedPgp && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "thurin-card-badge thurin-card-badge--verified", children: "PGP Verified" }),
-      _optionalChain([identity, 'access', _43 => _43.efp, 'optionalAccess', _44 => _44.hasEfp]) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "thurin-card-badge thurin-card-badge--verified", children: "EFP" }),
+      _optionalChain([identity, 'access', _16 => _16.efp, 'optionalAccess', _17 => _17.hasEfp]) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "thurin-card-badge thurin-card-badge--verified", children: "EFP" }),
       identity.proofs.map((p, i) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
         "span",
         {
@@ -2069,108 +386,6 @@ function ThurinCard({ ens, address, theme = "thurin" }) {
   ] });
 }
 
-// src/core/authorization.ts
-
-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: _viem.stringToHex.call(void 0, a.pgpSignature),
-      pgpPublicKey: _viem.stringToHex.call(void 0, 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: _viem.stringToHex.call(void 0, 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 _viem.hashTypedData.call(void 0, typedData);
-}
-function recordKind(name) {
-  return _viem.keccak256.call(void 0, _viem.stringToHex.call(void 0, name));
-}
-
 
 
 
@@ -2212,5 +427,5 @@ function recordKind(name) {
 
 
 
-exports.AUTHORIZATION_TYPES = AUTHORIZATION_TYPES; exports.EIP712_NAME = EIP712_NAME; exports.EIP712_VERSION = EIP712_VERSION; exports.IdentityKitProvider = IdentityKitProvider; exports.NETWORKS = NETWORKS; exports.REGISTRY_ABI = REGISTRY_ABI; exports.REGISTRY_ADDRESS = REGISTRY_ADDRESS; exports.ThurinCard = ThurinCard; exports.attestTypedData = attestTypedData; exports.authorizationDigest = authorizationDigest; exports.bytesToFingerprint = bytesToFingerprint; exports.chainFor = chainFor; exports.displayUrl = displayUrl; exports.fetchEFPGraph = fetchEFPGraph; exports.fetchKeyByFingerprint = fetchKeyByFingerprint; exports.fetchKeyByKeyId = fetchKeyByKeyId; exports.fingerprintHash = fingerprintHash; exports.fingerprintToBytes = fingerprintToBytes; exports.getRegistry = getRegistry; exports.hasEmailUserID = hasEmailUserID; exports.identifyProof = identifyProof; exports.isNetworkName = isNetworkName; exports.keyIdOf = keyIdOf; exports.keyIdToBytes = keyIdToBytes; exports.normalizeFingerprint = normalizeFingerprint; exports.parsePgpKey = parsePgpKey; exports.proofHref = proofHref; exports.proofSecondaryHref = proofSecondaryHref; exports.reattestTypedData = reattestTypedData; exports.recordKind = recordKind; exports.registryDomain = registryDomain; exports.revokeTypedData = revokeTypedData; exports.setRecordTypedData = setRecordTypedData; exports.stripEmailUserIDs = stripEmailUserIDs; exports.updateKeyTypedData = updateKeyTypedData; exports.useAttestations = useAttestations; exports.useEFPGraph = useEFPGraph; exports.usePGPProofs = usePGPProofs; exports.useThurinIdentity = useThurinIdentity; exports.verifyAttestation = verifyAttestation; exports.verifyProof = verifyProof;
+exports.AUTHORIZATION_TYPES = _chunkNL4LHKJXcjs.AUTHORIZATION_TYPES; exports.EIP712_NAME = _chunkNL4LHKJXcjs.EIP712_NAME; exports.EIP712_VERSION = _chunkNL4LHKJXcjs.EIP712_VERSION; exports.IdentityKitProvider = IdentityKitProvider; exports.NETWORKS = _chunkNL4LHKJXcjs.NETWORKS; exports.REGISTRY_ABI = _chunkNL4LHKJXcjs.REGISTRY_ABI; exports.REGISTRY_ADDRESS = _chunkNL4LHKJXcjs.REGISTRY_ADDRESS; exports.ThurinCard = ThurinCard; exports.attestTypedData = _chunkNL4LHKJXcjs.attestTypedData; exports.authorizationDigest = _chunkNL4LHKJXcjs.authorizationDigest; exports.bytesToFingerprint = _chunkNL4LHKJXcjs.bytesToFingerprint; exports.chainFor = _chunkNL4LHKJXcjs.chainFor; exports.displayUrl = _chunkNL4LHKJXcjs.displayUrl; exports.fetchEFPGraph = _chunkNL4LHKJXcjs.fetchEFPGraph; exports.fetchKeyByFingerprint = _chunkNL4LHKJXcjs.fetchKeyByFingerprint; exports.fetchKeyByKeyId = _chunkNL4LHKJXcjs.fetchKeyByKeyId; exports.fingerprintHash = _chunkNL4LHKJXcjs.fingerprintHash; exports.fingerprintToBytes = _chunkNL4LHKJXcjs.fingerprintToBytes; exports.getRegistry = _chunkNL4LHKJXcjs.getRegistry; exports.hasEmailUserID = _chunkNL4LHKJXcjs.hasEmailUserID; exports.identifyProof = _chunkNL4LHKJXcjs.identifyProof; exports.isNetworkName = _chunkNL4LHKJXcjs.isNetworkName; exports.keyIdOf = _chunkNL4LHKJXcjs.keyIdOf; exports.keyIdToBytes = _chunkNL4LHKJXcjs.keyIdToBytes; exports.normalizeFingerprint = _chunkNL4LHKJXcjs.normalizeFingerprint; exports.parsePgpKey = _chunkNL4LHKJXcjs.parsePgpKey; exports.proofHref = _chunkNL4LHKJXcjs.proofHref; exports.proofSecondaryHref = _chunkNL4LHKJXcjs.proofSecondaryHref; exports.reattestTypedData = _chunkNL4LHKJXcjs.reattestTypedData; exports.recordKind = _chunkNL4LHKJXcjs.recordKind; exports.registryDomain = _chunkNL4LHKJXcjs.registryDomain; exports.revokeTypedData = _chunkNL4LHKJXcjs.revokeTypedData; exports.setRecordTypedData = _chunkNL4LHKJXcjs.setRecordTypedData; exports.stripEmailUserIDs = _chunkNL4LHKJXcjs.stripEmailUserIDs; exports.updateKeyTypedData = _chunkNL4LHKJXcjs.updateKeyTypedData; exports.useAttestations = useAttestations; exports.useEFPGraph = useEFPGraph; exports.usePGPProofs = usePGPProofs; exports.useThurinIdentity = useThurinIdentity; exports.verifyAttestation = _chunkNL4LHKJXcjs.verifyAttestation; exports.verifyProof = _chunkNL4LHKJXcjs.verifyProof;
 //# sourceMappingURL=index.cjs.map