Mask computed address in Create2 and Clones libraries

.changeset/fluffy-steaks-exist.md

@@ -0,0 +1,5 @@
+---
+'openzeppelin-solidity': patch
+---
+
+`Create2`, `Clones`: Mask `computeAddress` and `cloneDeterministic` outputs to produce a clean value for an `address` type (i.e. only use 20 bytes)

contracts/mocks/ComputedAddressRemainderMock.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Clones} from "../proxy/Clones.sol";
+import {Create2} from "../utils/Create2.sol";
+
+contract ComputedAddressRemainderMock {
+ uint256 private constant _REMAINDER_MASK = ~(uint256(type(uint160).max));
+
+ function getCreate2ComputedRemainder(
+ bytes32 salt,
+ bytes32 bytecodeHash,
+ address deployer
+ ) external pure returns (uint256 remainder) {
+ address predicted = Create2.computeAddress(salt, bytecodeHash, deployer);
+ remainder = _getRemainder(predicted);
+ }
+
+ function getClonesPredictedRemainder(
+ address implementation,
+ bytes32 salt,
+ address deployer
+ ) external pure returns (uint256 remainder) {
+ address predicted = Clones.predictDeterministicAddress(implementation, salt, deployer);
+ remainder = _getRemainder(predicted);
+ }
+
+ function _getRemainder(address addr) internal pure returns (uint256 remainder) {
+ uint256 remainderMask = _REMAINDER_MASK;
+
+ /// @solidity memory-safe-assembly
+ assembly {
+ remainder := and(addr, remainderMask)
+ }
+ }
+}

contracts/proxy/Clones.sol

@@ -79,7 +79,7 @@ library Clones {
  mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
  mstore(add(ptr, 0x58), salt)
  mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
- predicted := keccak256(add(ptr, 0x43), 0x55)
+ predicted := and(keccak256(add(ptr, 0x43), 0x55), 0xffffffffffffffffffffffffffffffffffffffff)
  }
  }
 

contracts/utils/Create2.sol

@@ -90,7 +90,7 @@ library Create2 {
  mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes
  let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff
  mstore8(start, 0xff)
- addr := keccak256(start, 85)
+ addr := and(keccak256(start, 85), 0xffffffffffffffffffffffffffffffffffffffff)
  }
  }
 }

test/proxy/Clones.test.js

@@ -9,6 +9,7 @@ async function fixture() {
 
  const factory = await ethers.deployContract('$Clones');
  const implementation = await ethers.deployContract('DummyImplementation');
+ const computedAddressMock = await ethers.deployContract('ComputedAddressRemainderMock');
 
  const newClone = async (initData, opts = {}) => {
  const clone = await factory.$clone.staticCall(implementation).then(address => implementation.attach(address));
@@ -27,7 +28,7 @@ async function fixture() {
  return clone;
  };
 
- return { deployer, factory, implementation, newClone, newCloneDeterministic };
+ return { deployer, factory, implementation, computedAddressMock, newClone, newCloneDeterministic };
 }
 
 describe('Clones', function () {
@@ -83,5 +84,15 @@ describe('Clones', function () {
  .to.emit(this.factory, 'return$cloneDeterministic')
  .withArgs(predicted);
  });
+
+ it('clean address prediction', async function () {
+ const salt = ethers.randomBytes(32);
+ const predictedRemainder = await this.computedAddressMock.getClonesPredictedRemainder(
+ this.implementation,
+ salt,
+ ethers.Typed.address(this.deployer),
+ );
+ expect(predictedRemainder).to.equal(0);
+ });
  });
 });

test/utils/Create2.test.js

@@ -6,6 +6,7 @@ async function fixture() {
  const [deployer, other] = await ethers.getSigners();
 
  const factory = await ethers.deployContract('$Create2');
+ const computedAddressMock = await ethers.deployContract('ComputedAddressRemainderMock');
 
  // Bytecode for deploying a contract that includes a constructor.
  // We use a vesting wallet, with 3 constructor arguments.
@@ -19,7 +20,7 @@ async function fixture() {
  .getContractFactory('$Create2')
  .then(({ bytecode, interface }) => ethers.concat([bytecode, interface.encodeDeploy([])]));
 
- return { deployer, other, factory, constructorByteCode, constructorLessBytecode };
+ return { deployer, other, factory, computedAddressMock, constructorByteCode, constructorLessBytecode };
 }
 
 describe('Create2', function () {
@@ -54,6 +55,15 @@ describe('Create2', function () {
  );
  expect(onChainComputed).to.equal(offChainComputed);
  });
+
+ it('computes the clean contract address', async function () {
+ const computedRemainder = await this.computedAddressMock.getCreate2ComputedRemainder(
+ saltHex,
+ ethers.keccak256(this.constructorByteCode),
+ ethers.Typed.address(this.deployer),
+ );
+ expect(computedRemainder).to.equal(0);
+ });
  });
 
  describe('deploy', function () {