@thurinlabs/identity-kit 0.7.5 → 1.0.0

package/dist/index.cjs

@@ -2,12 +2,1247 @@
 var _react = require('react');
 var _wagmi = require('wagmi');
 var _chains = require('wagmi/chains');
+
+// src/core/abi.ts
+var REGISTRY_ABI = [
+  {
+    "type": "function",
+    "name": "ATTEST_TYPEHASH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "DOMAIN_SEPARATOR",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "EIP712_NAME",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "EIP712_VERSION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "MAX_KEY_BYTES",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "MAX_RECORD_BYTES",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "MAX_SIG_BYTES",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "MESSAGE_VERSION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "REATTEST_TYPEHASH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "REVOKE_TYPEHASH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "SET_RECORD_TYPEHASH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "UPDATE_KEY_TYPEHASH",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "VERSION",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8",
+        "internalType": "uint8"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "addressesFor",
+    "inputs": [
+      {
+        "name": "fingerprintHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "addressesForCount",
+    "inputs": [
+      {
+        "name": "fingerprintHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "addressesForRange",
+    "inputs": [
+      {
+        "name": "fingerprintHash",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "start",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "count",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "out",
+        "type": "address[]",
+        "internalType": "address[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "attest",
+    "inputs": [
+      {
+        "name": "fingerprint",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "pgpSignature",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "pgpPublicKey",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "attestFor",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "fingerprint",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "pgpSignature",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "pgpPublicKey",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "attestationCount",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "attestationsOf",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "tuple[]",
+        "internalType": "struct PGPRegistry.Attestation[]",
+        "components": [
+          {
+            "name": "fingerprint",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "createdAt",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "revokedAt",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "messageVersion",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "keyPtr",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sigPtr",
+            "type": "address",
+            "internalType": "address"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "attestationsOfRange",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "start",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "count",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "out",
+        "type": "tuple[]",
+        "internalType": "struct PGPRegistry.Attestation[]",
+        "components": [
+          {
+            "name": "fingerprint",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "createdAt",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "revokedAt",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "messageVersion",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "keyPtr",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sigPtr",
+            "type": "address",
+            "internalType": "address"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "cancelAuthorization",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "current",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "found",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "attestation",
+        "type": "tuple",
+        "internalType": "struct PGPRegistry.Attestation",
+        "components": [
+          {
+            "name": "fingerprint",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "createdAt",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "revokedAt",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "messageVersion",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "keyPtr",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sigPtr",
+            "type": "address",
+            "internalType": "address"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "fingerprintsForKeyId",
+    "inputs": [
+      {
+        "name": "keyId",
+        "type": "bytes8",
+        "internalType": "bytes8"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "fingerprintsForKeyIdCount",
+    "inputs": [
+      {
+        "name": "keyId",
+        "type": "bytes8",
+        "internalType": "bytes8"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "fingerprintsForKeyIdRange",
+    "inputs": [
+      {
+        "name": "keyId",
+        "type": "bytes8",
+        "internalType": "bytes8"
+      },
+      {
+        "name": "start",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "count",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "out",
+        "type": "bytes[]",
+        "internalType": "bytes[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getAttestation",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "tuple",
+        "internalType": "struct PGPRegistry.Attestation",
+        "components": [
+          {
+            "name": "fingerprint",
+            "type": "bytes",
+            "internalType": "bytes"
+          },
+          {
+            "name": "createdAt",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "revokedAt",
+            "type": "uint64",
+            "internalType": "uint64"
+          },
+          {
+            "name": "messageVersion",
+            "type": "uint8",
+            "internalType": "uint8"
+          },
+          {
+            "name": "keyPtr",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "sigPtr",
+            "type": "address",
+            "internalType": "address"
+          }
+        ]
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getPayload",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "pgpSignature",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "pgpPublicKey",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "nonces",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "reattest",
+    "inputs": [
+      {
+        "name": "revokeIndex",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "fingerprint",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "pgpSignature",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "pgpPublicKey",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "reattestFor",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "revokeIndex",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "fingerprint",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "pgpSignature",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "pgpPublicKey",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "record",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "kind",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "revoke",
+    "inputs": [
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "revokeFor",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setRecord",
+    "inputs": [
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "kind",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "value",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "setRecordFor",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "kind",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "value",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "updateKey",
+    "inputs": [
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "pgpPublicKey",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "updateKeyFor",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "pgpPublicKey",
+        "type": "bytes",
+        "internalType": "bytes"
+      },
+      {
+        "name": "deadline",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "signature",
+        "type": "bytes",
+        "internalType": "bytes"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "Attested",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "fingerprintHash",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "fingerprint",
+        "type": "bytes",
+        "indexed": false,
+        "internalType": "bytes"
+      },
+      {
+        "name": "messageVersion",
+        "type": "uint8",
+        "indexed": false,
+        "internalType": "uint8"
+      },
+      {
+        "name": "keyPtr",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "sigPtr",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "submitter",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "KeyUpdated",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "fingerprintHash",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "oldKeyPtr",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "newKeyPtr",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "submitter",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "NonceUsed",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "nonce",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "RecordSet",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "kind",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "submitter",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Revoked",
+    "inputs": [
+      {
+        "name": "owner",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "fingerprintHash",
+        "type": "bytes32",
+        "indexed": true,
+        "internalType": "bytes32"
+      },
+      {
+        "name": "index",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "submitter",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "error",
+    "name": "AlreadyRevoked",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "AuthorizationExpired",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "DeploymentFailed",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "DuplicateActiveFingerprint",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "EmptyPublicKey",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "EmptySignature",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "IndexOutOfBounds",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidAuthorization",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidFingerprintLength",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "InvalidPointer",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "PublicKeyTooLarge",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "RecordTooLarge",
+    "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "SignatureTooLarge",
+    "inputs": []
+  }
+];
+
+// src/core/contract.ts
+var REGISTRY_ADDRESS = "0x9302E02e2869e129aC8516fE5eFFd51EA3082c09";
+var NETWORKS = {
+  mainnet: {
+    chainId: 1,
+    address: REGISTRY_ADDRESS,
+    deployBlock: 25962908n,
+    // 2026-09-12, tx 0xda4c3a19cae4e71ffb02559a048403f664d5a7967c19d42158c39600ec63bad8
+    explorerUrl: "https://etherscan.io",
+    defaultRpcUrl: "https://ethereum-rpc.publicnode.com"
+  },
+  sepolia: {
+    chainId: 11155111,
+    address: REGISTRY_ADDRESS,
+    deployBlock: 11683667n,
+    // 2026-09-11, tx 0x3e40e8f5b9fbf82a4b8943561bcc9b964b2987de10640ac8ff3a1b4ef0725322
+    explorerUrl: "https://sepolia.etherscan.io",
+    defaultRpcUrl: "https://ethereum-sepolia-rpc.publicnode.com"
+  },
+  /** A local anvil instance (`anvil`, chain id 31337). Deploy with pgp-registry's Deploy script. */
+  local: {
+    chainId: 31337,
+    address: REGISTRY_ADDRESS,
+    deployBlock: 0n,
+    explorerUrl: "",
+    defaultRpcUrl: "http://127.0.0.1:8545"
+  }
+};
+function isNetworkName(value) {
+  return value === "mainnet" || value === "sepolia" || value === "local";
+}
+function getRegistry(network = "mainnet", addressOverride) {
+  const r = NETWORKS[network];
+  if (!r) throw new Error(`Unknown network: ${network}`);
+  if (addressOverride && /^0x[0-9a-fA-F]{40}$/.test(addressOverride)) {
+    return { ...r, address: addressOverride };
+  }
+  return r;
+}
+
+// src/provider.tsx
 var _reactquery = require('@tanstack/react-query');
 
 // src/context.ts
 
 var defaultConfig = {
-  scryBaseUrl: "https://thurin.id"
+  baseUrl: "https://thurin.id",
+  network: "mainnet"
 };
 var IdentityKitContext = _react.createContext.call(void 0, defaultConfig);
 function useIdentityKitConfig() {
@@ -24,22 +1259,25 @@ var defaultQueryClient = new (0, _reactquery.QueryClient)({
     }
   }
 });
-function createDefaultWagmiConfig(rpcUrl) {
-  return _wagmi.createConfig.call(void 0, {
-    chains: [_chains.mainnet],
-    transports: {
-      [_chains.mainnet.id]: _wagmi.http.call(void 0, rpcUrl || "https://ethereum-rpc.publicnode.com")
-    }
-  });
+function chainFor(network = "mainnet") {
+  if (network === "sepolia") return _chains.sepolia;
+  if (network === "local") return _chains.foundry;
+  return _chains.mainnet;
 }
-function WagmiDetector({ children, rpcUrl }) {
+function createDefaultWagmiConfig(rpcUrl, network) {
+  const url = rpcUrl || getRegistry(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) } });
+}
+function WagmiDetector({ children, rpcUrl, network }) {
   let hasWagmi = false;
   try {
     _wagmi.useConfig.call(void 0, );
     hasWagmi = true;
   } catch (e) {
   }
-  const wagmiConfig = _react.useMemo.call(void 0, () => createDefaultWagmiConfig(rpcUrl), [rpcUrl]);
+  const wagmiConfig = _react.useMemo.call(void 0, () => createDefaultWagmiConfig(rpcUrl, network), [rpcUrl, network]);
   if (hasWagmi) {
     return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children });
   }
@@ -49,93 +1287,84 @@ function IdentityKitProvider({
   children,
   rpcUrl,
   neynarApiKey,
-  scryBaseUrl = "https://thurin.id"
+  baseUrl = "https://thurin.id",
+  network = "mainnet",
+  registryAddress
 }) {
   const config = _react.useMemo.call(void 0, 
-    () => ({ rpcUrl, neynarApiKey, scryBaseUrl }),
-    [rpcUrl, neynarApiKey, scryBaseUrl]
+    () => ({ rpcUrl, neynarApiKey, baseUrl, network, registryAddress }),
+    [rpcUrl, neynarApiKey, baseUrl, network, registryAddress]
   );
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, IdentityKitContext.Provider, { value: config, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, WagmiDetector, { rpcUrl, children }) });
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, IdentityKitContext.Provider, { value: config, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, WagmiDetector, { rpcUrl, network, children }) });
 }
 
-// src/hooks/useScryIdentity.ts
-
+// src/hooks/useThurinIdentity.ts
 
 var _ens = require('viem/ens');
 
-// src/hooks/useSignetClaims.ts
-
+// src/hooks/useAttestations.ts
 
 
 var _viem = require('viem');
 
-// src/core/contract.ts
-var REGISTRY_ADDRESS = "0xf7a45BC662A78a6fb417ED5f52b3766cbf13EbBb";
-var CONTRACT_DEPLOY_BLOCK = 24515891n;
-var REGISTRY_ABI = [
-  {
-    name: "Attested",
-    type: "event",
-    inputs: [
-      { name: "ethAddress", type: "address", indexed: true },
-      { name: "fingerprintHash", type: "string", indexed: true },
-      { name: "fingerprint", type: "string", indexed: false },
-      { name: "pgpSignature", type: "string", indexed: false },
-      { name: "pgpPublicKey", type: "string", indexed: false },
-      { name: "index", type: "uint256", indexed: false },
-      { name: "timestamp", type: "uint256", indexed: false }
-    ]
-  },
-  {
-    name: "attestationCount",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "addr", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }]
-  },
-  {
-    name: "getAttestation",
-    type: "function",
-    stateMutability: "view",
-    inputs: [
-      { name: "addr", type: "address" },
-      { name: "index", type: "uint256" }
-    ],
-    outputs: [
-      { name: "fingerprint", type: "string" },
-      { name: "createdAt", type: "uint256" },
-      { name: "revoked", type: "bool" }
-    ]
-  }
-];
+// src/core/fingerprint.ts
 
-// src/core/logs.ts
-var LOG_CHUNK_SIZE = 49999n;
-async function getLogsChunked(client, params) {
-  const latest = await client.getBlockNumber();
-  const fromBlock = _nullishCoalesce(params.fromBlock, () => ( CONTRACT_DEPLOY_BLOCK));
-  const toBlock = params.toBlock === "latest" || !params.toBlock ? latest : params.toBlock;
-  const allLogs = [];
-  for (let start = fromBlock; start <= toBlock; start += LOG_CHUNK_SIZE) {
-    const end = start + LOG_CHUNK_SIZE - 1n > toBlock ? toBlock : start + LOG_CHUNK_SIZE - 1n;
-    const logs = await client.getLogs({
-      ...params,
-      fromBlock: start,
-      toBlock: end
-    });
-    allLogs.push(...logs);
-  }
-  return allLogs;
+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 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 { readKey } = await Promise.resolve().then(() => _interopRequireWildcard(require("openpgp")));
     const key = await readKey({ armoredKey });
     const fingerprint = key.getFingerprint().toUpperCase();
-    const algorithm = String(key.keyPacket.algorithm);
-    const created = _nullishCoalesce(_optionalChain([key, 'access', _2 => _2.keyPacket, 'access', _3 => _3.created, 'optionalAccess', _4 => _4.toISOString, 'call', _5 => _5()]), () => ( null));
+    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 = [];
@@ -152,7 +1381,7 @@ async function parsePgpKey(armoredKey) {
             cert.signatureType,
             { userID: user.userID, key: key.keyPacket }
           );
-        } catch (e2) {
+        } catch (e3) {
           continue;
         }
         userVerified = true;
@@ -170,17 +1399,17 @@ async function parsePgpKey(armoredKey) {
         }
       }
       if (userVerified) {
-        const uid = _optionalChain([user, 'access', _6 => _6.userID, 'optionalAccess', _7 => _7.userID]);
+        const uid = _optionalChain([user, 'access', _8 => _8.userID, 'optionalAccess', _9 => _9.userID]);
         if (uid) userIDs.push(uid);
       }
     }
     const subkeys = key.subkeys.map((sk) => ({
-      algorithm: String(sk.keyPacket.algorithm),
-      created: _nullishCoalesce(_optionalChain([sk, 'access', _8 => _8.keyPacket, 'access', _9 => _9.created, 'optionalAccess', _10 => _10.toISOString, 'call', _11 => _11()]), () => ( null)),
+      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 (e3) {
+  } catch (e4) {
     return null;
   }
 }
@@ -208,17 +1437,50 @@ async function verifyAttestation({
       return { verified: false, reason: "Signed message does not contain ETH address" };
     }
     return { verified: true };
-  } catch (e4) {
+  } 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 (e5) {
+  } catch (e8) {
     return null;
   }
 }
@@ -227,104 +1489,80 @@ async function fetchKeyByKeyId(keyId) {
     const resp = await fetch(`${KEYSERVER_BASE}/by-keyid/${keyId}`);
     if (!resp.ok) return null;
     return await resp.text();
-  } catch (e6) {
+  } catch (e9) {
     return null;
   }
 }
 
-// src/hooks/useSignetClaims.ts
-function useSignetClaims(address) {
+// src/hooks/useAttestations.ts
+function useAttestations(address) {
   const config = useIdentityKitConfig();
-  const { data: count, isLoading: countLoading } = _wagmi.useReadContract.call(void 0, {
-    address: REGISTRY_ADDRESS,
+  const registry = getRegistry(config.network, config.registryAddress);
+  const chain = chainFor(config.network);
+  const owner = address;
+  const { data: rows, isLoading: rowsLoading } = _wagmi.useReadContract.call(void 0, {
+    address: registry.address,
     abi: REGISTRY_ABI,
-    functionName: "attestationCount",
-    args: address ? [address] : void 0,
-    chainId: _chains.mainnet.id,
-    query: { enabled: !!address }
+    functionName: "attestationsOf",
+    args: owner ? [owner] : void 0,
+    chainId: chain.id,
+    query: { enabled: !!owner }
   });
-  const attestationCount = count ? Number(count) : 0;
-  const contracts = address ? Array.from({ length: attestationCount }, (_, i) => ({
-    address: REGISTRY_ADDRESS,
+  const count = _nullishCoalesce(_optionalChain([rows, 'optionalAccess', _18 => _18.length]), () => ( 0));
+  const contracts = owner && rows ? rows.map((_, i) => ({
+    address: registry.address,
     abi: REGISTRY_ABI,
-    functionName: "getAttestation",
-    args: [address, BigInt(i)],
-    chainId: _chains.mainnet.id
+    functionName: "getPayload",
+    args: [owner, BigInt(i)],
+    chainId: chain.id
   })) : [];
-  const { data: attestations, isLoading: attestationsLoading } = _wagmi.useReadContracts.call(void 0, {
+  const { data: payloads, isLoading: payloadsLoading } = _wagmi.useReadContracts.call(void 0, {
     contracts,
     query: { enabled: contracts.length > 0 }
   });
-  const { data: eventData } = _reactquery.useQuery.call(void 0, {
-    queryKey: ["signet-logs", address],
-    queryFn: async () => {
-      if (!address) return [];
-      const client = _viem.createPublicClient.call(void 0, {
-        chain: _chains.mainnet,
-        transport: _viem.http.call(void 0, config.rpcUrl || "https://ethereum-rpc.publicnode.com")
-      });
-      const event = _viem.parseAbiItem.call(void 0, 
-        "event Attested(address indexed ethAddress, string indexed fingerprintHash, string fingerprint, string pgpSignature, string pgpPublicKey, uint256 index, uint256 timestamp)"
-      );
-      return getLogsChunked(client, {
-        address: REGISTRY_ADDRESS,
-        event,
-        args: { ethAddress: address },
-        fromBlock: CONTRACT_DEPLOY_BLOCK,
-        toBlock: "latest"
-      });
-    },
-    enabled: !!address && attestationCount > 0,
-    staleTime: 3e5
-  });
+  const payloadsReady = count === 0 || payloads !== void 0 && payloads.length === count;
   const { data: claims, isLoading: verifyLoading } = _reactquery.useQuery.call(void 0, {
-    queryKey: ["signet-claims", address, attestationCount, !!eventData],
+    queryKey: ["attestations", config.network, registry.address, address, count, payloadsReady],
     queryFn: async () => {
-      if (!attestations || !address) return [];
+      if (!rows || !address) return [];
       const results = [];
-      const logsByIndex = {};
-      for (const l of eventData || []) logsByIndex[Number(l.args.index)] = l;
-      for (let i = 0; i < attestations.length; i++) {
-        const att = attestations[i];
-        if (att.status !== "success") continue;
-        const [fingerprint, createdAt, revoked] = att.result;
-        const log = logsByIndex[i];
-        const pgpSignature = _nullishCoalesce(_optionalChain([log, 'optionalAccess', _12 => _12.args, 'optionalAccess', _13 => _13.pgpSignature]), () => ( null));
-        const pgpPublicKey = _nullishCoalesce(_optionalChain([log, 'optionalAccess', _14 => _14.args, 'optionalAccess', _15 => _15.pgpPublicKey]), () => ( null));
-        const txHash = _nullishCoalesce(_optionalChain([log, 'optionalAccess', _16 => _16.transactionHash]), () => ( null));
-        let verification = null;
-        if (pgpPublicKey && pgpSignature) {
-          verification = await verifyAttestation({
-            pgpPublicKey,
-            pgpSignature,
-            fingerprint,
-            ethAddress: address
-          });
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const payload = _optionalChain([payloads, 'optionalAccess', _19 => _19[i]]);
+        let pgpSignature = null;
+        let pgpPublicKey = null;
+        if (payload && payload.status === "success") {
+          const [sigHex, keyHex] = payload.result;
+          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 revokedAt = Number(row.revokedAt);
         results.push({
           index: i,
           fingerprint,
-          createdAt: Number(createdAt),
-          revoked,
+          createdAt: Number(row.createdAt),
+          revoked: revokedAt !== 0,
+          revokedAt: revokedAt === 0 ? null : revokedAt,
+          messageVersion: Number(row.messageVersion),
           pgpSignature,
           pgpPublicKey,
-          txHash,
           verification
         });
       }
       return results;
     },
-    enabled: !!attestations && attestations.length > 0,
+    enabled: !!rows && payloadsReady,
     staleTime: 3e5
   });
-  const eventLogsPending = !!address && attestationCount > 0 && eventData === void 0;
-  const isLoading = countLoading || attestationsLoading || verifyLoading || eventLogsPending;
+  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', _17 => _17.verification, 'optionalAccess', _18 => _18.verified]));
+  const verifiedClaims = activeClaims.filter((c) => _optionalChain([c, 'access', _20 => _20.verification, 'optionalAccess', _21 => _21.verified]));
   const currentFingerprint = verifiedClaims.length > 0 ? verifiedClaims[verifiedClaims.length - 1].fingerprint : null;
   return {
     claims: claims || [],
-    totalClaims: attestationCount,
+    totalClaims: count,
     activeClaims: activeClaims.length,
     currentFingerprint,
     isLoading
@@ -357,7 +1595,7 @@ async function fetchEFPGraph(address) {
       top8: (top8Data.following || []).map((f) => f.data),
       hasEfp: true
     };
-  } catch (e7) {
+  } catch (e10) {
     return null;
   }
 }
@@ -462,7 +1700,7 @@ async function verifyGitHub(proof, fingerprint) {
     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', _19 => _19.owner, 'optionalAccess', _20 => _20.login, 'optionalAccess', _21 => _21.toLowerCase, 'call', _22 => _22()]) !== proof.user.toLowerCase()) {
+    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 || {})) {
@@ -520,7 +1758,7 @@ async function verifyFarcaster(proof, fingerprint, neynarApiKey) {
       const data = await resp.json();
       for (const msg of data.messages || []) {
         if (msg.hash && msg.hash.startsWith(proof.castHash)) {
-          const text = _optionalChain([msg, 'access', _23 => _23.data, 'optionalAccess', _24 => _24.castAddBody, 'optionalAccess', _25 => _25.text]) || "";
+          const text = _optionalChain([msg, 'access', _26 => _26.data, 'optionalAccess', _27 => _27.castAddBody, 'optionalAccess', _28 => _28.text]) || "";
           if (containsFingerprint(text, fingerprint)) {
             return { verified: true };
           }
@@ -559,7 +1797,7 @@ async function verifyMastodon(proof, fingerprint) {
     );
     if (!resp.ok) return { verified: false, reason: `Mastodon API returned ${resp.status}` };
     const data = await resp.json();
-    const keyId = fingerprint.slice(-16);
+    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)) {
@@ -591,14 +1829,14 @@ async function verifyProof(proof, fingerprint, neynarApiKey) {
 }
 
 // src/hooks/usePGPProofs.ts
-function usePGPProofs(fingerprint) {
+function usePGPProofs(fingerprint, armoredKey) {
   const config = useIdentityKitConfig();
   const { data } = _reactquery.useQuery.call(void 0, {
-    queryKey: ["pgp-proofs", fingerprint],
+    // 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', _29 => _29.length]), () => ( 0))],
     queryFn: async () => {
-      if (!fingerprint) return { keyInfo: null, proofs: [] };
-      const armoredKey = await fetchKeyByFingerprint(fingerprint);
-      if (!armoredKey) return { keyInfo: null, proofs: [] };
+      if (!fingerprint || !armoredKey) return { keyInfo: null, proofs: [] };
       const keyInfo = await parsePgpKey(armoredKey);
       if (!keyInfo) return { keyInfo: null, proofs: [] };
       const identified = keyInfo.notations.map((n) => identifyProof(n)).filter((p) => p !== null && p.provider !== "unknown");
@@ -627,49 +1865,50 @@ function usePGPProofs(fingerprint) {
       }
       return { keyInfo, proofs: [...byAccount.values()] };
     },
-    enabled: !!fingerprint,
+    enabled: !!fingerprint && !!armoredKey,
     staleTime: 3e5
   });
   return {
-    keyInfo: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _26 => _26.keyInfo]), () => ( null)),
-    proofs: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _27 => _27.proofs]), () => ( [])),
+    keyInfo: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _30 => _30.keyInfo]), () => ( null)),
+    proofs: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _31 => _31.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
     // would briefly paint without proof badges and then pop them in.
-    isLoading: !!fingerprint && data === void 0
+    isLoading: !!fingerprint && !!armoredKey && data === void 0
   };
 }
 
-// src/hooks/useScryIdentity.ts
+// src/hooks/useThurinIdentity.ts
 function isAddress(value) {
   return /^0x[0-9a-fA-F]{40}$/.test(value);
 }
 function safeNormalize(name) {
   try {
     return _ens.normalize.call(void 0, name);
-  } catch (e8) {
+  } catch (e11) {
     return void 0;
   }
 }
-function useScryIdentity(ensOrAddress) {
+function useThurinIdentity(ensOrAddress) {
+  const chain = chainFor(useIdentityKitConfig().network);
   const isAddr = ensOrAddress ? isAddress(ensOrAddress) : false;
   const ensInput = ensOrAddress && !isAddr ? safeNormalize(ensOrAddress) : void 0;
   const { data: resolvedAddress } = _wagmi.useEnsAddress.call(void 0, {
     name: ensInput,
-    chainId: _chains.mainnet.id,
+    chainId: chain.id,
     query: { enabled: !!ensInput }
   });
   const address = isAddr ? ensOrAddress : _nullishCoalesce(resolvedAddress, () => ( null));
   const { data: ensName } = _wagmi.useEnsName.call(void 0, {
     address,
-    chainId: _chains.mainnet.id,
+    chainId: chain.id,
     query: { enabled: !!address }
   });
   const displayName = ensInput || ensName || null;
   const { data: ensAvatar } = _wagmi.useEnsAvatar.call(void 0, {
     name: displayName ? safeNormalize(displayName) : void 0,
-    chainId: _chains.mainnet.id,
+    chainId: chain.id,
     query: { enabled: !!displayName }
   });
   const {
@@ -678,12 +1917,15 @@ function useScryIdentity(ensOrAddress) {
     activeClaims,
     currentFingerprint,
     isLoading: claimsLoading
-  } = useSignetClaims(address);
+  } = useAttestations(address);
+  const currentClaim = [...claims].reverse().find(
+    (c) => !c.revoked && _optionalChain([c, 'access', _32 => _32.verification, 'optionalAccess', _33 => _33.verified]) && c.fingerprint === currentFingerprint
+  );
   const {
     keyInfo: pgpKeyInfo,
     proofs,
     isLoading: proofsLoading
-  } = usePGPProofs(currentFingerprint);
+  } = usePGPProofs(currentFingerprint, _nullishCoalesce(_optionalChain([currentClaim, 'optionalAccess', _34 => _34.pgpPublicKey]), () => ( null)));
   const { efp, isLoading: efpLoading } = useEFPGraph(address);
   return {
     address,
@@ -701,81 +1943,205 @@ function useScryIdentity(ensOrAddress) {
   };
 }
 
-// src/components/ScryCard/ScryCard.tsx
+// src/components/ThurinCard/ThurinCard.tsx
 
 function ThurinLogo() {
-  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "svg", { className: "scry-card-avatar-placeholder", viewBox: "0 0 100 100", xmlns: "http://www.w3.org/2000/svg", children: [
-    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "circle", { cx: "50", cy: "50", r: "50", fill: "var(--scry-surface-deep)" }),
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "svg", { className: "thurin-card-avatar-placeholder", viewBox: "0 0 100 100", xmlns: "http://www.w3.org/2000/svg", children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "circle", { cx: "50", cy: "50", r: "50", fill: "var(--thurin-surface-deep)" }),
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { d: "M25 80 Q25 25 50 25 Q75 25 75 50", fill: "none", stroke: "#7c9a3e", strokeWidth: "4", strokeLinecap: "round" }),
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { d: "M33 75 Q33 35 50 35 Q67 35 67 52", fill: "none", stroke: "#7c9a3e", strokeWidth: "4", strokeLinecap: "round" }),
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { d: "M41 70 Q41 45 50 45 Q59 45 59 55", fill: "none", stroke: "#c9a227", strokeWidth: "4", strokeLinecap: "round" }),
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { d: "M50 65 L50 53", fill: "none", stroke: "#c9a227", strokeWidth: "4", strokeLinecap: "round" })
   ] });
 }
-function ScryCard({ ens, address, theme = "thurin" }) {
+function ThurinCard({ ens, address, theme = "thurin" }) {
   const input = ens || address;
-  const identity = useScryIdentity(input);
+  const identity = useThurinIdentity(input);
   const config = useIdentityKitConfig();
-  const scryUrl = identity.address ? `${config.scryBaseUrl}/eth/${identity.address}` : ens ? `${config.scryBaseUrl}/ens/${ens}` : null;
+  const profileUrl = identity.address ? `${config.baseUrl}/eth/${identity.address}` : ens ? `${config.baseUrl}/ens/${ens}` : null;
   if (identity.isLoading) {
-    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "scry-card", "data-scry-theme": theme, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "scry-card-loading", children: "Loading identity..." }) });
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "thurin-card", "data-thurin-theme": theme, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "thurin-card-loading", children: "Loading identity..." }) });
   }
   const displayAddress = identity.address || null;
   const verifiedProofs = identity.proofs.filter((p) => p.status === "verified").length;
-  const hasVerifiedPgp = identity.claims.some((c) => _optionalChain([c, 'access', _28 => _28.verification, 'optionalAccess', _29 => _29.verified]) && !c.revoked);
-  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card", "data-scry-theme": theme, children: [
-    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "a", { className: "scry-card-header", href: scryUrl || void 0, target: "_blank", rel: "noopener noreferrer", children: [
+  const hasVerifiedPgp = identity.claims.some((c) => _optionalChain([c, 'access', _35 => _35.verification, 'optionalAccess', _36 => _36.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, 
         "img",
         {
-          className: "scry-card-avatar",
+          className: "thurin-card-avatar",
           src: identity.ensAvatar,
           alt: identity.ensName || ""
         }
       ) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ThurinLogo, {}),
       /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { children: [
-        identity.ensName && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "scry-card-name", children: identity.ensName }),
-        displayAddress && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "scry-card-address", children: displayAddress })
+        identity.ensName && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "thurin-card-name", children: identity.ensName }),
+        displayAddress && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "thurin-card-address", children: displayAddress })
       ] })
     ] }),
-    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card-stats", children: [
-      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card-stat", children: [
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-value", children: identity.activeClaims }),
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-label", children: "Seals" })
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "thurin-card-stats", children: [
+      /* @__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: identity.activeClaims }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "thurin-card-stat-label", children: "Attestations" })
       ] }),
-      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card-stat", children: [
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-value", children: verifiedProofs }),
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-label", children: "Proofs" })
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "thurin-card-stat", children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "thurin-card-stat-value", children: verifiedProofs }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "thurin-card-stat-label", children: "Proofs" })
       ] }),
-      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card-stat", children: [
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-value", children: _nullishCoalesce(_optionalChain([identity, 'access', _30 => _30.efp, 'optionalAccess', _31 => _31.followers]), () => ( 0)) }),
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-stat-label", children: "Followers" })
+      /* @__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', _37 => _37.efp, 'optionalAccess', _38 => _38.followers]), () => ( 0)) }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "thurin-card-stat-label", children: "Followers" })
       ] })
     ] }),
-    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "scry-card-badges", children: [
-      hasVerifiedPgp && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-badge scry-card-badge--verified", children: "PGP Verified" }),
-      _optionalChain([identity, 'access', _32 => _32.efp, 'optionalAccess', _33 => _33.hasEfp]) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "scry-card-badge scry-card-badge--verified", children: "EFP" }),
+    /* @__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', _39 => _39.efp, 'optionalAccess', _40 => _40.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",
         {
-          className: `scry-card-badge scry-card-badge--${p.status === "verified" ? "verified" : "unverified"}`,
+          className: `thurin-card-badge thurin-card-badge--${p.status === "verified" ? "verified" : "unverified"}`,
           children: p.label
         },
         i
       ))
     ] }),
-    scryUrl && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    profileUrl && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
       "a",
       {
-        className: "scry-card-link",
-        href: scryUrl,
+        className: "thurin-card-link",
+        href: profileUrl,
         target: "_blank",
         rel: "noopener noreferrer",
-        children: "View on Scry"
+        children: "View on 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));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -796,5 +2162,5 @@ function ScryCard({ ens, address, theme = "thurin" }) {
 
 
 
-exports.CONTRACT_DEPLOY_BLOCK = CONTRACT_DEPLOY_BLOCK; exports.IdentityKitProvider = IdentityKitProvider; exports.REGISTRY_ABI = REGISTRY_ABI; exports.REGISTRY_ADDRESS = REGISTRY_ADDRESS; exports.ScryCard = ScryCard; exports.displayUrl = displayUrl; exports.fetchEFPGraph = fetchEFPGraph; exports.fetchKeyByFingerprint = fetchKeyByFingerprint; exports.fetchKeyByKeyId = fetchKeyByKeyId; exports.identifyProof = identifyProof; exports.parsePgpKey = parsePgpKey; exports.proofHref = proofHref; exports.proofSecondaryHref = proofSecondaryHref; exports.useEFPGraph = useEFPGraph; exports.usePGPProofs = usePGPProofs; exports.useScryIdentity = useScryIdentity; exports.useSignetClaims = useSignetClaims; exports.verifyAttestation = verifyAttestation; exports.verifyProof = verifyProof;
+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;
 //# sourceMappingURL=index.cjs.map