From 9c7ab667b0fd4d121d2f8f2af74a01efa557631a Mon Sep 17 00:00:00 2001 From: Hadrien Croubois Date: Thu, 27 Jun 2024 16:30:48 +0200 Subject: [PATCH] linted generation --- contracts/utils/cryptography/MerkleProof.sol | 8 +- scripts/generate/templates/MerkleProof.js | 251 +++++++++--------- .../generate/templates/MerkleProof.opts.js | 5 +- 3 files changed, 130 insertions(+), 134 deletions(-) diff --git a/contracts/utils/cryptography/MerkleProof.sol b/contracts/utils/cryptography/MerkleProof.sol index ccfc9ddbd8c..bfd90bdeda5 100644 --- a/contracts/utils/cryptography/MerkleProof.sol +++ b/contracts/utils/cryptography/MerkleProof.sol @@ -35,7 +35,7 @@ library MerkleProof { * This version handles proofs in memory with the default hashing function. */ function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) { - return processProof(proof, leaf) == root; + return processProof(proof, leaf, Hashes.commutativeKeccak256) == root; } /** @@ -100,7 +100,7 @@ library MerkleProof { * This version handles proofs in calldata with the default hashing function. */ function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) { - return processProof(proof, leaf) == root; + return processProof(proof, leaf, Hashes.commutativeKeccak256) == root; } /** @@ -170,7 +170,7 @@ library MerkleProof { bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { - return processMultiProof(proof, proofFlags, leaves) == root; + return processMultiProof(proof, proofFlags, leaves, Hashes.commutativeKeccak256) == root; } /** @@ -330,7 +330,7 @@ library MerkleProof { bytes32 root, bytes32[] calldata leaves ) internal pure returns (bool) { - return processMultiProof(proof, proofFlags, leaves) == root; + return processMultiProof(proof, proofFlags, leaves, Hashes.commutativeKeccak256) == root; } /** diff --git a/scripts/generate/templates/MerkleProof.js b/scripts/generate/templates/MerkleProof.js index 7f44f4f1573..0ec34248e05 100644 --- a/scripts/generate/templates/MerkleProof.js +++ b/scripts/generate/templates/MerkleProof.js @@ -1,6 +1,8 @@ const format = require('../format-lines'); const { OPTS } = require('./MerkleProof.opts'); +const DEFAULT_HASH = 'Hashes.commutativeKeccak256'; + // TEMPLATE const header = `\ pragma solidity ^0.8.20; @@ -24,143 +26,136 @@ import {Hashes} from "./Hashes.sol"; `; const errors = `\ - /** - *@dev The multiproof provided is not valid. - */ - error MerkleProofInvalidMultiproof(); +/** + *@dev The multiproof provided is not valid. + */ +error MerkleProofInvalidMultiproof(); `; +const formatArgsSingleLine = (...args) => args.filter(Boolean).join(', '); +const formatArgsMultiline = (...args) => '\n' + format(args.filter(Boolean).join(',\0').split('\0')); + /* eslint-disable max-len */ -const templateProof = ({ suffix, location, visibility, hashType, hashName = 'Hashes.commutativeKeccak256' }) => `\ - /** - * @dev Returns true if a \`leaf\` can be proved to be a part of a Merkle tree - * defined by \`root\`. For this, a \`proof\` must be provided, containing - * sibling hashes on the branch from the leaf to the root of the tree. Each - * pair of leaves and each pair of pre-images are assumed to be sorted. - * - * This version handles proofs in ${location} with ${hashType ? 'a custom' : 'the default'} hashing function. - */ - function verify${suffix}(${[ - `bytes32[] ${location} proof`, - 'bytes32 root', - 'bytes32 leaf', - hashType && [hashType, hashName].join(' '), - ] - .filter(Boolean) - .join(', ')}) internal ${visibility} returns (bool) { - return processProof(${['proof', 'leaf', hashType && hashName].filter(Boolean).join(', ')}) == root; - } +const templateProof = ({ suffix, location, visibility, hash }) => `\ +/** + * @dev Returns true if a \`leaf\` can be proved to be a part of a Merkle tree + * defined by \`root\`. For this, a \`proof\` must be provided, containing + * sibling hashes on the branch from the leaf to the root of the tree. Each + * pair of leaves and each pair of pre-images are assumed to be sorted. + * + * This version handles proofs in ${location} with ${hash ? 'a custom' : 'the default'} hashing function. + */ +function verify${suffix}(${(hash ? formatArgsMultiline : formatArgsSingleLine)( + `bytes32[] ${location} proof`, + 'bytes32 root', + 'bytes32 leaf', + hash && `function(bytes32, bytes32) view returns (bytes32) ${hash}`, +)}) internal ${visibility} returns (bool) { + return processProof(proof, leaf, ${hash ?? DEFAULT_HASH}) == root; +} - /** - * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up - * from \`leaf\` using \`proof\`. A \`proof\` is valid if and only if the rebuilt - * hash matches the root of the tree. When processing the proof, the pairs - * of leafs & pre-images are assumed to be sorted. - * - * This version handles proofs in ${location} with ${hashType ? 'a custom' : 'the default'} hashing function. - */ - function processProof${suffix}(${[ - `bytes32[] ${location} proof`, - 'bytes32 leaf', - hashType && [hashType, hashName].join(' '), - ] - .filter(Boolean) - .join(', ')}) internal ${visibility} returns (bytes32) { - bytes32 computedHash = leaf; - for (uint256 i = 0; i < proof.length; i++) { - computedHash = ${hashName}(computedHash, proof[i]); - } - return computedHash; +/** + * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up + * from \`leaf\` using \`proof\`. A \`proof\` is valid if and only if the rebuilt + * hash matches the root of the tree. When processing the proof, the pairs + * of leafs & pre-images are assumed to be sorted. + * + * This version handles proofs in ${location} with ${hash ? 'a custom' : 'the default'} hashing function. + */ +function processProof${suffix}(${(hash ? formatArgsMultiline : formatArgsSingleLine)( + `bytes32[] ${location} proof`, + 'bytes32 leaf', + hash && `function(bytes32, bytes32) view returns (bytes32) ${hash}`, +)}) internal ${visibility} returns (bytes32) { + bytes32 computedHash = leaf; + for (uint256 i = 0; i < proof.length; i++) { + computedHash = ${hash ?? DEFAULT_HASH}(computedHash, proof[i]); } + return computedHash; +} `; -const templateMultiProof = ({ suffix, location, visibility, hashType, hashName = 'Hashes.commutativeKeccak256' }) => `\ - /** - * @dev Returns true if the \`leaves\` can be simultaneously proven to be a part of a Merkle tree defined by - * \`root\`, according to \`proof\` and \`proofFlags\` as described in {processMultiProof}. - * - * This version handles multiproofs in ${location} with ${hashType ? 'a custom' : 'the default'} hashing function. - * - * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details. - */ - function multiProofVerify${suffix}(${[ - `bytes32[] ${location} proof`, - `bool[] ${location} proofFlags`, - 'bytes32 root', - `bytes32[] ${location} leaves`, - hashType && [hashType, hashName].join(' '), - ] - .filter(Boolean) - .join(', ')}) internal ${visibility} returns (bool) { - return processMultiProof(${['proof', 'proofFlags', 'leaves', hashType && hashName] - .filter(Boolean) - .join(', ')}) == root; +const templateMultiProof = ({ suffix, location, visibility, hash }) => `\ +/** + * @dev Returns true if the \`leaves\` can be simultaneously proven to be a part of a Merkle tree defined by + * \`root\`, according to \`proof\` and \`proofFlags\` as described in {processMultiProof}. + * + * This version handles multiproofs in ${location} with ${hash ? 'a custom' : 'the default'} hashing function. + * + * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details. + */ +function multiProofVerify${suffix}(${formatArgsMultiline( + `bytes32[] ${location} proof`, + `bool[] ${location} proofFlags`, + 'bytes32 root', + `bytes32[] ${location} leaves`, + hash && `function(bytes32, bytes32) view returns (bytes32) ${hash}`, +)}) internal ${visibility} returns (bool) { + return processMultiProof(proof, proofFlags, leaves, ${hash ?? DEFAULT_HASH}) == root; +} + +/** + * @dev Returns the root of a tree reconstructed from \`leaves\` and sibling nodes in \`proof\`. The reconstruction + * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another + * leaf/inner node or a proof sibling node, depending on whether each \`proofFlags\` item is true or false + * respectively. + * + * This version handles multiproofs in ${location} with ${hash ? 'a custom' : 'the default'} hashing function. + * + * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree + * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the + * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer). + */ +function processMultiProof${suffix}(${formatArgsMultiline( + `bytes32[] ${location} proof`, + `bool[] ${location} proofFlags`, + `bytes32[] ${location} leaves`, + hash && `function(bytes32, bytes32) view returns (bytes32) ${hash}`, +)}) internal ${visibility} returns (bytes32 merkleRoot) { + // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by + // consuming and producing values on a queue. The queue starts with the \`leaves\` array, then goes onto the + // \`hashes\` array. At the end of the process, the last hash in the \`hashes\` array should contain the root of + // the Merkle tree. + uint256 leavesLen = leaves.length; + uint256 totalHashes = proofFlags.length; + + // Check proof validity. + if (leavesLen + proof.length != totalHashes + 1) { + revert MerkleProofInvalidMultiproof(); } - /** - * @dev Returns the root of a tree reconstructed from \`leaves\` and sibling nodes in \`proof\`. The reconstruction - * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another - * leaf/inner node or a proof sibling node, depending on whether each \`proofFlags\` item is true or false - * respectively. - * - * This version handles multiproofs in ${location} with ${hashType ? 'a custom' : 'the default'} hashing function. - * - * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree - * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the - * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer). - */ - function processMultiProof${suffix}(${[ - `bytes32[] ${location} proof`, - `bool[] ${location} proofFlags`, - `bytes32[] ${location} leaves`, - hashType && [hashType, hashName].join(' '), - ] - .filter(Boolean) - .join(', ')}) internal ${visibility} returns (bytes32 merkleRoot) { - // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by - // consuming and producing values on a queue. The queue starts with the \`leaves\` array, then goes onto the - // \`hashes\` array. At the end of the process, the last hash in the \`hashes\` array should contain the root of - // the Merkle tree. - uint256 leavesLen = leaves.length; - uint256 totalHashes = proofFlags.length; + // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using + // \`xxx[xxxPos++]\`, which return the current value and increment the pointer, thus mimicking a queue's "pop". + bytes32[] memory hashes = new bytes32[](totalHashes); + uint256 leafPos = 0; + uint256 hashPos = 0; + uint256 proofPos = 0; + // At each step, we compute the next hash using two values: + // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we + // get the next hash. + // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the + // \`proof\` array. + for (uint256 i = 0; i < totalHashes; i++) { + bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; + bytes32 b = proofFlags[i] + ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]) + : proof[proofPos++]; + hashes[i] = ${hash ?? DEFAULT_HASH}(a, b); + } - // Check proof validity. - if (leavesLen + proof.length != totalHashes + 1) { + if (totalHashes > 0) { + if (proofPos != proof.length) { revert MerkleProofInvalidMultiproof(); } - - // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using - // \`xxx[xxxPos++]\`, which return the current value and increment the pointer, thus mimicking a queue's "pop". - bytes32[] memory hashes = new bytes32[](totalHashes); - uint256 leafPos = 0; - uint256 hashPos = 0; - uint256 proofPos = 0; - // At each step, we compute the next hash using two values: - // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we - // get the next hash. - // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the - // \`proof\` array. - for (uint256 i = 0; i < totalHashes; i++) { - bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; - bytes32 b = proofFlags[i] - ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]) - : proof[proofPos++]; - hashes[i] = ${hashName}(a, b); - } - - if (totalHashes > 0) { - if (proofPos != proof.length) { - revert MerkleProofInvalidMultiproof(); - } - unchecked { - return hashes[totalHashes - 1]; - } - } else if (leavesLen > 0) { - return leaves[0]; - } else { - return proof[0]; + unchecked { + return hashes[totalHashes - 1]; } + } else if (leavesLen > 0) { + return leaves[0]; + } else { + return proof[0]; } +} `; /* eslint-enable max-len */ @@ -168,8 +163,12 @@ const templateMultiProof = ({ suffix, location, visibility, hashType, hashName = module.exports = format( header.trimEnd(), 'library MerkleProof {', - errors, - ...OPTS.flatMap(opts => templateProof(opts)), - ...OPTS.flatMap(opts => templateMultiProof(opts)), + format( + [].concat( + errors, + OPTS.flatMap(opts => templateProof(opts)), + OPTS.flatMap(opts => templateMultiProof(opts)), + ), + ).trimEnd(), '}', ); diff --git a/scripts/generate/templates/MerkleProof.opts.js b/scripts/generate/templates/MerkleProof.opts.js index bd905e85d77..911f2392257 100644 --- a/scripts/generate/templates/MerkleProof.opts.js +++ b/scripts/generate/templates/MerkleProof.opts.js @@ -5,10 +5,7 @@ const OPTS = product( { suffix: '', location: 'memory' }, { suffix: 'Calldata', location: 'calldata' }, ], - [ - { visibility: 'pure' }, - { visibility: 'view', hashName: 'hasher', hashType: 'function(bytes32, bytes32) view returns (bytes32)' }, - ], + [{ visibility: 'pure' }, { visibility: 'view', hash: 'hasher' }], ).map(objs => Object.assign({}, ...objs)); module.exports = { OPTS };