Create2Deployer Hardhat Script

deploy_deterministic.js

//Using hardhat-deploy & https://github.com/pcaversaccio/create2deployer

const { network } = require('hardhat');

require('hardhat');
const ethers = hre.ethers;

//https://github.com/pcaversaccio/create2deployer
const CREATE2_DEPLOYER_ADDRESS = '0x13b0D85CcB8bf860b6b79AF3029fCA081AE9beF2';
const CREATE2_DEPLOYER_ABI = [
	'event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)',
	'event Paused(address account)',
	'event Unpaused(address account)',
	'function computeAddress(bytes32 salt, bytes32 codeHash) view returns (address)',
	'function computeAddressWithDeployer(bytes32 salt, bytes32 codeHash, address deployer) pure returns (address)',
	'function deploy(uint256 value, bytes32 salt, bytes code)',
	'function deployERC1820Implementer(uint256 value, bytes32 salt)',
	'function killCreate2Deployer(address payoutAddress)',
	'function owner() view returns (address)',
	'function pause()',
	'function paused() view returns (bool)',
	'function renounceOwnership()',
	'function transferOwnership(address newOwner)',
	'function unpause()'
];

const SALT = process.env.DEPLOY_SALT;
const OWNER = process.env.DEPLOY_OWNER;
const GASLIMIT = 4 * 10 ** 6;

let Contracts = {
	ContractA: '',
	ContractB: '',
	ContractC: ''
};

function getArgs(name, owner) {
	switch (name) {
		case 'ContractB':
			return [owner, Contracts.ContractA];
		case 'ContractC':
			return [owner, Contracts.ContractA, Contracts.ContractB];
		default:
			return [owner];
	}
}

async function main() {
	let create2Deployer;
	let results = [];

	let wallet = new ethers.Wallet(process.env.DEPLOY_PRIVATE_KEY, ethers.provider);
	let signer = wallet.connect(ethers.provider);

	console.log('Network', hre.network.name);
	console.log('Deployer', signer.address);
	console.log('Gaslimit', GASLIMIT);

	if (hre.network.name === 'hardhat' || hre.network.name === 'localhost') {
		await ethers.provider.getSigner(0).sendTransaction({
			to: signer.address,
			value: ethers.utils.parseEther('1')
		});

		let hhCreate2Deployer = await ethers.getContractFactory('Create2DeployerLocal', signer);
		create2Deployer = await hhCreate2Deployer.deploy();
		await create2Deployer.deployed();
	} else {
		create2Deployer = new ethers.Contract(CREATE2_DEPLOYER_ADDRESS, CREATE2_DEPLOYER_ABI, signer);
	}

	for (let c = 0; c < Object.keys(Contracts).length; c++) {
		let contractName = Object.keys(Contracts)[c];
		let contractArgs = getArgs(contractName, OWNER);

		console.log('Deploying', contractName, contractArgs);

		let contract = await ethers.getContractFactory(contractName);
		let deployTransaction = contract.getDeployTransaction(...contractArgs);

		let computedContractAddress = await create2Deployer.computeAddress(
			ethers.utils.id(SALT),
			ethers.utils.keccak256(deployTransaction.data)
		);

		Contracts[contractName] = computedContractAddress;

		let options = {};
		if (hre.network.name.toLowerCase().indexOf('arbitrum') == -1) {
			options.gasLimit = GASLIMIT;
		}

		let createReceipt = await create2Deployer.deploy(
			0,
			ethers.utils.id(SALT),
			deployTransaction.data
		);
		createReceipt = await createReceipt.wait();

		results.push({
			contract: contractName,
			address: computedContractAddress,
			deployTransaction: createReceipt.transactionHash,
			match: createReceipt.events[0].address === computedContractAddress
		});
	}

	console.table(results);
}

main()
	.then(() => process.exit(0))
	.catch((error) => {
		console.error(error);
		process.exit(1);
	});