@thurinlabs/identity-kit 1.0.3 → 1.1.0

package/dist/chunk-NL4LHKJX.cjs

@@ -0,0 +1,1857 @@
+"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/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 _chains = require('viem/chains');
+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;
+}
+function chainFor(network = "mainnet") {
+  if (network === "sepolia") return _chains.sepolia;
+  if (network === "local") return _chains.foundry;
+  return _chains.mainnet;
+}
+
+// src/core/fingerprint.ts
+var _viem = require('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 _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 (e) {
+    return String(_nullishCoalesce(_optionalChain([keyOrSubkey, 'access', _ => _.keyPacket, 'optionalAccess', _2 => _2.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', _3 => _3.keyPacket, 'access', _4 => _4.created, 'optionalAccess', _5 => _5.toISOString, 'call', _6 => _6()]), () => ( 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 (e2) {
+          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', _7 => _7.userID, 'optionalAccess', _8 => _8.userID]);
+        if (uid) userIDs.push(uid);
+      }
+    }
+    const subkeys = key.subkeys.map((sk) => ({
+      algorithm: algorithmName(sk),
+      created: _nullishCoalesce(_optionalChain([sk, 'access', _9 => _9.keyPacket, 'access', _10 => _10.created, 'optionalAccess', _11 => _11.toISOString, 'call', _12 => _12()]), () => ( null)),
+      fingerprint: sk.getFingerprint().toUpperCase()
+    }));
+    return { fingerprint, userIDs, algorithm, created, expires, notations, subkeys };
+  } catch (e3) {
+    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 (e4) {
+    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', _13 => _13.userID, 'optionalAccess', _14 => _14.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 (e5) {
+    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', _15 => _15.userID, 'optionalAccess', _16 => _16.userID]), () => ( ""))));
+  } catch (e6) {
+    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 (e7) {
+    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 (e8) {
+    return null;
+  }
+}
+
+// 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 (e9) {
+    return null;
+  }
+}
+
+// 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', _17 => _17.owner, 'optionalAccess', _18 => _18.login, 'optionalAccess', _19 => _19.toLowerCase, 'call', _20 => _20()]) !== 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', _21 => _21.owner, 'optionalAccess', _22 => _22.login, 'optionalAccess', _23 => _23.toLowerCase, 'call', _24 => _24()]) !== 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', _25 => _25.data, 'optionalAccess', _26 => _26.castAddBody, 'optionalAccess', _27 => _27.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/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));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.REGISTRY_ABI = REGISTRY_ABI; exports.REGISTRY_ADDRESS = REGISTRY_ADDRESS; exports.NETWORKS = NETWORKS; exports.isNetworkName = isNetworkName; exports.getRegistry = getRegistry; exports.chainFor = chainFor; exports.normalizeFingerprint = normalizeFingerprint; exports.fingerprintToBytes = fingerprintToBytes; exports.bytesToFingerprint = bytesToFingerprint; exports.fingerprintHash = fingerprintHash; exports.keyIdOf = keyIdOf; exports.keyIdToBytes = keyIdToBytes; exports.parsePgpKey = parsePgpKey; exports.verifyAttestation = verifyAttestation; exports.stripEmailUserIDs = stripEmailUserIDs; exports.hasEmailUserID = hasEmailUserID; exports.fetchKeyByFingerprint = fetchKeyByFingerprint; exports.fetchKeyByKeyId = fetchKeyByKeyId; exports.fetchEFPGraph = fetchEFPGraph; exports.identifyProof = identifyProof; exports.displayUrl = displayUrl; exports.proofHref = proofHref; exports.proofSecondaryHref = proofSecondaryHref; exports.verifyProof = verifyProof; exports.EIP712_NAME = EIP712_NAME; exports.EIP712_VERSION = EIP712_VERSION; exports.registryDomain = registryDomain; exports.AUTHORIZATION_TYPES = AUTHORIZATION_TYPES; exports.attestTypedData = attestTypedData; exports.reattestTypedData = reattestTypedData; exports.updateKeyTypedData = updateKeyTypedData; exports.revokeTypedData = revokeTypedData; exports.setRecordTypedData = setRecordTypedData; exports.authorizationDigest = authorizationDigest; exports.recordKind = recordKind;
+//# sourceMappingURL=chunk-NL4LHKJX.cjs.map