Error: execution reverted

[Walid1Dev]

Team or Project

No response

Environment

Testnet

L2 block number

No response

zkSolc Version

1.5.8

zksync-ethers Version

6.15.3

Minimal Reproducible Code or Repo Link

DexFactory.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./LiquidityPool.sol";
import "./interfaces/IDexFactory.sol";
import "./interfaces/ILiquidityPool.sol";

contract DexFactory is IDexFactory {
    mapping(address => mapping(address => mapping(uint24 => address))) public getPool;
    address[] public allPools;
    address public immutable WETH;

constructor(address _weth) {
    require(_weth != address(0), "DexFactory: WETH cannot be zero address");
    WETH = _weth;
    
}

    function createPool(address tokenA, address tokenB, uint24 fee) external override returns (address payable pool) {
        require(tokenA != tokenB, "DexFactory: IDENTICAL_ADDRESSES");
        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        require(token0 != address(0), "DexFactory: ZERO_ADDRESS");
        require(getPool[token0][token1][fee] == address(0), "DexFactory: POOL_EXISTS");

        bytes memory bytecode = type(LiquidityPool).creationCode;
        bytes32 salt = keccak256(abi.encodePacked(token0, token1, fee));
       
        assembly {
            pool := create2(0, add(bytecode, 32), mload(bytecode), salt)
            if iszero(extcodesize(pool)) {
                revert(0, 0)
            }
        }

        require(pool != address(0), "DexFactory: FAILED_TO_CREATE_POOL");

        ILiquidityPool(pool).initialize(token0, token1, fee);

        getPool[token0][token1][fee] = pool;
        getPool[token1][token0][fee] = pool;
        allPools.push(pool);

        emit PoolCreated(token0, token1, fee, pool, allPools.length);
    }

    function allPoolsLength() external view override returns (uint256) {
        return allPools.length;
    }
}

debug file

const { ethers } = require("hardhat");

async function main() {
  const [deployer] = await ethers.getSigners();

  console.log("Deploying contracts with the account:", deployer.address);

  // Deploy WETH
  const WETH = await ethers.getContractFactory("WETH");
  const weth = await WETH.deploy();
  await weth.waitForDeployment();
  const wethAddress = await weth.getAddress();
  console.log("WETH deployed to:", wethAddress);

  // Deploy DexFactory
  const DexFactory = await ethers.getContractFactory("DexFactory");
  const factory = await DexFactory.deploy(wethAddress);
  await factory.waitForDeployment();
  const factoryAddress = await factory.getAddress();
  console.log("DexFactory deployed to:", factoryAddress);

  // Deploy test tokens
  const TestToken = await ethers.getContractFactory("TestToken");
  const token0 = await TestToken.deploy("Token0", "TK0");
  await token0.waitForDeployment();
  const token0Address = await token0.getAddress();
  console.log("Token0 deployed to:", token0Address);

  const token1 = await TestToken.deploy("Token1", "TK1");
  await token1.waitForDeployment();
  const token1Address = await token1.getAddress();
  console.log("Token1 deployed to:", token1Address);

  // Create a pool
  console.log("Creating pool...");

  try {
    console.log("Creating pool with tokens:", token0Address, token1Address);
    const createPoolTx = await factory.createPool(
      token0Address,
      token1Address,
      3000,
      {
        gasLimit: 10000000, // Increase gas limit
      }
    );
    console.log("Create pool transaction hash:", createPoolTx.hash);
    const receipt = await createPoolTx.wait();

    if (receipt.status === 1) {
      const poolAddress = await factory.getPool(
        token0Address,
        token1Address,
        3000
      );
      console.log("Pool created at:", poolAddress);

      // Initialize the pool (if needed)
      const LiquidityPool = await ethers.getContractFactory("LiquidityPool");
      const pool = LiquidityPool.attach(poolAddress);

      // Add initial liquidity
      const amount0 = ethers.parseEther("1");
      const amount1 = ethers.parseEther("1");

      await token0.approve(poolAddress, amount0);
      await token1.approve(poolAddress, amount1);

      console.log("Adding initial liquidity...");
      const addLiquidityTx = await pool.mint(
        amount0,
        amount1,
        0,
        0,
        deployer.address,
        {
          gasLimit: 1000000000, // Increase gas limit
        }
      );
      await addLiquidityTx.wait();
      console.log("Initial liquidity added");

      // Log pool reserves
      const [reserve0, reserve1] = await pool.getReserves();
      console.log("Pool reserves:", {
        reserve0: ethers.formatEther(reserve0),
        reserve1: ethers.formatEther(reserve1),
      });
    } else {
      console.error("Pool creation failed");
    }
  } catch (error) {
    console.error("Error creating pool:", error);
    if (error.data) {
      const decodedError = ethers.utils.toUtf8String(error.data);
      console.error("Decoded error:", decodedError);
    }
  }
}

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

Does this work on other EVMs? (If yes, please list at least 1 of them)

No

Description of What Your Contract Does

I am encountering an issue while deploying a contract on zkSync. I successfully deployed several contracts (WETH, DexFactory, Token0, Token1), but when attempting to create a pool using the DexFactory contract, the transaction reverts with the error: execution reverted: Error function_selector = 0x, data = 0x. The transaction fails with the error message provided below, and I am unable to proceed with creating the pool and im testing on inMemoryNode :

Additional Details

No response

[alhenaai[bot]]

It appears that the issue you're encountering with the DexFactory contract on the zkSync testnet involves the createPool function, which uses the create2 opcode for deploying a new LiquidityPool contract. The error message "execution reverted" typically indicates that something in the transaction or contract execution did not go as expected, which can be due to a variety of reasons including incorrect inputs, failed assertions, or other logic errors in the smart contract.

Here are a few steps and considerations to help troubleshoot and potentially resolve the issue:

1. Check Constructor Requirements: Ensure that the WETH address provided to the DexFactory constructor is correct and that the contract at that address is properly deployed and functioning as expected.

2. Validate Input Parameters: Verify that the input parameters (tokenA, tokenB, and fee) provided to the createPool function meet all the requirements laid out in the contract logic, such as not being identical and not being zero addresses.

3. Gas Limit and Transaction Settings: Since you're working on a testnet and using an in-memory node, ensure that the gas limit set in your transaction is sufficient for contract deployment. Sometimes, the default gas settings might not be enough for operations involving contract creation.

4. Contract Code and Deployment: Review the bytecode generation and the create2 deployment process in the createPool function. There might be an issue with how the bytecode is being handled or with the salt value used for creating a unique address.

5. Error Logging and Debugging: Enhance error logging in your smart contract, especially around the create2 call. You can modify the contract to provide more detailed revert messages. This can help pinpoint exactly where and why the transaction is failing.

6. Testing and Simulation: Utilize the zkSync Era test node for more detailed debugging. This tool can provide insights into transaction execution and state changes in a controlled environment.

7. Review Similar Deployments: Sometimes, looking at similar contracts or deployment strategies can provide clues. Check if there are similar implementations or community discussions that address similar issues.

If after these checks the issue still persists, it might be beneficial to share the specific error message or data returned from the transaction failure for further analysis. Additionally, consider reaching out on the zkSync developers discussions on Github for more targeted help from the developer community.

Your feedback helps us serve you better. If this fully addresses your question, please give it a thumbs up. If it doesn't, please give it a thumbs down. This will inform the community and team so we can improve our support.

[uF4No]

This is caused by your contract using create2 in an assembly block. As EraVM is different from the EVM, the use of assembly is limited. I'd recommend you to change that part to new Contract() instead.

Find more info in this section of EraVM docs.