BridgePool Factory

.gitignore

@@ -28,3 +28,6 @@ dist/
 scripts/generated
 node_modules/
 legacy/V1
+bridge/dist
+bridge/bindings 
+.deps

application/objs/ds.go

@@ -251,7 +251,8 @@ func (b *DataStore) Value() (*uint256.Uint256, error) {
 // Fee returns the fee stored in the object at the time of creation.
 // This is the total fee associated with the DataStore object.
 // Thus, we have
-//			Fee == perEpochFee*(numEpochs + 2)
+//
+//	Fee == perEpochFee*(numEpochs + 2)
 func (b *DataStore) Fee() (*uint256.Uint256, error) {
 	if b == nil {
 		return nil, errorz.ErrInvalid{}.New("ds.fee: ds not initialized")
@@ -264,7 +265,7 @@ func (b *DataStore) Fee() (*uint256.Uint256, error) {
 // Given a DataStore with data of size dataSize bytes which are to be stored
 // for of numEpochs, the value is
 //
-//		value := (dataSize + BaseDatasizeConst) * (numEpochs + 2)
+//	value := (dataSize + BaseDatasizeConst) * (numEpochs + 2)
 //
 // Here, BaseDatasizeConst is a constant which includes the base cost of the
 // actual storage object. Furthermore, we include 2 additional epochs into
@@ -273,14 +274,14 @@ func (b *DataStore) Fee() (*uint256.Uint256, error) {
 // Given the base cost, we also want to be able to include additional fees.
 // These fees would be on a per-epoch basis. Thus, we have the form
 //
-//		valuePlusFee := (dataSize + BaseDatasizeConst + perEpochFee) * (numEpochs + 2)
-//					  = (dataSize + BaseDatasizeConst) * (numEpochs + 2)
-//					    + perEpochFee * (numEpochs + 2)
-//					  = value + fee
+//	valuePlusFee := (dataSize + BaseDatasizeConst + perEpochFee) * (numEpochs + 2)
+//				  = (dataSize + BaseDatasizeConst) * (numEpochs + 2)
+//				    + perEpochFee * (numEpochs + 2)
+//				  = value + fee
 //
 // with
 //
-//		fee := perEpochFee * (numEpochs + 2)
+//	fee := perEpochFee * (numEpochs + 2)
 //
 // The fee is burned at creation.
 func (b *DataStore) ValuePlusFee() (*uint256.Uint256, error) {

application/objs/dspi.go

@@ -379,7 +379,7 @@ func RewardDepositEquation(deposit *uint256.Uint256, dataSize32, epochInitial, e
 //
 // The simple equation is
 //
-//		deposit = (dataSize + BaseDatasizeConst) * (2 + numEpochs)
+//	deposit = (dataSize + BaseDatasizeConst) * (2 + numEpochs)
 func BaseDepositEquation(dataSize32, numEpochs32 uint32) (*uint256.Uint256, error) {
 	if dataSize32 > constants.MaxDataStoreSize {
 		// dataSize is too large so we do not perform any checks
@@ -397,7 +397,7 @@ func BaseDepositEquation(dataSize32, numEpochs32 uint32) (*uint256.Uint256, erro
 //
 // The simple equation is
 //
-// 		numEpochs = (deposit / (dataSize + BaseDatasizeConst)) - 2
+//	numEpochs = (deposit / (dataSize + BaseDatasizeConst)) - 2
 //
 // We have additional checks to ensure there is no integer overflow.
 func NumEpochsEquation(dataSize32 uint32, deposit *uint256.Uint256) (uint32, error) {

bridge/contracts/BridgePoolFactory.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT-open-group
+pragma solidity ^0.8.16;
+
+import "contracts/libraries/errors/BridgePoolFactoryErrors.sol";
+import "contracts/libraries/factory/BridgePoolFactoryBase.sol";
+
+/// @custom:salt BridgePoolFactory
+/// @custom:deploy-type deployUpgradeable
+contract BridgePoolFactory is BridgePoolFactoryBase {
+    constructor() BridgePoolFactoryBase() {}
+
+    /**
+     * @notice Deploys a new bridge to pass tokens to our chain from the specified ERC contract.
+     * The pools are created as thin proxies (EIP1167) routing to versioned implementations identified by corresponding salt.
+     * @param tokenType_ type of token (1=ERC20, 2=ERC721)
+     * @param ercContract_ address of ERC20 source token contract
+     * @param implementationVersion_ version of BridgePool implementation to use
+     */
+    function deployNewNativePool(
+        uint8 tokenType_,
+        address ercContract_,
+        uint16 implementationVersion_
+    ) public onlyFactoryOrPublicPoolDeploymentEnabled {
+        _deployNewNativePool(tokenType_, ercContract_, implementationVersion_);
+    }
+
+    function deployPoolLogic(
+        uint8 tokenType_,
+        uint256 chainId_,
+        uint16 version_,
+        uint256 value_,
+        bytes calldata deployCode_
+    ) public onlyFactory returns (address) {
+        return _deployPoolLogic(tokenType_, chainId_, version_, value_, deployCode_);
+    }
+
+    /**
+     * @dev enables or disables public pool deployment
+     **/
+    function togglePublicPoolDeployment() public onlyFactory {
+        _togglePublicPoolDeployment();
+    }
+
+    /**
+     * @notice calculates salt for a BridgePool contract based on ERC contract's address, tokenType, chainID and version_
+     * @param tokenContractAddr_ address of ERC Token contract
+     * @param tokenType_ type of token (1=ERC20, 2=ERC721)
+     * @param version_ version of the implementation
+     * @param chainID_ chain ID
+     * @return calculated calculated salt
+     */
+    function getBridgePoolSalt(
+        address tokenContractAddr_,
+        uint8 tokenType_,
+        uint256 chainID_,
+        uint16 version_
+    ) public pure returns (bytes32) {
+        return
+            BridgePoolAddressUtil.getBridgePoolSalt(
+                tokenContractAddr_,
+                tokenType_,
+                chainID_,
+                version_
+            );
+    }
+}

bridge/contracts/interfaces/IBridgePool.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT-open-group
+pragma solidity ^0.8.11;
+
+interface IBridgePool {
+    function initialize(address ercContract_) external;
+
+    function deposit(address msgSender, bytes calldata depositParameters) external;
+
+    function withdraw(bytes memory _txInPreImage, bytes[4] memory _proofs) external;
+}

bridge/contracts/libraries/errors/BridgePoolFactoryErrors.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT-open-group
+pragma solidity ^0.8.16;
+
+library BridgePoolFactoryErrors {
+    error FailedToDeployLogic();
+    error PoolVersionNotSupported(uint16 version);
+    error StaticPoolDeploymentFailed(bytes32 salt_);
+    error UnexistentBridgePoolImplementationVersion(uint16 version);
+    error UnableToDeployBridgePool(bytes32 salt_);
+    error InsufficientFunds();
+    error PublicPoolDeploymentTemporallyDisabled();
+}

bridge/contracts/libraries/factory/BridgePoolFactoryBase.sol

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: MIT-open-group
+pragma solidity ^0.8.16;
+
+import "contracts/utils/ImmutableAuth.sol";
+import "contracts/libraries/errors/BridgePoolFactoryErrors.sol";
+import "contracts/interfaces/IBridgePool.sol";
+import "contracts/utils/BridgePoolAddressUtil.sol";
+import "@openzeppelin/contracts/utils/Strings.sol";
+
+abstract contract BridgePoolFactoryBase is ImmutableFactory {
+    enum TokenType {
+        ERC20,
+        ERC721,
+        ERC1155
+    }
+    //chainid of layer 1 chain, 1 for ether mainnet
+    uint256 private immutable _chainID;
+    bool public publicPoolDeploymentEnabled;
+    address private _implementation;
+    mapping(string => address) internal _logicAddresses;
+    event BridgePoolCreated(address poolAddress, address token);
+
+    modifier onlyFactoryOrPublicPoolDeploymentEnabled() {
+        if (msg.sender != _factoryAddress() && !publicPoolDeploymentEnabled) {
+            revert BridgePoolFactoryErrors.PublicPoolDeploymentTemporallyDisabled();
+        }
+        _;
+    }
+
+    constructor() ImmutableFactory(msg.sender) {
+        _chainID = block.chainid;
+    }
+
+    // NativeERC20V!
+    /**
+     * @notice returns bytecode for a Minimal Proxy (EIP-1167) that routes to BridgePool implementation
+     */
+    // solhint-disable-next-line
+    fallback() external {
+        address implementation_ = _implementation;
+        assembly {
+            let ptr := mload(0x40)
+            mstore(ptr, shl(176, 0x363d3d373d3d3d363d73)) //10
+            mstore(add(ptr, 10), shl(96, implementation_)) //20
+            mstore(add(ptr, 30), shl(136, 0x5af43d82803e903d91602b57fd5bf3)) //15
+            return(ptr, 45)
+        }
+    }
+
+    function _deployPoolLogic(
+        uint8 tokenType_,
+        uint256 chainId_,
+        uint16 version_,
+        uint256 value_,
+        bytes calldata deployCode_
+    ) internal returns (address) {
+        address addr;
+        uint32 codeSize;
+        bool native = true;
+        if (chainId_ != _chainID) {
+            native = false;
+        }
+        assembly {
+            let ptr := mload(0x40)
+            calldatacopy(ptr, deployCode_.offset, deployCode_.length)
+            addr := create(value_, ptr, deployCode_.length)
+            codeSize := extcodesize(addr)
+        }
+        if (codeSize == 0) {
+            revert BridgePoolFactoryErrors.FailedToDeployLogic();
+        }
+
+        _logicAddresses[_getImplementationAddressKey(tokenType_, version_, native)] = addr;
+        return addr;
+    }
+
+    /**
+     * @dev enables or disables public pool deployment
+     **/
+    function _togglePublicPoolDeployment() internal {
+        publicPoolDeploymentEnabled = !publicPoolDeploymentEnabled;
+    }
+
+    /**
+     * @notice Deploys a new bridge to pass tokens to layer 2 chain from the specified ERC contract.
+     * The pools are created as thin proxies (EIP1167) routing to versioned implementations identified by correspondent salt.
+     * @param tokenType_ type of token (0=ERC20, 1=ERC721, 2=ERC1155)
+     * @param ercContract_ address of ERC20 source token contract
+     * @param poolVersion_ version of BridgePool implementation to use
+     */
+    function _deployNewNativePool(
+        uint8 tokenType_,
+        address ercContract_,
+        uint16 poolVersion_
+    ) internal {
+        bool native = true;
+        //calculate the unique salt for the bridge pool
+        bytes32 bridgePoolSalt = BridgePoolAddressUtil.getBridgePoolSalt(
+            ercContract_,
+            tokenType_,
+            _chainID,
+            poolVersion_
+        );
+        //calculate the address of the pool's logic contract
+        address implementation = _logicAddresses[
+            _getImplementationAddressKey(tokenType_, poolVersion_, native)
+        ];
+        _implementation = implementation;
+        //check if the logic exists for the specified pool
+        //TODO determin if this step is still necessary
+        uint256 implementationSize;
+        assembly {
+            implementationSize := extcodesize(implementation)
+        }
+        if (implementationSize == 0) {
+            revert BridgePoolFactoryErrors.PoolVersionNotSupported(poolVersion_);
+        }
+        address contractAddr = _deployStaticPool(bridgePoolSalt);
+        IBridgePool(contractAddr).initialize(ercContract_);
+        emit BridgePoolCreated(contractAddr, ercContract_);
+    }
+
+    /**
+     * @notice creates a BridgePool contract with specific salt and bytecode returned by this contract fallback
+     * @param salt_ salt of the implementation contract
+     * @return contractAddr the address of the BridgePool
+     */
+    function _deployStaticPool(bytes32 salt_) internal returns (address contractAddr) {
+        uint256 contractSize;
+        assembly {
+            let ptr := mload(0x40)
+            mstore(ptr, shl(136, 0x5880818283335afa3d82833e3d82f3))
+            contractAddr := create2(0, ptr, 15, salt_)
+            contractSize := extcodesize(contractAddr)
+        }
+        if (contractSize == 0) {
+            revert BridgePoolFactoryErrors.StaticPoolDeploymentFailed(salt_);
+        }
+        return contractAddr;
+    }
+
+    /**
+     * @notice calculates salt for a BridgePool implementation contract based on tokenType and version
+     * @param tokenType_ type of token (0=ERC20, 1=ERC721, 2=ERC1155)
+     * @param version_ version of the implementation
+     * @param native_ boolean flag to specifier native or external token pools
+     * @return calculated key
+     */
+    function _getImplementationAddressKey(
+        uint8 tokenType_,
+        uint16 version_,
+        bool native_
+    ) internal pure returns (string memory) {
+        string memory key;
+        if (native_) {
+            key = "Native";
+        } else {
+            key = "External";
+        }
+        if (tokenType_ == uint8(TokenType.ERC20)) {
+            key = string.concat(key, "ERC20");
+        } else if (tokenType_ == uint8(TokenType.ERC721)) {
+            key = string.concat(key, "ERC721");
+        } else if (tokenType_ == uint8(TokenType.ERC1155)) {
+            key = string.concat(key, "ERC1155");
+        }
+        key = string.concat(key, "V", Strings.toString(version_));
+        return key;
+    }
+}

bridge/contracts/utils/BridgePoolAddressUtil.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT-open-group
+pragma solidity ^0.8.16;
+
+library BridgePoolAddressUtil {
+    enum TokenType {
+        ERC20,
+        ERC721,
+        ERC1155
+    }
+
+    /**
+     * @notice calculates salt for a BridgePool contract based on ERC contract's address, tokenType, chainID and version_
+     * @param tokenContractAddr_ address of ERC contract of BridgePool
+     * @param tokenType_ type of token (0=ERC20, 1=ERC721, 2=ERC1155)
+     * @param version_ version of the implementation
+     * @param chainID_ chain ID
+     * @return calculated calculated salt
+     */
+    function getBridgePoolSalt(
+        address tokenContractAddr_,
+        uint8 tokenType_,
+        uint256 chainID_,
+        uint16 version_
+    ) internal pure returns (bytes32) {
+        return
+            keccak256(
+                bytes.concat(
+                    keccak256(abi.encodePacked(tokenContractAddr_)),
+                    keccak256(abi.encodePacked(tokenType_)),
+                    keccak256(abi.encodePacked(chainID_)),
+                    keccak256(abi.encodePacked(version_))
+                )
+            );
+    }
+
+    function getBridgePoolAddress(bytes32 bridgePoolSalt_, address bridgeFactory_)
+        internal
+        pure
+        returns (address)
+    {
+        // works: 5880818283335afa3d82833e3d82f3
+        bytes32 initCodeHash = 0xf231e946a2f88d89eafa7b43271c54f58277304b93ac77d138d9b0bb3a989b6d;
+        return
+            address(
+                uint160(
+                    uint256(
+                        keccak256(
+                            abi.encodePacked(hex"ff", bridgeFactory_, bridgePoolSalt_, initCodeHash)
+                        )
+                    )
+                )
+            );
+    }
+}