github/zk-email-verify
1
1
Fork 0
mirror of https://github.com/zkemail/zk-email-verify.git synced 2026-01-09 13:38:03 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into zkfriendly/sol-191-circuit-utils-library

Browse Source
This commit is contained in:
zkfriendly
2025-08-22 11:08:57 +02:00
parent e8d7d0374f 850f7ce380
commit ea38bea99d
8 changed files with 399 additions and 2467 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
README.md
View File

@@ -30,7 +30,7 @@ Contains Solidity contracts for email verification purposes. [Read more](/packag
[Proof of Twitter](https://github.com/zkemail/proof-of-twitter/) is a demo application built using ZK-Email where you can prove ownership of a Twitter account (and mint an NFT) using an email from Twitter. [Proof of Twitter](https://github.com/zkemail/proof-of-twitter/) is a demo application built using ZK-Email where you can prove ownership of a Twitter account (and mint an NFT) using an email from Twitter.
Try here: [https://twitter.prove.email/](https://twitter.prove.email/) Try here: [https://twitter.zk.email/](https://twitter.zk.email/)
You can fork the project as a starting point for your own ZK-Email application. You can fork the project as a starting point for your own ZK-Email application.
@@ -42,13 +42,8 @@ Moreover, for those interested in creating the Twitter circuit from scratch, our
- Audit from [yAcademy](https://yacademy.dev/) - [Report](/audits/yacademy-audit.pdf). - Audit from [yAcademy](https://yacademy.dev/) - [Report](/audits/yacademy-audit.pdf).
## Contributors 💡 ## Contributors 💡
For each pull request that successfully merges and addresses an [open issue](https://github.com/zkemail/zk-email-verify/issues), we offer a $50 reward. Should we overlook issuing your reward, kindly send us a direct message as a reminder. To learn more about how you can contribute to this project, please consult our [Contributing Guide](CONTRIBUTING.md). For each pull request that successfully merges and addresses an [open issue](https://github.com/zkemail/zk-email-verify/issues), we offer a $50 reward. Feel free to email support@zk.email to let us know. To learn more about how you can contribute to this project, please consult our [Contributing Guide](CONTRIBUTING.md). Thank you to all of our existing contributors!
A heartfelt thank you goes to all of our contributors!
## Licensing ## Licensing
Everything we write is MIT-licensed. Note that circom and circomlib is GPL. Broadly we are pro permissive open source usage with attribution! We hope that those who derive profit from this, contribute that money altruistically back to this technology and open source public goods. Everything we write is MIT-licensed. Note that circom and circomlib is GPL. Broadly we are pro permissive open source usage with attribution! We hope that those who derive profit from this, contribute that money altruistically back to this technology and open source public goods.

47
packages/contracts/DKIMRegistry.sol
View File

@@ -2,7 +2,7 @@
pragma solidity ^0.8.0; pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/IDKIMRegistry.sol"; import "./interfaces/IERC7969.sol";
/** /**
A Registry that store the hash(dkim_public_key) for each domain A Registry that store the hash(dkim_public_key) for each domain
@@ -13,41 +13,25 @@ import "./interfaces/IDKIMRegistry.sol";
Input is DKIM pub key split into 17 chunks of 121 bits. You can use `helpers` package to fetch/split DKIM keys Input is DKIM pub key split into 17 chunks of 121 bits. You can use `helpers` package to fetch/split DKIM keys
*/ */
contract DKIMRegistry is IDKIMRegistry, Ownable { contract DKIMRegistry is IDKIMRegistry, Ownable {
constructor(address _signer) Ownable(_signer) { } constructor(address _signer) Ownable(_signer) {}
event DKIMPublicKeyHashRegistered(string domainName, bytes32 publicKeyHash); // Mapping from domain name hash to DKIM public key hash
event DKIMPublicKeyHashRevoked(bytes32 publicKeyHash); mapping(bytes32 => mapping(bytes32 => bool)) public dkimPublicKeyHashes;
// Mapping from domain name to DKIM public key hash
mapping(string => mapping(bytes32 => bool)) public dkimPublicKeyHashes;
// DKIM public that are revoked (eg: in case of private key compromise) // DKIM public that are revoked (eg: in case of private key compromise)
mapping(bytes32 => bool) public revokedDKIMPublicKeyHashes; mapping(bytes32 => bool) public revokedDKIMPublicKeyHashes;
function _stringEq( function isKeyHashValid(
string memory a, bytes32 domainNameHash,
string memory b
) internal pure returns (bool) {
return keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b));
}
function isDKIMPublicKeyHashValid(
string memory domainName,
bytes32 publicKeyHash bytes32 publicKeyHash
) public view returns (bool) { ) public view returns (bool) {
if (revokedDKIMPublicKeyHashes[publicKeyHash]) { return
return false; dkimPublicKeyHashes[domainNameHash][publicKeyHash] ||
} !revokedDKIMPublicKeyHashes[publicKeyHash];
if (dkimPublicKeyHashes[domainName][publicKeyHash]) {
return true;
}
return false;
} }
function setDKIMPublicKeyHash( function setDKIMPublicKeyHash(
string memory domainName, bytes32 domainHash,
bytes32 publicKeyHash bytes32 publicKeyHash
) public onlyOwner { ) public onlyOwner {
require( require(
@@ -55,23 +39,22 @@ contract DKIMRegistry is IDKIMRegistry, Ownable {
"cannot set revoked pubkey" "cannot set revoked pubkey"
); );
dkimPublicKeyHashes[domainName][publicKeyHash] = true; dkimPublicKeyHashes[domainHash][publicKeyHash] = true;
emit KeyHashRegistered(domainHash, publicKeyHash);
emit DKIMPublicKeyHashRegistered(domainName, publicKeyHash);
} }
function setDKIMPublicKeyHashes( function setDKIMPublicKeyHashes(
string memory domainName, bytes32 domainHash,
bytes32[] memory publicKeyHashes bytes32[] memory publicKeyHashes
) public onlyOwner { ) public onlyOwner {
for (uint256 i = 0; i < publicKeyHashes.length; i++) { for (uint256 i = 0; i < publicKeyHashes.length; i++) {
setDKIMPublicKeyHash(domainName, publicKeyHashes[i]); setDKIMPublicKeyHash(domainHash, publicKeyHashes[i]);
} }
} }
function revokeDKIMPublicKeyHash(bytes32 publicKeyHash) public onlyOwner { function revokeDKIMPublicKeyHash(bytes32 publicKeyHash) public onlyOwner {
revokedDKIMPublicKeyHashes[publicKeyHash] = true; revokedDKIMPublicKeyHashes[publicKeyHash] = true;
emit DKIMPublicKeyHashRevoked(publicKeyHash); emit KeyHashRevoked(publicKeyHash);
} }
} }

76
packages/contracts/UserOverrideableDKIMRegistry.sol
View File

@@ -2,7 +2,7 @@
pragma solidity ^0.8.0; pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/IDKIMRegistry.sol"; import "./interfaces/IERC7969.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol"; import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {IERC1271} from "@openzeppelin/contracts/interfaces/IERC1271.sol"; import {IERC1271} from "@openzeppelin/contracts/interfaces/IERC1271.sol";
@@ -24,21 +24,8 @@ contract UserOverrideableDKIMRegistry is
using Strings for *; using Strings for *;
using ECDSA for *; using ECDSA for *;
/// @notice Emitted when a DKIM public key hash is successfully set.
event DKIMPublicKeyHashRegistered(
string indexed domainName,
bytes32 indexed publicKeyHash,
address indexed authorizer
);
/// @notice Emitted when a DKIM public key hash is successfully revoked.
event DKIMPublicKeyHashRevoked(
bytes32 indexed publicKeyHash,
address indexed authorizer
);
/// @notice Emitted when a DKIM public key hash is successfully reactivated. /// @notice Emitted when a DKIM public key hash is successfully reactivated.
event DKIMPublicKeyHashReactivated( event KeyHashReactivated(
bytes32 indexed publicKeyHash, bytes32 indexed publicKeyHash,
address indexed authorizer address indexed authorizer
); );
@@ -53,7 +40,7 @@ contract UserOverrideableDKIMRegistry is
uint public setTimestampDelay; uint public setTimestampDelay;
/// @notice DKIM public key hashes that are set /// @notice DKIM public key hashes that are set
mapping(string => mapping(bytes32 => mapping(address => bool))) mapping(bytes32 => mapping(bytes32 => mapping(address => bool)))
public dkimPublicKeyHashes; public dkimPublicKeyHashes;
/// @notice DKIM public key hashes that are revoked (eg: in case of private key compromise) /// @notice DKIM public key hashes that are revoked (eg: in case of private key compromise)
@@ -87,34 +74,33 @@ contract UserOverrideableDKIMRegistry is
setTimestampDelay = _setTimestampDelay; setTimestampDelay = _setTimestampDelay;
} }
/// @notice Checks if a DKIM public key hash is valid for a given domain. /// @notice Checks if a DKIM public key hash is valid for a given domain hash.
/// @param domainName The domain name for which the DKIM public key hash is being checked. /// @param domainNameHash The hash of the domain name for which the DKIM public key hash is being checked.
/// @param publicKeyHash The hash of the DKIM public key to be checked. /// @param publicKeyHash The hash of the DKIM public key to be checked.
/// @return bool True if the DKIM public key hash is valid, false otherwise. /// @return bool True if the DKIM public key hash is valid, false otherwise.
/// @dev This function returns true if the owner of the given `msg.sender` approves the public key hash before `enabledTimeOfDKIMPublicKeyHash` and neither `mainAuthorizer` nor the owner of `msg.sender` revokes the public key hash. However, after `enabledTimeOfDKIMPublicKeyHash`, only one of their approvals is required. In addition, if the public key hash is reactivated by the owner of `msg.sender`, the public key hash revoked only by `mainAuthorizer` is considered valid. /// @dev This function returns true if the owner of the given `msg.sender` approves the public key hash before `enabledTimeOfDKIMPublicKeyHash` and neither `mainAuthorizer` nor the owner of `msg.sender` revokes the public key hash. However, after `enabledTimeOfDKIMPublicKeyHash`, only one of their approvals is required. In addition, if the public key hash is reactivated by the owner of `msg.sender`, the public key hash revoked only by `mainAuthorizer` is considered valid.
function isDKIMPublicKeyHashValid( function isKeyHashValid(
string memory domainName, bytes32 domainNameHash,
bytes32 publicKeyHash bytes32 publicKeyHash
) public view returns (bool) { ) public view returns (bool) {
address ownerOfSender = Ownable(msg.sender).owner(); address ownerOfSender = Ownable(msg.sender).owner();
return return isKeyHashValid(domainNameHash, publicKeyHash, ownerOfSender);
isDKIMPublicKeyHashValid(domainName, publicKeyHash, ownerOfSender);
} }
/// @notice Checks if a DKIM public key hash is valid for a given domain. /// @notice Checks if a DKIM public key hash is valid for a given domain.
/// @param domainName The domain name for which the DKIM public key hash is being checked. /// @param domainNameHash The hash of the domain name for which the DKIM public key hash is being checked.
/// @param publicKeyHash The hash of the DKIM public key to be checked. /// @param publicKeyHash The hash of the DKIM public key to be checked.
/// @param authorizer The address of the expected authorizer /// @param authorizer The address of the expected authorizer
/// @return bool True if the DKIM public key hash is valid, false otherwise. /// @return bool True if the DKIM public key hash is valid, false otherwise.
/// @dev This function returns true if 1) at least the given `authorizer` approves the public key hash before `enabledTimeOfDKIMPublicKeyHash` and 2) neither `mainAuthorizer` nor `authorizer` revokes the public key hash. However, after `enabledTimeOfDKIMPublicKeyHash`, only one of their approvals is required. In addition, if the public key hash is reactivated by the `authorizer`, the public key hash revoked only by `mainAuthorizer` is considered valid. /// @dev This function returns true if 1) at least the given `authorizer` approves the public key hash before `enabledTimeOfDKIMPublicKeyHash` and 2) neither `mainAuthorizer` nor `authorizer` revokes the public key hash. However, after `enabledTimeOfDKIMPublicKeyHash`, only one of their approvals is required. In addition, if the public key hash is reactivated by the `authorizer`, the public key hash revoked only by `mainAuthorizer` is considered valid.
/// @dev The domain name, public key hash, and authorizer address must not be zero. /// @dev The domain name, public key hash, and authorizer address must not be zero.
/// @dev The authorizer address cannot be the mainAuthorizer. /// @dev The authorizer address cannot be the mainAuthorizer.
function isDKIMPublicKeyHashValid( function isKeyHashValid(
string memory domainName, bytes32 domainNameHash,
bytes32 publicKeyHash, bytes32 publicKeyHash,
address authorizer address authorizer
) public view returns (bool) { ) public view returns (bool) {
require(bytes(domainName).length > 0, "domain name cannot be zero"); require(domainNameHash != bytes32(0), "domain name cannot be zero");
require(publicKeyHash != bytes32(0), "public key hash cannot be zero"); require(publicKeyHash != bytes32(0), "public key hash cannot be zero");
require(authorizer != address(0), "authorizer address cannot be zero"); require(authorizer != address(0), "authorizer address cannot be zero");
require( require(
@@ -126,7 +112,7 @@ contract UserOverrideableDKIMRegistry is
authorizer authorizer
); );
uint256 setThreshold = _computeSetThreshold( uint256 setThreshold = _computeSetThreshold(
domainName, domainNameHash,
publicKeyHash, publicKeyHash,
authorizer authorizer
); );
@@ -160,8 +146,10 @@ contract UserOverrideableDKIMRegistry is
require(bytes(domainName).length > 0, "domain name cannot be zero"); require(bytes(domainName).length > 0, "domain name cannot be zero");
require(publicKeyHash != bytes32(0), "public key hash cannot be zero"); require(publicKeyHash != bytes32(0), "public key hash cannot be zero");
require(authorizer != address(0), "authorizer address cannot be zero"); require(authorizer != address(0), "authorizer address cannot be zero");
bytes32 domainNameHash = keccak256(bytes(domainName));
require( require(
dkimPublicKeyHashes[domainName][publicKeyHash][authorizer] == false, dkimPublicKeyHashes[domainNameHash][publicKeyHash][authorizer] ==
false,
"public key hash is already set" "public key hash is already set"
); );
require( require(
@@ -192,19 +180,19 @@ contract UserOverrideableDKIMRegistry is
} }
} }
dkimPublicKeyHashes[domainName][publicKeyHash][authorizer] = true; dkimPublicKeyHashes[domainNameHash][publicKeyHash][authorizer] = true;
if (authorizer == mainAuthorizer) { if (authorizer == mainAuthorizer) {
enabledTimeOfDKIMPublicKeyHash[publicKeyHash] = enabledTimeOfDKIMPublicKeyHash[publicKeyHash] =
block.timestamp + block.timestamp +
setTimestampDelay; setTimestampDelay;
} }
emit DKIMPublicKeyHashRegistered(domainName, publicKeyHash, authorizer); emit KeyHashRegistered(domainNameHash, publicKeyHash);
} }
/** /**
* @dev Sets the DKIM public key hashes in batch. * @dev Sets the DKIM public key hashes in batch.
* @param domainNames An array of the domain name for which the DKIM public key hash is being set. * @param domainNames An array of the domain names for which the DKIM public key hash is being set.
* @param publicKeyHashes An array of the hash of the DKIM public key to be set. * @param publicKeyHashes An array of the hash of the DKIM public key to be set.
* @param authorizers An array of the address of the authorizer who can set the DKIM public key hash. * @param authorizers An array of the address of the authorizer who can set the DKIM public key hash.
* @param signatures An array of the signature proving the authorization to set the DKIM public key hash. * @param signatures An array of the signature proving the authorization to set the DKIM public key hash.
@@ -291,7 +279,7 @@ contract UserOverrideableDKIMRegistry is
} }
revokedDKIMPublicKeyHashes[publicKeyHash][authorizer] = true; revokedDKIMPublicKeyHashes[publicKeyHash][authorizer] = true;
emit DKIMPublicKeyHashRevoked(publicKeyHash, authorizer); emit KeyHashRevoked(keccak256(bytes(domainName)));
} }
/** /**
@@ -304,7 +292,7 @@ contract UserOverrideableDKIMRegistry is
* @custom:require The domain name, public key hash, and authorizer address must not be zero. * @custom:require The domain name, public key hash, and authorizer address must not be zero.
* @custom:require The public key hash must be revoked by the main authorizer. * @custom:require The public key hash must be revoked by the main authorizer.
* @custom:require The signature must be valid according to EIP-1271 if the authorizer is a contract, or ECDSA if the authorizer is an EOA. * @custom:require The signature must be valid according to EIP-1271 if the authorizer is a contract, or ECDSA if the authorizer is an EOA.
* @custom:event DKIMPublicKeyHashReactivated Emitted when a DKIM public key hash is successfully reactivated. * @custom:event KeyHashReactivated Emitted when a DKIM public key hash is successfully reactivated.
*/ */
function reactivateDKIMPublicKeyHash( function reactivateDKIMPublicKeyHash(
string memory domainName, string memory domainName,
@@ -328,7 +316,8 @@ contract UserOverrideableDKIMRegistry is
"revoke threshold must be one" "revoke threshold must be one"
); );
require( require(
_computeSetThreshold(domainName, publicKeyHash, authorizer) >= 2, _computeSetThreshold(keccak256(bytes(domainName)), publicKeyHash, authorizer) >=
2,
"set threshold must be larger than two" "set threshold must be larger than two"
); );
if (msg.sender != authorizer) { if (msg.sender != authorizer) {
@@ -356,7 +345,7 @@ contract UserOverrideableDKIMRegistry is
} }
reactivatedDKIMPublicKeyHashes[publicKeyHash][authorizer] = true; reactivatedDKIMPublicKeyHashes[publicKeyHash][authorizer] = true;
emit DKIMPublicKeyHashReactivated(publicKeyHash, authorizer); emit KeyHashReactivated(publicKeyHash, authorizer);
} }
/** /**
@@ -405,14 +394,15 @@ contract UserOverrideableDKIMRegistry is
} }
function _computeSetThreshold( function _computeSetThreshold(
string memory domainName, bytes32 domainNameHash,
bytes32 publicKeyHash, bytes32 publicKeyHash,
address authorizer address authorizer
) private view returns (uint256) { ) private view returns (uint256) {
uint256 threshold = 0; uint256 threshold = 0;
if ( if (
dkimPublicKeyHashes[domainName][publicKeyHash][mainAuthorizer] == dkimPublicKeyHashes[domainNameHash][publicKeyHash][
true mainAuthorizer
] == true
) { ) {
if ( if (
block.timestamp < enabledTimeOfDKIMPublicKeyHash[publicKeyHash] block.timestamp < enabledTimeOfDKIMPublicKeyHash[publicKeyHash]
@@ -423,7 +413,8 @@ contract UserOverrideableDKIMRegistry is
} }
} }
if ( if (
dkimPublicKeyHashes[domainName][publicKeyHash][authorizer] == true dkimPublicKeyHashes[domainNameHash][publicKeyHash][authorizer] ==
true
) { ) {
threshold += 2; threshold += 2;
} }
@@ -450,13 +441,6 @@ contract UserOverrideableDKIMRegistry is
return threshold; return threshold;
} }
function _stringEq(
string memory a,
string memory b
) internal pure returns (bool) {
return keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b));
}
/// @notice Upgrade the implementation of the proxy. /// @notice Upgrade the implementation of the proxy.
/// @param newImplementation Address of the new implementation. /// @param newImplementation Address of the new implementation.
function _authorizeUpgrade( function _authorizeUpgrade(

9
packages/contracts/interfaces/IDKIMRegistry.sol
View File

@@ -1,9 +0,0 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IDKIMRegistry {
function isDKIMPublicKeyHashValid(
string memory domainName,
bytes32 publicKeyHash
) external view returns (bool);
}

31
packages/contracts/interfaces/IERC7969.sol Normal file
View File

@@ -0,0 +1,31 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
/**
* @title ERC-7969 DKIM Registry Interface.
*
* @dev This interface provides a standard way to register and validate DKIM public key hashes onchain
* Domain owners can register their DKIM public key hashes and third parties can verify their validity
* The interface enables email-based account abstraction and secure account recovery mechanisms.
*
* NOTE: The ERC-165 identifier for this interface is `0xdee3d600`.
*/
interface IDKIMRegistry {
/// @dev Emitted when a new DKIM public key hash is registered for a domain
/// @param domainHash The keccak256 hash of the lowercase domain name
/// @param keyHash The keccak256 hash of the DKIM public key
event KeyHashRegistered(bytes32 domainHash, bytes32 keyHash);
/// @dev Emitted when a DKIM public key hash is revoked for a domain
/// @param domainHash The keccak256 hash of the domain name
event KeyHashRevoked(bytes32 domainHash);
/// @dev Checks if a DKIM key hash is valid for a given domain
/// @param domainHash The keccak256 hash of the lowercase domain name
/// @param keyHash The keccak256 hash of the DKIM public key
/// @return True if the key hash is valid for the domain, false otherwise
function isKeyHashValid(
bytes32 domainHash,
bytes32 keyHash
) external view returns (bool);
}

6
packages/contracts/test/DKIMRegistry.t.sol
View File

@@ -2,9 +2,9 @@
pragma solidity ^0.8.12; pragma solidity ^0.8.12;
import "@openzeppelin/contracts/utils/Strings.sol"; import "@openzeppelin/contracts/utils/Strings.sol";
import "forge-std/Test.sol"; import "forge-std/src/Test.sol";
import "forge-std/console.sol"; import "forge-std/src/console.sol";
import "../interfaces/IDKIMRegistry.sol"; import "../interfaces/IERC7969.sol";
import "../DKIMRegistry.sol"; import "../DKIMRegistry.sol";
/// @title ECDSAOwnedDKIMRegistry /// @title ECDSAOwnedDKIMRegistry

242
packages/contracts/test/UserOverrideableDKIMRegistry.t.sol
View File

@@ -10,6 +10,7 @@ import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/Messa
import "./helpers/ExampleERC1271.sol"; import "./helpers/ExampleERC1271.sol";
import "./helpers/ExampleOwnable.sol"; import "./helpers/ExampleOwnable.sol";
import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol"; import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
import {IDKIMRegistry} from "../interfaces/IERC7969.sol";
contract UserOverrideableDKIMRegistryTest is Test { contract UserOverrideableDKIMRegistryTest is Test {
UserOverrideableDKIMRegistry registry; UserOverrideableDKIMRegistry registry;
@@ -18,6 +19,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
using Strings for *; using Strings for *;
string public domainName = "example.com"; string public domainName = "example.com";
bytes32 public domainNameHash = keccak256(bytes(domainName));
bytes32 public publicKeyHash = bytes32(uint256(1)); bytes32 public publicKeyHash = bytes32(uint256(1));
bytes32 public publicKeyHash2 = bytes32(uint256(2)); bytes32 public publicKeyHash2 = bytes32(uint256(2));
uint256 public setTimestampDelay = 1 days; uint256 public setTimestampDelay = 1 days;
@@ -73,11 +75,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(user1); vm.startPrank(user1);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
user1
);
registry.setDKIMPublicKeyHash( registry.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -88,7 +86,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// setThreshold = 2 // setThreshold = 2
require( require(
registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), registry.isKeyHashValid(domainNameHash, publicKeyHash),
"Invalid public key hash" "Invalid public key hash"
); );
vm.stopPrank(); vm.stopPrank();
@@ -98,11 +96,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(mainAuthorizer); vm.startPrank(mainAuthorizer);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
mainAuthorizer
);
registry.setDKIMPublicKeyHash( registry.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -114,11 +108,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(user1); vm.startPrank(user1);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
user1
);
registry.setDKIMPublicKeyHash( registry.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -130,7 +120,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// setThreshold = 3 // setThreshold = 3
require( require(
registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), registry.isKeyHashValid(domainNameHash, publicKeyHash),
"Invalid public key hash" "Invalid public key hash"
); );
vm.stopPrank(); vm.stopPrank();
@@ -140,11 +130,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(mainAuthorizer); vm.startPrank(mainAuthorizer);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
mainAuthorizer
);
registry.setDKIMPublicKeyHash( registry.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -157,7 +143,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.warp(block.timestamp + setTimestampDelay); vm.warp(block.timestamp + setTimestampDelay);
// setThreshold = 2 // setThreshold = 2
require( require(
registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), registry.isKeyHashValid(domainNameHash, publicKeyHash),
"Invalid public key hash" "Invalid public key hash"
); );
vm.stopPrank(); vm.stopPrank();
@@ -178,11 +164,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
(uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest); (uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest);
bytes memory signature = abi.encodePacked(r, s, v); bytes memory signature = abi.encodePacked(r, s, v);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
mainAuthorizer
);
registry.setDKIMPublicKeyHash( registry.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -194,11 +176,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(user1); vm.startPrank(user1);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
user1
);
registry.setDKIMPublicKeyHash( registry.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -210,7 +188,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// setThreshold = 2 // setThreshold = 2
require( require(
registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), registry.isKeyHashValid(domainNameHash, publicKeyHash),
"Invalid public key hash" "Invalid public key hash"
); );
vm.stopPrank(); vm.stopPrank();
@@ -231,11 +209,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
(uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest); (uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest);
bytes memory signature = abi.encodePacked(r, s, v); bytes memory signature = abi.encodePacked(r, s, v);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
mainAuthorizer
);
registry.setDKIMPublicKeyHash( registry.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -248,7 +222,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.warp(block.timestamp + setTimestampDelay); vm.warp(block.timestamp + setTimestampDelay);
// setThreshold = 2 // setThreshold = 2
require( require(
registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), registry.isKeyHashValid(domainNameHash, publicKeyHash),
"Invalid public key hash" "Invalid public key hash"
); );
vm.stopPrank(); vm.stopPrank();
@@ -269,11 +243,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
(uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest); (uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest);
bytes memory signature = abi.encodePacked(r, s, v); bytes memory signature = abi.encodePacked(r, s, v);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
address(mainAuthorizerContract)
);
registryWithContract.setDKIMPublicKeyHash( registryWithContract.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -285,11 +255,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(user1); vm.startPrank(user1);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
user1
);
registryWithContract.setDKIMPublicKeyHash( registryWithContract.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -301,10 +267,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// setThreshold = 2 // setThreshold = 2
require( require(
registryWithContract.isDKIMPublicKeyHashValid( registryWithContract.isKeyHashValid(domainNameHash, publicKeyHash),
domainName,
publicKeyHash
),
"Invalid public key hash" "Invalid public key hash"
); );
vm.stopPrank(); vm.stopPrank();
@@ -325,11 +288,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
(uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest); (uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest);
bytes memory signature = abi.encodePacked(r, s, v); bytes memory signature = abi.encodePacked(r, s, v);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
address(mainAuthorizerContract)
);
registryWithContract.setDKIMPublicKeyHash( registryWithContract.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -342,10 +301,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.warp(block.timestamp + setTimestampDelay); vm.warp(block.timestamp + setTimestampDelay);
// setThreshold = 2 // setThreshold = 2
require( require(
registryWithContract.isDKIMPublicKeyHashValid( registryWithContract.isKeyHashValid(domainNameHash, publicKeyHash),
domainName,
publicKeyHash
),
"Invalid public key hash" "Invalid public key hash"
); );
vm.stopPrank(); vm.stopPrank();
@@ -354,10 +310,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
function testRevokeDKIMPublicKeyHashByUser1() public { function testRevokeDKIMPublicKeyHashByUser1() public {
vm.startPrank(user1); vm.startPrank(user1);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRevoked( emit IDKIMRegistry.KeyHashRevoked(domainNameHash);
publicKeyHash,
user1
);
registry.revokeDKIMPublicKeyHash( registry.revokeDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -368,7 +321,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
require( require(
!registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), !registry.isKeyHashValid(domainNameHash, publicKeyHash),
"public key hash is not revoked" "public key hash is not revoked"
); );
vm.stopPrank(); vm.stopPrank();
@@ -377,10 +330,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
function testRevokeDKIMPublicKeyHashByMainAuthorizer() public { function testRevokeDKIMPublicKeyHashByMainAuthorizer() public {
vm.startPrank(mainAuthorizer); vm.startPrank(mainAuthorizer);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRevoked( emit IDKIMRegistry.KeyHashRevoked(domainNameHash);
publicKeyHash,
mainAuthorizer
);
registry.revokeDKIMPublicKeyHash( registry.revokeDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -391,7 +341,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
require( require(
!registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), !registry.isKeyHashValid(domainNameHash, publicKeyHash),
"public key hash is not revoked" "public key hash is not revoked"
); );
vm.stopPrank(); vm.stopPrank();
@@ -412,10 +362,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
(uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest); (uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest);
bytes memory signature = abi.encodePacked(r, s, v); bytes memory signature = abi.encodePacked(r, s, v);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRevoked( emit IDKIMRegistry.KeyHashRevoked(domainNameHash);
publicKeyHash,
mainAuthorizer
);
registry.revokeDKIMPublicKeyHash( registry.revokeDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -426,7 +373,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
require( require(
!registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), !registry.isKeyHashValid(domainNameHash, publicKeyHash),
"public key hash is not revoked" "public key hash is not revoked"
); );
vm.stopPrank(); vm.stopPrank();
@@ -447,10 +394,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
(uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest); (uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest);
bytes memory signature = abi.encodePacked(r, s, v); bytes memory signature = abi.encodePacked(r, s, v);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRevoked( emit IDKIMRegistry.KeyHashRevoked(domainNameHash);
publicKeyHash,
address(mainAuthorizerContract)
);
registryWithContract.revokeDKIMPublicKeyHash( registryWithContract.revokeDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -461,10 +405,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
require( require(
!registryWithContract.isDKIMPublicKeyHashValid( !registryWithContract.isKeyHashValid(domainNameHash, publicKeyHash),
domainName,
publicKeyHash
),
"public key hash is not revoked" "public key hash is not revoked"
); );
vm.stopPrank(); vm.stopPrank();
@@ -485,7 +426,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// revokeThreshold = 0 // revokeThreshold = 0
require( require(
registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), registry.isKeyHashValid(domainNameHash, publicKeyHash),
"Invalid public key hash" "Invalid public key hash"
); );
vm.stopPrank(); vm.stopPrank();
@@ -518,7 +459,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
// revokeThreshold = 1 // revokeThreshold = 1
// reactivated // reactivated
require( require(
registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), registry.isKeyHashValid(domainNameHash, publicKeyHash),
"Invalid public key hash" "Invalid public key hash"
); );
vm.stopPrank(); vm.stopPrank();
@@ -551,7 +492,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
// revokeThreshold = 1 // revokeThreshold = 1
// reactivated // reactivated
require( require(
registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), registry.isKeyHashValid(domainNameHash, publicKeyHash),
"Invalid public key hash" "Invalid public key hash"
); );
vm.stopPrank(); vm.stopPrank();
@@ -584,7 +525,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
// revokeThreshold = 1 // revokeThreshold = 1
// not reactivated // not reactivated
require( require(
!registry.isDKIMPublicKeyHashValid(domainName, publicKeyHash), !registry.isKeyHashValid(domainNameHash, publicKeyHash),
"public key hash must be valid" "public key hash must be valid"
); );
vm.stopPrank(); vm.stopPrank();
@@ -606,34 +547,20 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.stopPrank(); vm.stopPrank();
} }
function testIsDKIMPublicKeyHashValidReturnsFalseByUser2() public { function testIsKeyHashValidByUser2() public {
testSetDKIMPublicKeyHashByUser1(); testSetDKIMPublicKeyHashByUser1();
vm.startPrank(address(exampleOwnable2)); vm.startPrank(address(exampleOwnable2));
// setThreshold = 0 // setThreshold = 0
bool isValid = registry.isDKIMPublicKeyHashValid( assertFalse(registry.isKeyHashValid(domainNameHash, publicKeyHash));
domainName,
publicKeyHash
);
assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
} }
function testIsDKIMPublicKeyHashValidReturnsFalseByUser2ECDSA() public { function testIsDKIMPublicKeyHashBeforeEnabledWithoutUserConfirm() public {
testSetDKIMPublicKeyHashByUser1();
}
function testRevertWhenIsDKIMPublicKeyHashBeforeEnabledWithoutUserConfirm()
public
{
vm.startPrank(mainAuthorizer); vm.startPrank(mainAuthorizer);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
mainAuthorizer
);
registry.setDKIMPublicKeyHash( registry.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -644,11 +571,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// setThreshold = 1 // setThreshold = 1
bool isValid = registry.isDKIMPublicKeyHashValid( assertFalse(registry.isKeyHashValid(domainNameHash, publicKeyHash));
domainName,
publicKeyHash
);
assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
} }
@@ -668,11 +591,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
(uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest); (uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest);
bytes memory signature = abi.encodePacked(r, s, v); bytes memory signature = abi.encodePacked(r, s, v);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
mainAuthorizer
);
registry.setDKIMPublicKeyHash( registry.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -683,11 +602,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// setThreshold = 1 // setThreshold = 1
bool isValid = registry.isDKIMPublicKeyHashValid( assertFalse(registry.isKeyHashValid(domainNameHash, publicKeyHash));
domainName,
publicKeyHash
);
assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
} }
@@ -707,11 +622,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
(uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest); (uint8 v, bytes32 r, bytes32 s) = vm.sign(9, digest);
bytes memory signature = abi.encodePacked(r, s, v); bytes memory signature = abi.encodePacked(r, s, v);
vm.expectEmit(); vm.expectEmit();
emit UserOverrideableDKIMRegistry.DKIMPublicKeyHashRegistered( emit IDKIMRegistry.KeyHashRegistered(domainNameHash, publicKeyHash);
domainName,
publicKeyHash,
address(mainAuthorizerContract)
);
registryWithContract.setDKIMPublicKeyHash( registryWithContract.setDKIMPublicKeyHash(
domainName, domainName,
publicKeyHash, publicKeyHash,
@@ -722,9 +633,8 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// setThreshold = 1 // setThreshold = 1
bool isValid = registryWithContract.isDKIMPublicKeyHashValid( assertFalse(
domainName, registryWithContract.isKeyHashValid(domainNameHash, publicKeyHash)
publicKeyHash
); );
assertEq(isValid, false); assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
@@ -955,37 +865,25 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.stopPrank(); vm.stopPrank();
} }
function testIsDKIMPublicKeyHashValidByUser1AfterRevokedByMainAuthorizer() function testIsKeyHashValidByUser1AfterRevokedByMainAuthorizer() public {
public
{
testRevokeDKIMPublicKeyHashByMainAuthorizer(); testRevokeDKIMPublicKeyHashByMainAuthorizer();
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// revokeThreshold = 1 // revokeThreshold = 1
bool isValid = registry.isDKIMPublicKeyHashValid( assertFalse(registry.isKeyHashValid(domainNameHash, publicKeyHash));
domainName,
publicKeyHash
);
assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
} }
function testIsDKIMPublicKeyHashValidByUser1AfterRevokedByUser1() function testIsKeyHashValidByUser1AfterRevokedByUser1() public {
public
{
testRevokeDKIMPublicKeyHashByUser1(); testRevokeDKIMPublicKeyHashByUser1();
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// revokeThreshold = 1 // revokeThreshold = 1
bool isValid = registry.isDKIMPublicKeyHashValid( assertFalse(registry.isKeyHashValid(domainNameHash, publicKeyHash));
domainName,
publicKeyHash
);
assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
} }
function testIsDKIMPublicKeyHashValidByUser1AfterSetByUser1RevokedByMainAuthorizer() function testIsKeyHashValidByUser1AfterSetByUser1RevokedByMainAuthorizer()
public public
{ {
testSetDKIMPublicKeyHashByUser1(); testSetDKIMPublicKeyHashByUser1();
@@ -993,15 +891,11 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// revokeThreshold = 1 // revokeThreshold = 1
bool isValid = registry.isDKIMPublicKeyHashValid( assertFalse(registry.isKeyHashValid(domainNameHash, publicKeyHash));
domainName,
publicKeyHash
);
assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
} }
function testIsDKIMPublicKeyHashValidByUser1AfterSetByMainAuthorizerBeforeEnabledRevokedByMainAuthorizer() function testIsKeyHashValidByUser1AfterSetByMainAuthorizerBeforeEnabledRevokedByMainAuthorizer()
public public
{ {
testSetDKIMPublicKeyHashByMainAuthorizerBeforeEnabled(); testSetDKIMPublicKeyHashByMainAuthorizerBeforeEnabled();
@@ -1009,15 +903,11 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// revokeThreshold = 1 // revokeThreshold = 1
bool isValid = registry.isDKIMPublicKeyHashValid( assertFalse(registry.isKeyHashValid(domainNameHash, publicKeyHash));
domainName,
publicKeyHash
);
assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
} }
function testIsDKIMPublicKeyHashValidByUser1AfterSetByMainAuthorizerAfterEnabledRevokedByMainAuthorizer() function testIsKeyHashValidByUser1AfterSetByMainAuthorizerAfterEnabledRevokedByMainAuthorizer()
public public
{ {
testSetDKIMPublicKeyHashByMainAuthorizerAfterEnabled(); testSetDKIMPublicKeyHashByMainAuthorizerAfterEnabled();
@@ -1025,31 +915,21 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// revokeThreshold = 1 // revokeThreshold = 1
bool isValid = registry.isDKIMPublicKeyHashValid( assertFalse(registry.isKeyHashValid(domainNameHash, publicKeyHash));
domainName,
publicKeyHash
);
assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
} }
function testIsDKIMPublicKeyHashValidByUser1AfterSetByUser1RevokedByUser1() function testIsKeyHashValidByUser1AfterSetByUser1RevokedByUser1() public {
public
{
testSetDKIMPublicKeyHashByUser1(); testSetDKIMPublicKeyHashByUser1();
testRevokeDKIMPublicKeyHashByUser1(); testRevokeDKIMPublicKeyHashByUser1();
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// revokeThreshold = 2 // revokeThreshold = 2
bool isValid = registry.isDKIMPublicKeyHashValid( assertFalse(registry.isKeyHashValid(domainNameHash, publicKeyHash));
domainName,
publicKeyHash
);
assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
} }
function testIsDKIMPublicKeyHashValidByUser1AfterSetByMainAuthorizerBeforeEnabledRevokedByUser1() function testIsKeyHashValidByUser1AfterSetByMainAuthorizerBeforeEnabledRevokedByUser1()
public public
{ {
testSetDKIMPublicKeyHashByMainAuthorizerBeforeEnabled(); testSetDKIMPublicKeyHashByMainAuthorizerBeforeEnabled();
@@ -1057,15 +937,11 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// revokeThreshold = 2 // revokeThreshold = 2
bool isValid = registry.isDKIMPublicKeyHashValid( assertFalse(registry.isKeyHashValid(domainNameHash, publicKeyHash));
domainName,
publicKeyHash
);
assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
} }
function testIsDKIMPublicKeyHashValidByUser1AfterSetByMainAuthorizerAfterEnabledRevokedByUser1() function testIsKeyHashValidByUser1AfterSetByMainAuthorizerAfterEnabledRevokedByUser1()
public public
{ {
testSetDKIMPublicKeyHashByMainAuthorizerAfterEnabled(); testSetDKIMPublicKeyHashByMainAuthorizerAfterEnabled();
@@ -1073,11 +949,7 @@ contract UserOverrideableDKIMRegistryTest is Test {
vm.startPrank(address(exampleOwnable1)); vm.startPrank(address(exampleOwnable1));
// revokeThreshold = 2 // revokeThreshold = 2
bool isValid = registry.isDKIMPublicKeyHashValid( assertFalse(registry.isKeyHashValid(domainNameHash, publicKeyHash));
domainName,
publicKeyHash
);
assertEq(isValid, false);
vm.stopPrank(); vm.stopPrank();
} }

2446
scripts/abis/DKIMRegistry.json
View File

File diff suppressed because one or more lines are too long