[General] OZ Factory/Clone pattern is not working on zkSyncEra

[andrebrener]

Environment

Mainnet

Provide a brief description of the functionality you're trying to implement and the issue you are running into.

When running the function to deploy a smart contract from a clone/proxy pattern factory contract is returning execution reverted: ERC1167: create failed error.

Contract is deployed at 0x48955e80B47e0FC170D3BFA3e85d15960388c0EC

Repo Link (Optional)

https://github.com/fuul-protocol/protocol-contracts/blob/main/contracts/FuulFactory.sol

Additional Details

No response

[0xsisyfos]

Hello,
Thank you for reaching out.
Did you check the differences between zkSync and Ethereum when in comes to contract deployment?
Here: https://docs.zksync.io/build/developer-reference/contract-deployment.html#ethereum-zksync-differences-in-contract-deployment

[andrebrener]

yes! I know why it doesn't work but I don't know exactly how to replace the OZ Clones implementation for one that works in zkSync.

This would work, right? and how do you implement it exactly?

import {FuulProject} from "./FuulProject.sol";
....

    FuulProject fuulProject = new FuulProject(
            arg1,
            arg2,
            arg3,
            arg4
        );

    address clone = address(fuulProject);

Taken from here

[bxpana]

We don't currently support ERC1167 since we have a different bytecode format. You could Accept the address in the constructor and fallback to this address always instead

pragma solidity ^0.8.20;

contract Proxy {
    address immutable implementation;

    constructor(address _implementation) {
        implementation = _implementation;
    }

    fallback() external payable {
        address impl = implementation;
        assembly {
            // The pointer to the free memory slot
            let ptr := mload(0x40)
            // Copy function signature and arguments from calldata at zero position into memory at pointer position
            calldatacopy(ptr, 0, calldatasize())
            // Delegatecall method of the implementation contract returns 0 on error
            let result := delegatecall(gas(), impl, ptr, calldatasize(), 0, 0)
            // Get the size of the last return data
            let size := returndatasize()
            // Copy the size length of bytes from return data at zero position to pointer position
            returndatacopy(ptr, 0, size)
            // Depending on the result value
            switch result
            case 0 {
                // End execution and revert state changes
                revert(ptr, size)
            }
            default {
                // Return data with length of size at pointers position
                return(ptr, size)
            }
        }
    }
}