Adds TimestampedHashRegistry contract

contracts/utils/TimestampedHashRegistry.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import "./interfaces/ITimestampedHashRegistry.sol";
+
+// TODO: would SelfMulticall be useful?
+contract TimestampedHashRegistry is Ownable, EIP712, ITimestampedHashRegistry {
+    using ECDSA for bytes32;
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    mapping(bytes32 => EnumerableSet.AddressSet) private _hashTypeToSigners;
+
+    mapping(bytes32 => SignedHash) public hashTypeToSignedHash;
+
+    bytes32 private constant _SIGNED_HASH_TYPE_HASH =
+        keccak256(
+            "SignedHash(bytes32 hashType,bytes32 hash,uint256 timestamp)"
+        );
+
+    constructor() EIP712("TimestampedHashRegistry", "1.0.0") {}
+
+    function setHashTypeSigners(
+        bytes32 hashType,
+        address[] calldata signers
+    ) external onlyOwner {
+        require(hashType != bytes32(0), "Hash is zero");
+        require(signers.length != 0, "Signers length is empty");
+        for (uint256 ind = 0; ind < signers.length; ind++) {
+            _hashTypeToSigners[hashType].add(signers[ind]);
+        }
+        emit SetHashTypeSigners(hashType, signers);
+    }
+
+    function registerSignedHash(
+        bytes32 hashType,
+        SignedHash calldata signedHash,
+        bytes[] calldata signatures
+    ) external {
+        require(hashType != bytes32(0), "Hash type is zero");
+        EnumerableSet.AddressSet storage signers = _hashTypeToSigners[hashType];
+        require(signers.length() != 0, "Signers have not been set");
+        require(
+            signatures.length == signers.length(),
+            "Signatures length mismatch"
+        );
+        for (uint256 ind = 0; ind < signatures.length; ind++) {
+            require(
+                signers.contains(
+                    _hashTypedDataV4(
+                        keccak256(
+                            abi.encode(
+                                _SIGNED_HASH_TYPE_HASH,
+                                hashType,
+                                signedHash.hash,
+                                signedHash.timestamp
+                            )
+                        )
+                    ).recover(signatures[ind])
+                ),
+                "Signature mismatch"
+            );
+        }
+        hashTypeToSignedHash[hashType] = SignedHash(
+            signedHash.hash,
+            signedHash.timestamp
+        );
+        emit RegisteredSignedHash(
+            hashType,
+            signedHash.hash,
+            signedHash.timestamp,
+            signatures
+        );
+    }
+
+    function getSigners(
+        bytes32 hashType
+    ) external view returns (address[] memory signers) {
+        signers = _hashTypeToSigners[hashType].values();
+    }
+}

contracts/utils/interfaces/ITimestampedHashRegistry.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+interface ITimestampedHashRegistry {
+    event SetHashTypeSigners(bytes32 indexed hashType, address[] signers);
+
+    event RegisteredSignedHash(
+        bytes32 indexed hashType,
+        bytes32 hash,
+        uint256 timestamp,
+        bytes[] signatures
+    );
+
+    struct SignedHash {
+        bytes32 hash; // i.e. merkle tree root
+        uint256 timestamp;
+    }
+
+    function setHashTypeSigners(
+        bytes32 hashType,
+        address[] calldata signers
+    ) external;
+
+    function registerSignedHash(
+        bytes32 hashType,
+        SignedHash calldata signedHash,
+        bytes[] calldata signatures
+    ) external;
+
+    function getSigners(
+        bytes32 hashType
+    ) external view returns (address[] memory signers);
+
+    function hashTypeToSignedHash(
+        bytes32 hashType
+    ) external view returns (bytes32 hash, uint256 timestamp);
+}

test/test-utils.js

@@ -70,14 +70,18 @@ module.exports = {
       [adminRole, ethers.utils.solidityKeccak256(['string'], [roleDescription])]
     );
   },
-  expiringMetaTxDomain: async (expiringMetaTxForwarder) => {
+  buildEIP712Domain: (name, chainId, verifyingContract) => {
     return {
-      name: 'ExpiringMetaTxForwarder',
+      name,
       version: '1.0.0',
-      chainId: (await expiringMetaTxForwarder.provider.getNetwork()).chainId,
-      verifyingContract: expiringMetaTxForwarder.address,
+      chainId,
+      verifyingContract,
     };
   },
+  expiringMetaTxDomain: async (expiringMetaTxForwarder) => {
+    const chainId = (await expiringMetaTxForwarder.provider.getNetwork()).chainId;
+    return module.exports.buildEIP712Domain('ExpiringMetaTxForwarder', chainId, expiringMetaTxForwarder.address);
+  },
   expiringMetaTxTypes: () => {
     return {
       ExpiringMetaTx: [

test/utils/TimestampedHashRegistry.sol.js

@@ -0,0 +1,251 @@
+const hre = require('hardhat');
+const helpers = require('@nomicfoundation/hardhat-network-helpers');
+const { StandardMerkleTree } = require('@openzeppelin/merkle-tree');
+const { expect } = require('chai');
+const { generateRandomBytes32, generateRandomAddress, buildEIP712Domain } = require('../test-utils');
+
+describe('TimestampedHashRegistry', function () {
+  const deploy = async () => {
+    const roleNames = [
+      'deployer',
+      'owner',
+      'dapiFallbackRootSigner1',
+      'dapiFallbackRootSigner2',
+      'dapiFallbackRootSigner3',
+      'airnode',
+      'randomPerson',
+    ];
+    const accounts = await hre.ethers.getSigners();
+    const roles = roleNames.reduce((acc, roleName, index) => {
+      return { ...acc, [roleName]: accounts[index] };
+    }, {});
+
+    const TimestampedHashRegistry = await hre.ethers.getContractFactory('TimestampedHashRegistry', roles.deployer);
+    const timestampedHashRegistry = await TimestampedHashRegistry.deploy();
+    await timestampedHashRegistry.connect(roles.deployer).transferOwnership(roles.owner.address);
+
+    const dapiName = 'API3/USD';
+    const fallbackBeaconTemplateId = generateRandomBytes32();
+    const fallbackBeaconId = hre.ethers.utils.solidityKeccak256(
+      ['address', 'bytes32'],
+      [roles.airnode.address, fallbackBeaconTemplateId]
+    );
+    const fallbackSponsorWalletAddress = generateRandomAddress();
+
+    const treeEntry = [hre.ethers.utils.formatBytes32String(dapiName), fallbackBeaconId, fallbackSponsorWalletAddress];
+    const treeValues = [
+      [generateRandomBytes32(), generateRandomBytes32(), generateRandomAddress()],
+      [generateRandomBytes32(), generateRandomBytes32(), generateRandomAddress()],
+      treeEntry,
+      [generateRandomBytes32(), generateRandomBytes32(), generateRandomAddress()],
+      [generateRandomBytes32(), generateRandomBytes32(), generateRandomAddress()],
+    ];
+    const tree = StandardMerkleTree.of(treeValues, ['bytes32', 'bytes32', 'address']);
+    const root = tree.root;
+    const timestamp = Math.floor(Date.now() / 1000);
+    const chainId = (await timestampedHashRegistry.provider.getNetwork()).chainId;
+    const domain = buildEIP712Domain('TimestampedHashRegistry', chainId, timestampedHashRegistry.address);
+    const types = {
+      SignedHash: [
+        { name: 'hashType', type: 'bytes32' },
+        { name: 'hash', type: 'bytes32' },
+        { name: 'timestamp', type: 'uint256' },
+      ],
+    };
+    const dapiFallbackHashType = hre.ethers.utils.formatBytes32String('dAPI fallback root');
+    const values = {
+      hashType: dapiFallbackHashType,
+      hash: root,
+      timestamp,
+    };
+    const signatures = await Promise.all(
+      [roles.dapiFallbackRootSigner1, roles.dapiFallbackRootSigner2, roles.dapiFallbackRootSigner3].map(
+        async (rootSigner) => await rootSigner._signTypedData(domain, types, values)
+      )
+    );
+
+    return {
+      roles,
+      timestampedHashRegistry,
+      dapiName,
+      fallbackBeaconTemplateId,
+      fallbackBeaconId,
+      fallbackSponsorWalletAddress,
+      domain,
+      types,
+      dapiFallbackHashType,
+      root,
+      timestamp,
+      signatures,
+    };
+  };
+
+  describe('constructor', function () {
+    it('constructs', async function () {
+      const { roles, timestampedHashRegistry } = await helpers.loadFixture(deploy);
+      expect(await timestampedHashRegistry.owner()).to.equal(roles.owner.address);
+    });
+  });
+
+  describe('setHashTypeSigners', function () {
+    context('Sender is the owner', function () {
+      context('HashType is not zero', function () {
+        context('Signers is not empty', function () {
+          it('sets signers', async function () {
+            const { roles, timestampedHashRegistry, dapiFallbackHashType } = await helpers.loadFixture(deploy);
+            const signers = [
+              roles.dapiFallbackRootSigner1.address,
+              roles.dapiFallbackRootSigner2.address,
+              roles.dapiFallbackRootSigner3.address,
+            ];
+            expect(await timestampedHashRegistry.getSigners(dapiFallbackHashType)).to.deep.equal([]);
+            await expect(timestampedHashRegistry.connect(roles.owner).setHashTypeSigners(dapiFallbackHashType, signers))
+              .to.emit(timestampedHashRegistry, 'SetHashTypeSigners')
+              .withArgs(dapiFallbackHashType, signers);
+            expect(await timestampedHashRegistry.getSigners(dapiFallbackHashType)).to.deep.equal(signers);
+          });
+        });
+        context('Signers is empty', function () {
+          it('reverts', async function () {
+            const { roles, timestampedHashRegistry } = await helpers.loadFixture(deploy);
+            await expect(
+              timestampedHashRegistry.connect(roles.owner).setHashTypeSigners(generateRandomBytes32(), [])
+            ).to.be.revertedWith('Signers length is empty');
+          });
+        });
+      });
+      context('HashType is zero', function () {
+        it('reverts', async function () {
+          const { roles, timestampedHashRegistry } = await helpers.loadFixture(deploy);
+          await expect(
+            timestampedHashRegistry.connect(roles.owner).setHashTypeSigners(hre.ethers.constants.HashZero, [])
+          ).to.be.revertedWith('Hash is zero');
+        });
+      });
+    });
+    context('Sender is not the owner', function () {
+      it('reverts', async function () {
+        const { roles, timestampedHashRegistry } = await helpers.loadFixture(deploy);
+        const rootSigners = [generateRandomAddress(), generateRandomAddress(), generateRandomAddress()];
+        await expect(
+          timestampedHashRegistry.connect(roles.randomPerson).setHashTypeSigners(generateRandomBytes32(), rootSigners)
+        ).to.be.revertedWith('Ownable: caller is not the owner');
+      });
+    });
+  });
+
+  describe('registerSignedHash', function () {
+    context('HashType is not zero', function () {
+      context('Signers is not empty', function () {
+        context('Number of signatures is equal to number of signers', function () {
+          context('All signatures match', function () {
+            it('registers hash', async function () {
+              const { roles, timestampedHashRegistry, dapiFallbackHashType, root, timestamp, signatures } =
+                await helpers.loadFixture(deploy);
+              const signers = [
+                roles.dapiFallbackRootSigner1.address,
+                roles.dapiFallbackRootSigner2.address,
+                roles.dapiFallbackRootSigner3.address,
+              ];
+              expect(await timestampedHashRegistry.hashTypeToSignedHash(dapiFallbackHashType)).to.contain(
+                hre.ethers.constants.HashZero,
+                0
+              );
+              await timestampedHashRegistry.connect(roles.owner).setHashTypeSigners(dapiFallbackHashType, signers);
+              await expect(
+                timestampedHashRegistry.registerSignedHash(dapiFallbackHashType, { hash: root, timestamp }, signatures)
+              )
+                .to.emit(timestampedHashRegistry, 'RegisteredSignedHash')
+                .withArgs(dapiFallbackHashType, root, timestamp, signatures);
+              expect(await timestampedHashRegistry.hashTypeToSignedHash(dapiFallbackHashType)).to.contain(
+                root,
+                timestamp
+              );
+            });
+          });
+          context('All signatures do not match', function () {
+            it('reverts', async function () {
+              const {
+                roles,
+                timestampedHashRegistry,
+                domain,
+                types,
+                dapiFallbackHashType,
+                root,
+                timestamp,
+                signatures,
+              } = await helpers.loadFixture(deploy);
+              const signers = [
+                roles.dapiFallbackRootSigner1.address,
+                roles.dapiFallbackRootSigner2.address,
+                roles.dapiFallbackRootSigner3.address,
+              ];
+              await timestampedHashRegistry.connect(roles.owner).setHashTypeSigners(dapiFallbackHashType, signers);
+              // Signed by a different signer
+              await expect(
+                timestampedHashRegistry.registerSignedHash(dapiFallbackHashType, { hash: root, timestamp }, [
+                  await roles.randomPerson._signTypedData(domain, types, {
+                    hashType: dapiFallbackHashType,
+                    hash: root,
+                    timestamp,
+                  }),
+                  ...signatures.slice(1),
+                ])
+              ).to.be.revertedWith('Signature mismatch');
+              // Signed a different root
+              await expect(
+                timestampedHashRegistry.registerSignedHash(dapiFallbackHashType, { hash: root, timestamp }, [
+                  await roles.dapiFallbackRootSigner1._signTypedData(domain, types, {
+                    hashType: dapiFallbackHashType,
+                    hash: generateRandomBytes32(),
+                    timestamp,
+                  }),
+                  ...signatures.slice(1),
+                ])
+              ).to.be.revertedWith('Signature mismatch');
+            });
+          });
+        });
+        context('Number of signatures is not equal to number of signers', function () {
+          it('reverts', async function () {
+            const { roles, timestampedHashRegistry, dapiFallbackHashType, root, timestamp, signatures } =
+              await helpers.loadFixture(deploy);
+            const signers = [
+              roles.dapiFallbackRootSigner1.address,
+              roles.dapiFallbackRootSigner2.address,
+              roles.dapiFallbackRootSigner3.address,
+            ];
+            await timestampedHashRegistry.connect(roles.owner).setHashTypeSigners(dapiFallbackHashType, signers);
+            await expect(
+              timestampedHashRegistry.registerSignedHash(
+                dapiFallbackHashType,
+                { hash: root, timestamp },
+                signatures.slice(1)
+              )
+            ).to.be.revertedWith('Signatures length mismatch');
+          });
+        });
+      });
+      context('Signers is empty', function () {
+        it('reverts', async function () {
+          const { timestampedHashRegistry, dapiFallbackHashType, root, timestamp } = await helpers.loadFixture(deploy);
+          await expect(
+            timestampedHashRegistry.registerSignedHash(dapiFallbackHashType, { hash: root, timestamp }, [])
+          ).to.be.revertedWith('Signers have not been set');
+        });
+      });
+    });
+    context('HashType is zero', function () {
+      it('reverts', async function () {
+        const { timestampedHashRegistry, root, timestamp, signatures } = await helpers.loadFixture(deploy);
+        await expect(
+          timestampedHashRegistry.registerSignedHash(
+            hre.ethers.constants.HashZero,
+            { hash: root, timestamp },
+            signatures
+          )
+        ).to.be.revertedWith('Hash type is zero');
+      });
+    });
+  });
+});