Add revert if the bytecode length is zero

contracts/mocks/Create2Impl.sol

@@ -4,13 +4,13 @@ import "../utils/Create2.sol";
 import "../token/ERC20/ERC20.sol";
 
 contract Create2Impl {
-    function deploy(bytes32 salt, bytes memory code) public {
-        Create2.deploy(salt, code);
+    function deploy(uint256 value, bytes32 salt, bytes memory code) public {
+        Create2.deploy(value, salt, code);
     }
 
-    function deployERC20(bytes32 salt) public {
+    function deployERC20(uint256 value, bytes32 salt) public {
         // solhint-disable-next-line indent
-        Create2.deploy(salt, type(ERC20).creationCode);
+        Create2.deploy(value, salt, type(ERC20).creationCode);
     }
 
     function computeAddress(bytes32 salt, bytes32 codeHash) public view returns (address) {

contracts/utils/Create2.sol

@@ -17,11 +17,13 @@ library Create2 {
      * will be deployed can be known in advance via {computeAddress}. Note that
      * a contract cannot be deployed twice using the same salt.
      */
-    function deploy(bytes32 salt, bytes memory bytecode) internal returns (address) {
+    function deploy(uint256 value, bytes32 salt, bytes memory bytecode) internal returns (address) {
         address addr;
+        require(address(this).balance >= value, "Factory does not have enough funds to fufill deposit");
+        require(bytecode.length > 0, "Create2: bytecode length is zero");
         // solhint-disable-next-line no-inline-assembly
         assembly {
-            addr := create2(0, add(bytecode, 0x20), mload(bytecode), salt)
+            addr := create2(value, add(bytecode, 0x20), mload(bytecode), salt)
         }
         require(addr != address(0), "Create2: Failed on deploy");
         return addr;

test/utils/Create2.test.js

@@ -1,5 +1,5 @@
 const { contract, accounts, web3 } = require('@openzeppelin/test-environment');
-const { BN, expectRevert } = require('@openzeppelin/test-helpers');
+const { balance, BN, ether, expectRevert, send } = require('@openzeppelin/test-helpers');
 
 const { expect } = require('chai');
 
@@ -40,23 +40,42 @@ describe('Create2', function () {
     const offChainComputed =
       computeCreate2Address(saltHex, ERC20.bytecode, this.factory.address);
     await this.factory
-      .deploy(saltHex, ERC20.bytecode, { from: deployerAccount });
+      .deploy(0, saltHex, ERC20.bytecode, { from: deployerAccount });
     expect(ERC20.bytecode).to.include((await web3.eth.getCode(offChainComputed)).slice(2));
   });
 
   it('should deploy a ERC20Mock with correct balances', async function () {
     const offChainComputed =
       computeCreate2Address(saltHex, constructorByteCode, this.factory.address);
     await this.factory
-      .deploy(saltHex, constructorByteCode, { from: deployerAccount });
+      .deploy(0, saltHex, constructorByteCode, { from: deployerAccount });
     const erc20 = await ERC20Mock.at(offChainComputed);
     expect(await erc20.balanceOf(deployerAccount)).to.be.bignumber.equal(new BN(100));
   });
 
+  it('should deploy a contract with funds deposited in the factory', async function () {
+    const deposit = ether('1');
+    await send.ether(deployerAccount, this.factory.address, deposit);
+    const generatedAddress =
+      await this.factory.deploy(deposit, saltHex, constructorByteCode, { from: deployerAccount });
+    expect(await balance.current(generatedAddress)).to.be.bignumber.equal(deposit);
+  });
+
   it('should failed deploying a contract in an existent address', async function () {
-    await this.factory.deploy(saltHex, constructorByteCode, { from: deployerAccount });
+    await this.factory.deploy(0, saltHex, constructorByteCode, { from: deployerAccount });
+    await expectRevert(
+      this.factory.deploy(0, saltHex, constructorByteCode, { from: deployerAccount }), 'Create2: Failed on deploy'
+    );
+  });
+  it('should fail deploying a contract if the bytecode length is zero', async function () {
+    await expectRevert(
+      this.factory.deploy(0, saltHex, '0x', { from: deployerAccount }), 'Create2: bytecode length is zero'
+    );
+  });
+  it('should fail deploying a contract if factory contract does not have sufficient balance', async function () {
     await expectRevert(
-      this.factory.deploy(saltHex, constructorByteCode, { from: deployerAccount }), 'Create2: Failed on deploy'
+      this.factory.deploy(1, saltHex, constructorByteCode, { from: deployerAccount }),
+      'Factory does not have enough funds to fufill deposit'
     );
   });
 });