@thurinlabs/identity-kit 0.8.0 → 1.0.1

package/dist/index.d.ts

@@ -1,14 +1,973 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as viem from 'viem';
+import { Hex, TypedDataDomain } from 'viem';
 import { ReactNode } from 'react';
 
+declare const REGISTRY_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "ATTEST_TYPEHASH";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "DOMAIN_SEPARATOR";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "EIP712_NAME";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "EIP712_VERSION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MAX_KEY_BYTES";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MAX_RECORD_BYTES";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MAX_SIG_BYTES";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MESSAGE_VERSION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "REATTEST_TYPEHASH";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "REVOKE_TYPEHASH";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "SET_RECORD_TYPEHASH";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "UPDATE_KEY_TYPEHASH";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "VERSION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "addressesFor";
+    readonly inputs: readonly [{
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "addressesForCount";
+    readonly inputs: readonly [{
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "addressesForRange";
+    readonly inputs: readonly [{
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "start";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "count";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "out";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "attest";
+    readonly inputs: readonly [{
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "attestFor";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "attestationCount";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "attestationsOf";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple[]";
+        readonly internalType: "struct PGPRegistry.Attestation[]";
+        readonly components: readonly [{
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "createdAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "revokedAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "messageVersion";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "keyPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "sigPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "attestationsOfRange";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "start";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "count";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "out";
+        readonly type: "tuple[]";
+        readonly internalType: "struct PGPRegistry.Attestation[]";
+        readonly components: readonly [{
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "createdAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "revokedAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "messageVersion";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "keyPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "sigPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "cancelAuthorization";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "current";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "found";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "attestation";
+        readonly type: "tuple";
+        readonly internalType: "struct PGPRegistry.Attestation";
+        readonly components: readonly [{
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "createdAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "revokedAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "messageVersion";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "keyPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "sigPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "fingerprintsForKeyId";
+    readonly inputs: readonly [{
+        readonly name: "keyId";
+        readonly type: "bytes8";
+        readonly internalType: "bytes8";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes[]";
+        readonly internalType: "bytes[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "fingerprintsForKeyIdCount";
+    readonly inputs: readonly [{
+        readonly name: "keyId";
+        readonly type: "bytes8";
+        readonly internalType: "bytes8";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "fingerprintsForKeyIdRange";
+    readonly inputs: readonly [{
+        readonly name: "keyId";
+        readonly type: "bytes8";
+        readonly internalType: "bytes8";
+    }, {
+        readonly name: "start";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "count";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "out";
+        readonly type: "bytes[]";
+        readonly internalType: "bytes[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getAttestation";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct PGPRegistry.Attestation";
+        readonly components: readonly [{
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "createdAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "revokedAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "messageVersion";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "keyPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "sigPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getPayload";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "nonces";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "reattest";
+    readonly inputs: readonly [{
+        readonly name: "revokeIndex";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "reattestFor";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "revokeIndex";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "record";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "kind";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "revoke";
+    readonly inputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "revokeFor";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setRecord";
+    readonly inputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "kind";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "value";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setRecordFor";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "kind";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "value";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "updateKey";
+    readonly inputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "updateKeyFor";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "event";
+    readonly name: "Attested";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+        readonly indexed: false;
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "messageVersion";
+        readonly type: "uint8";
+        readonly indexed: false;
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "keyPtr";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "sigPtr";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "submitter";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "KeyUpdated";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "oldKeyPtr";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newKeyPtr";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "submitter";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "NonceUsed";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "RecordSet";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "kind";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "submitter";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Revoked";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "submitter";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "AlreadyRevoked";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "AuthorizationExpired";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "DeploymentFailed";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "DuplicateActiveFingerprint";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "EmptyPublicKey";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "EmptySignature";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "IndexOutOfBounds";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidAuthorization";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidFingerprintLength";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidPointer";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "PublicKeyTooLarge";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "RecordTooLarge";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "SignatureTooLarge";
+    readonly inputs: readonly [];
+}];
+
+/**
+ * PGPRegistry v2 is deployed with CREATE2, so it has the same address on every
+ * network. (v1 lived at 0xf7a45BC662A78a6fb417ED5f52b3766cbf13EbBb on mainnet and
+ * is no longer read by Thurin.)
+ */
+declare const REGISTRY_ADDRESS: "0x9302E02e2869e129aC8516fE5eFFd51EA3082c09";
+/** Networks the PGPRegistry is deployed on. `mainnet` is the default everywhere. */
+type NetworkName = 'mainnet' | 'sepolia' | 'local';
+interface RegistryDeployment {
+    chainId: number;
+    address: `0x${string}`;
+    /** Block the registry was deployed in (informational; v2 needs no log scans). */
+    deployBlock: bigint;
+    /** Block explorer base URL for address/tx links. Empty when there is none. */
+    explorerUrl: string;
+    /** Keyless public RPC used when no rpcUrl is configured. */
+    defaultRpcUrl: string;
+}
+declare const NETWORKS: Record<NetworkName, RegistryDeployment>;
+declare function isNetworkName(value: unknown): value is NetworkName;
+/**
+ * The registry deployment for a network. `addressOverride` swaps the contract
+ * address (e.g. a local deploy that landed somewhere else).
+ */
+declare function getRegistry(network?: NetworkName, addressOverride?: string): RegistryDeployment;
+
 interface Attestation {
+    /** Position in the owner's attestation history. */
     index: number;
+    /** Lowercase hex fingerprint, no 0x (40 chars for v4 keys, 64 for v6). */
     fingerprint: string;
+    /** Unix seconds. */
     createdAt: number;
     revoked: boolean;
+    /** Unix seconds, or null while active. */
+    revokedAt: number | null;
+    /** Format of the clearsigned message (1 = "I control the Ethereum address: <address>"). */
+    messageVersion: number;
+    /** The clearsigned message stored on-chain (null only if the payload read failed). */
     pgpSignature: string | null;
+    /** The armored public key stored on-chain (null only if the payload read failed). */
     pgpPublicKey: string | null;
-    txHash: string | null;
     verification: PGPVerification | null;
 }
 interface PGPVerification {
@@ -79,12 +1038,166 @@ interface IdentityKitConfig {
     rpcUrl?: string;
     neynarApiKey?: string;
     baseUrl?: string;
+    /** Which PGPRegistry deployment to read: 'mainnet' (default) or 'sepolia'. */
+    network?: 'mainnet' | 'sepolia' | 'local';
+    /** Override the registry address (e.g. a local deploy that landed elsewhere). */
+    registryAddress?: string;
 }
 
+declare function chainFor(network?: NetworkName): {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://sepolia.etherscan.io";
+            readonly apiUrl: "https://api-sepolia.etherscan.io/api";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 751532;
+        };
+        readonly ensUniversalResolver: {
+            readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+            readonly blockCreated: 8928790;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 11155111;
+    name: "Sepolia";
+    nativeCurrency: {
+        readonly name: "Sepolia Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+} | {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: viem.ChainContract | {
+            [sourceId: number]: viem.ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: viem.ChainContract | undefined;
+        ensUniversalResolver?: viem.ChainContract | undefined;
+        multicall3?: viem.ChainContract | undefined;
+        erc6492Verifier?: viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 31337;
+    name: "Foundry";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["http://127.0.0.1:8545"];
+            readonly webSocket: readonly ["ws://127.0.0.1:8545"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://etherscan.io";
+            readonly apiUrl: "https://api.etherscan.io/api";
+        };
+    };
+    blockTime: 12000;
+    contracts: {
+        readonly ensUniversalResolver: {
+            readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+            readonly blockCreated: 23085558;
+        };
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 14353601;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 1;
+    name: "Ethereum";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://eth.merkle.io"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+};
 interface IdentityKitProviderProps extends IdentityKitConfig {
     children: ReactNode;
 }
-declare function IdentityKitProvider({ children, rpcUrl, neynarApiKey, baseUrl, }: IdentityKitProviderProps): react_jsx_runtime.JSX.Element;
+declare function IdentityKitProvider({ children, rpcUrl, neynarApiKey, baseUrl, network, registryAddress, }: IdentityKitProviderProps): react_jsx_runtime.JSX.Element;
 
 interface ThurinCardProps {
     ens?: string;
@@ -95,6 +1208,11 @@ declare function ThurinCard({ ens, address, theme }: ThurinCardProps): react_jsx
 
 declare function useThurinIdentity(ensOrAddress: string | undefined | null): ThurinIdentity;
 
+/**
+ * On-chain attestations for an address, read straight from the v2 registry:
+ * `attestationsOf` for the history, `getPayload` for each stored signature + key.
+ * No event logs, so any RPC works. Each claim is verified off-chain.
+ */
 declare function useAttestations(address: string | undefined | null): {
     claims: Attestation[];
     totalClaims: number;
@@ -108,7 +1226,16 @@ declare function useEFPGraph(address: string | undefined | null): {
     isLoading: boolean;
 };
 
-declare function usePGPProofs(fingerprint: string | undefined | null): {
+/**
+ * Proofs for an identity, read from the PGP key stored in its on-chain
+ * attestation. No keyserver is consulted: keys.openpgp.org only serves user
+ * IDs whose email is verified and drops non-email user IDs entirely, so it can
+ * never carry the published (non-email) identity that holds the notations.
+ *
+ * @param fingerprint the attested fingerprint (proofs must name it)
+ * @param armoredKey  the attestation's `pgpPublicKey`
+ */
+declare function usePGPProofs(fingerprint: string | undefined | null, armoredKey: string | undefined | null): {
     keyInfo: PGPKeyInfo | null;
     proofs: ProofResult[];
     isLoading: boolean;
@@ -127,78 +1254,341 @@ declare function verifyAttestation({ pgpPublicKey, pgpSignature, fingerprint, et
     fingerprint: string;
     ethAddress: string;
 }): Promise<PGPVerification>;
+interface StrippedKey {
+    /** Armored public key containing only the non-email user IDs. */
+    armored: string;
+    /** User IDs kept (no `@`). */
+    kept: string[];
+    /** User IDs removed (contained an `@`). */
+    removed: string[];
+}
+/**
+ * Remove every user ID that contains an email address, keeping the rest (and
+ * their self-certifications, so proof notations on a non-email user ID survive).
+ * Returns null when nothing would remain — openpgp needs at least one
+ * self-certified user ID to verify signatures, so such a key must not be
+ * published. The key material and subkeys are untouched; the fingerprint is
+ * unchanged.
+ */
+declare function stripEmailUserIDs(armoredKey: string): Promise<StrippedKey | null>;
+/** True when any user ID on the key contains an email address. */
+declare function hasEmailUserID(armoredKey: string): Promise<boolean>;
 declare function fetchKeyByFingerprint(fingerprint: string): Promise<string | null>;
 declare function fetchKeyByKeyId(keyId: string): Promise<string | null>;
 
 declare function fetchEFPGraph(address: string): Promise<EFPGraph | null>;
 
-declare const REGISTRY_ADDRESS: "0xf7a45BC662A78a6fb417ED5f52b3766cbf13EbBb";
-declare const CONTRACT_DEPLOY_BLOCK = 24515891n;
-declare const REGISTRY_ABI: readonly [{
-    readonly name: "Attested";
-    readonly type: "event";
-    readonly inputs: readonly [{
-        readonly name: "ethAddress";
+/** Normalize a fingerprint to lowercase hex with no prefix or spaces. Returns null if malformed. */
+declare function normalizeFingerprint(input: string): string | null;
+/** Fingerprint → the raw `bytes` argument the v2 registry takes (0x-prefixed, 20 or 32 bytes). */
+declare function fingerprintToBytes(fingerprint: string): Hex;
+/** Raw `bytes` from the registry → lowercase hex fingerprint without 0x. */
+declare function bytesToFingerprint(bytes: Hex | string): string;
+/** keccak256 of the raw fingerprint bytes — the `fingerprintHash` the registry indexes by. */
+declare function fingerprintHash(fingerprint: string): Hex;
+/**
+ * The long key ID as the `bytes8` the registry indexes by. Per RFC 9580 §5.5.4 it is the
+ * low-order 8 bytes of a v4 (20-byte) fingerprint and the high-order 8 bytes of a v6
+ * (32-byte) fingerprint — the same value `gpg --keyid-format long` prints.
+ */
+declare function keyIdOf(fingerprint: string): Hex;
+/** A 16-hex long key ID (spaces/0x tolerated) → `bytes8`. */
+declare function keyIdToBytes(keyId: string): Hex | null;
+
+/**
+ * EIP-712 authorizations for the registry's relayed writes (`attestFor`, `reattestFor`,
+ * `updateKeyFor`, `revokeFor`, `setRecordFor`). The owner signs one of these typed
+ * structs; anyone can then submit the matching call and pay the gas. Every field is
+ * bound, plus the owner's current `nonce` (read with `nonces(owner)`) and a `deadline`.
+ *
+ * The domain includes the chain id, so an authorization for one network cannot be
+ * replayed on another even though the registry has the same address everywhere.
+ */
+declare const EIP712_NAME = "Thurin PGPRegistry";
+declare const EIP712_VERSION = "2";
+declare function registryDomain(chainId: number, verifyingContract: Hex): TypedDataDomain;
+declare const AUTHORIZATION_TYPES: {
+    readonly Attest: readonly [{
+        readonly name: "owner";
         readonly type: "address";
-        readonly indexed: true;
-    }, {
-        readonly name: "fingerprintHash";
-        readonly type: "string";
-        readonly indexed: true;
     }, {
         readonly name: "fingerprint";
-        readonly type: "string";
-        readonly indexed: false;
+        readonly type: "bytes";
     }, {
         readonly name: "pgpSignature";
-        readonly type: "string";
-        readonly indexed: false;
+        readonly type: "bytes";
     }, {
         readonly name: "pgpPublicKey";
-        readonly type: "string";
-        readonly indexed: false;
+        readonly type: "bytes";
     }, {
-        readonly name: "index";
+        readonly name: "nonce";
         readonly type: "uint256";
-        readonly indexed: false;
     }, {
-        readonly name: "timestamp";
+        readonly name: "deadline";
         readonly type: "uint256";
-        readonly indexed: false;
     }];
-}, {
-    readonly name: "attestationCount";
-    readonly type: "function";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [{
-        readonly name: "addr";
+    readonly Reattest: readonly [{
+        readonly name: "owner";
         readonly type: "address";
+    }, {
+        readonly name: "revokeIndex";
+        readonly type: "uint256";
+    }, {
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+    }, {
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
     }];
-    readonly outputs: readonly [{
-        readonly name: "";
+    readonly UpdateKey: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
         readonly type: "uint256";
     }];
-}, {
-    readonly name: "getAttestation";
-    readonly type: "function";
-    readonly stateMutability: "view";
-    readonly inputs: readonly [{
-        readonly name: "addr";
+    readonly Revoke: readonly [{
+        readonly name: "owner";
         readonly type: "address";
     }, {
         readonly name: "index";
         readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
     }];
-    readonly outputs: readonly [{
-        readonly name: "fingerprint";
-        readonly type: "string";
+    readonly SetRecord: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
     }, {
-        readonly name: "createdAt";
+        readonly name: "index";
         readonly type: "uint256";
     }, {
-        readonly name: "revoked";
-        readonly type: "bool";
+        readonly name: "kind";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "value";
+        readonly type: "bytes";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
     }];
-}];
+};
+type AuthorizationAction = keyof typeof AUTHORIZATION_TYPES;
+interface Common {
+    owner: Hex;
+    nonce: bigint;
+    deadline: bigint;
+}
+type AttestAuthorization = Common & {
+    fingerprint: string;
+    pgpSignature: string;
+    pgpPublicKey: string;
+};
+type ReattestAuthorization = AttestAuthorization & {
+    revokeIndex: bigint;
+};
+type UpdateKeyAuthorization = Common & {
+    index: bigint;
+    pgpPublicKey: string;
+};
+type RevokeAuthorization = Common & {
+    index: bigint;
+};
+type SetRecordAuthorization = Common & {
+    index: bigint;
+    kind: Hex;
+    value: Hex;
+};
+/**
+ * Build the object to pass to viem/wagmi `signTypedData`. `fingerprint` is the hex
+ * fingerprint; `pgpSignature` / `pgpPublicKey` are the armored text exactly as they
+ * will be submitted (they are hashed as UTF-8 bytes).
+ */
+declare function attestTypedData(chainId: number, registry: Hex, a: AttestAuthorization): {
+    domain: TypedDataDomain;
+    types: {
+        Attest: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+        }, {
+            readonly name: "pgpSignature";
+            readonly type: "bytes";
+        }, {
+            readonly name: "pgpPublicKey";
+            readonly type: "bytes";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "Attest";
+    message: {
+        owner: `0x${string}`;
+        fingerprint: `0x${string}`;
+        pgpSignature: `0x${string}`;
+        pgpPublicKey: `0x${string}`;
+        nonce: bigint;
+        deadline: bigint;
+    };
+};
+declare function reattestTypedData(chainId: number, registry: Hex, a: ReattestAuthorization): {
+    domain: TypedDataDomain;
+    types: {
+        Reattest: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "revokeIndex";
+            readonly type: "uint256";
+        }, {
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+        }, {
+            readonly name: "pgpSignature";
+            readonly type: "bytes";
+        }, {
+            readonly name: "pgpPublicKey";
+            readonly type: "bytes";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "Reattest";
+    message: {
+        revokeIndex: bigint;
+        owner: `0x${string}`;
+        fingerprint: `0x${string}`;
+        pgpSignature: `0x${string}`;
+        pgpPublicKey: `0x${string}`;
+        nonce: bigint;
+        deadline: bigint;
+    };
+};
+declare function updateKeyTypedData(chainId: number, registry: Hex, a: UpdateKeyAuthorization): {
+    domain: TypedDataDomain;
+    types: {
+        UpdateKey: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "index";
+            readonly type: "uint256";
+        }, {
+            readonly name: "pgpPublicKey";
+            readonly type: "bytes";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "UpdateKey";
+    message: {
+        owner: `0x${string}`;
+        index: bigint;
+        pgpPublicKey: `0x${string}`;
+        nonce: bigint;
+        deadline: bigint;
+    };
+};
+declare function revokeTypedData(chainId: number, registry: Hex, a: RevokeAuthorization): {
+    domain: TypedDataDomain;
+    types: {
+        Revoke: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "index";
+            readonly type: "uint256";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "Revoke";
+    message: {
+        owner: `0x${string}`;
+        index: bigint;
+        nonce: bigint;
+        deadline: bigint;
+    };
+};
+declare function setRecordTypedData(chainId: number, registry: Hex, a: SetRecordAuthorization): {
+    domain: TypedDataDomain;
+    types: {
+        SetRecord: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "index";
+            readonly type: "uint256";
+        }, {
+            readonly name: "kind";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "value";
+            readonly type: "bytes";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "SetRecord";
+    message: {
+        owner: `0x${string}`;
+        index: bigint;
+        kind: `0x${string}`;
+        value: `0x${string}`;
+        nonce: bigint;
+        deadline: bigint;
+    };
+};
+/** The digest the registry recovers the signer from — handy for tests and CLIs. */
+declare function authorizationDigest(typedData: ReturnType<typeof attestTypedData | typeof reattestTypedData | typeof updateKeyTypedData | typeof revokeTypedData | typeof setRecordTypedData>): Hex;
+/** `bytes32 kind` for a record from a human-readable name, e.g. recordKind('thurin.vouch'). */
+declare function recordKind(name: string): Hex;
 
-export { type Attestation, CONTRACT_DEPLOY_BLOCK, type EFPGraph, type IdentityKitConfig, IdentityKitProvider, type IdentityKitProviderProps, type Notation, type PGPKeyInfo, type PGPVerification, type Proof, type ProofResult, REGISTRY_ABI, REGISTRY_ADDRESS, type SubkeyInfo, type Theme, ThurinCard, type ThurinCardProps, type ThurinIdentity, displayUrl, fetchEFPGraph, fetchKeyByFingerprint, fetchKeyByKeyId, identifyProof, parsePgpKey, proofHref, proofSecondaryHref, useAttestations, useEFPGraph, usePGPProofs, useThurinIdentity, verifyAttestation, verifyProof };
+export { AUTHORIZATION_TYPES, type AttestAuthorization, type Attestation, type AuthorizationAction, type EFPGraph, EIP712_NAME, EIP712_VERSION, type IdentityKitConfig, IdentityKitProvider, type IdentityKitProviderProps, NETWORKS, type NetworkName, type Notation, type PGPKeyInfo, type PGPVerification, type Proof, type ProofResult, REGISTRY_ABI, REGISTRY_ADDRESS, type ReattestAuthorization, type RegistryDeployment, type RevokeAuthorization, type SetRecordAuthorization, type StrippedKey, type SubkeyInfo, type Theme, ThurinCard, type ThurinCardProps, type ThurinIdentity, type UpdateKeyAuthorization, attestTypedData, authorizationDigest, bytesToFingerprint, chainFor, displayUrl, fetchEFPGraph, fetchKeyByFingerprint, fetchKeyByKeyId, fingerprintHash, fingerprintToBytes, getRegistry, hasEmailUserID, identifyProof, isNetworkName, keyIdOf, keyIdToBytes, normalizeFingerprint, parsePgpKey, proofHref, proofSecondaryHref, reattestTypedData, recordKind, registryDomain, revokeTypedData, setRecordTypedData, stripEmailUserIDs, updateKeyTypedData, useAttestations, useEFPGraph, usePGPProofs, useThurinIdentity, verifyAttestation, verifyProof };