feat: yield bearing bridge

README.md

@@ -22,3 +22,4 @@ Check [this doc](./docs/deployment.md) for instructions on deployment and verifi
 Discord: [Arbitrum](https://discord.com/invite/5KE54JwyTs)
 
 Twitter: [Arbitrum](https://twitter.com/arbitrum)
+

contracts/tokenbridge/arbitrum/L2AtomicTokenBridgeFactory.sol

@@ -305,6 +305,7 @@ library OrbitSalts {
     bytes internal constant L1_STANDARD_GATEWAY = bytes("L1SGW");
     bytes internal constant L1_CUSTOM_GATEWAY = bytes("L1CGW");
     bytes internal constant L1_WETH_GATEWAY = bytes("L1WGW");
+    bytes internal constant L1_MASTER_VAULT_FACTORY = bytes("L1MVF");
 
     bytes internal constant L2_PROXY_ADMIN = bytes("L2PA");
     bytes internal constant L2_ROUTER = bytes("L2R");

contracts/tokenbridge/ethereum/L1GatewayDeployer.sol

@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.4;
+
+import {L1ERC20Gateway} from "./gateway/L1ERC20Gateway.sol";
+import {L1CustomGateway} from "./gateway/L1CustomGateway.sol";
+import {L1WethGateway} from "./gateway/L1WethGateway.sol";
+import {L1OrbitERC20Gateway} from "./gateway/L1OrbitERC20Gateway.sol";
+import {L1OrbitCustomGateway} from "./gateway/L1OrbitCustomGateway.sol";
+import {L1YbbERC20Gateway} from "./gateway/L1YbbERC20Gateway.sol";
+import {L1YbbCustomGateway} from "./gateway/L1YbbCustomGateway.sol";
+import {L1OrbitYbbERC20Gateway} from "./gateway/L1OrbitYbbERC20Gateway.sol";
+import {L1OrbitYbbCustomGateway} from "./gateway/L1OrbitYbbCustomGateway.sol";
+import {IMasterVaultFactory} from "../libraries/vault/IMasterVaultFactory.sol";
+import {IGatewayRouter} from "../libraries/gateway/IGatewayRouter.sol";
+import {ClonableBeaconProxy} from "../libraries/ClonableBeaconProxy.sol";
+import {
+    TransparentUpgradeableProxy
+} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+
+/**
+ * @title L1GatewayDeployer
+ * @notice Library for deploying all L1 gateway components (standard, custom, WETH, and YBB)
+ */
+library L1GatewayDeployer {
+    // ============ Standard Gateway Structs ============
+
+    struct StandardDeploymentParams {
+        address inbox;
+        address proxyAdmin;
+        address upgradeExecutor;
+        address router;
+        address l2StandardGateway;
+        address l2CustomGateway;
+        address l2BeaconProxyFactory;
+        bool isFeeTokenBased;
+    }
+
+    struct StandardTemplates {
+        address standardGatewayTemplate;
+        address feeTokenBasedStandardGatewayTemplate;
+        address customGatewayTemplate;
+        address feeTokenBasedCustomGatewayTemplate;
+    }
+
+    struct StandardDeploymentResult {
+        address standardGateway;
+        address customGateway;
+    }
+
+    // ============ WETH Gateway Structs ============
+
+    struct WethDeploymentParams {
+        address inbox;
+        address proxyAdmin;
+        address router;
+        address l2WethGateway;
+        address l1Weth;
+        address l2Weth;
+    }
+
+    struct WethDeploymentResult {
+        address wethGateway;
+    }
+
+    // ============ YBB Gateway Structs ============
+
+    struct YbbDeploymentParams {
+        address inbox;
+        address proxyAdmin;
+        address upgradeExecutor;
+        address router;
+        address l2StandardGateway;
+        address l2CustomGateway;
+        address l2BeaconProxyFactory;
+        bool isFeeTokenBased;
+    }
+
+    struct YbbTemplates {
+        address ybbStandardGatewayTemplate;
+        address ybbCustomGatewayTemplate;
+        address feeTokenBasedYbbStandardGatewayTemplate;
+        address feeTokenBasedYbbCustomGatewayTemplate;
+        address masterVaultFactoryTemplate;
+    }
+
+    struct YbbDeploymentResult {
+        address masterVaultFactory;
+        address standardGateway;
+        address customGateway;
+    }
+
+    // ============ Standard Gateway Deployment ============
+
+    function deployStandardGateways(
+        StandardDeploymentParams memory params,
+        StandardTemplates memory templates,
+        bytes32 standardGatewaySalt,
+        bytes32 customGatewaySalt
+    ) external returns (StandardDeploymentResult memory result) {
+        {
+            address template = params.isFeeTokenBased
+                ? templates.feeTokenBasedStandardGatewayTemplate
+                : templates.standardGatewayTemplate;
+
+            result.standardGateway = _deployProxy(standardGatewaySalt, template, params.proxyAdmin);
+
+            L1ERC20Gateway(result.standardGateway)
+                .initialize(
+                    params.l2StandardGateway,
+                    params.router,
+                    params.inbox,
+                    keccak256(type(ClonableBeaconProxy).creationCode),
+                    params.l2BeaconProxyFactory
+                );
+        }
+
+        {
+            address template = params.isFeeTokenBased
+                ? templates.feeTokenBasedCustomGatewayTemplate
+                : templates.customGatewayTemplate;
+
+            result.customGateway = _deployProxy(customGatewaySalt, template, params.proxyAdmin);
+
+            L1CustomGateway(result.customGateway)
+                .initialize(
+                    params.l2CustomGateway, params.router, params.inbox, params.upgradeExecutor
+                );
+        }
+
+        return result;
+    }
+
+    // ============ WETH Gateway Deployment ============
+
+    function deployWethGateway(
+        WethDeploymentParams memory params,
+        address wethGatewayTemplate,
+        bytes32 wethGatewaySalt
+    ) external returns (WethDeploymentResult memory result) {
+        result.wethGateway = _deployProxy(wethGatewaySalt, wethGatewayTemplate, params.proxyAdmin);
+
+        L1WethGateway(payable(result.wethGateway))
+            .initialize(
+                params.l2WethGateway, params.router, params.inbox, params.l1Weth, params.l2Weth
+            );
+
+        return result;
+    }
+
+    // ============ YBB Gateway Deployment ============
+
+    function deployYbbGateways(
+        YbbDeploymentParams memory params,
+        YbbTemplates memory templates,
+        bytes32 masterVaultSalt,
+        bytes32 standardGatewaySalt,
+        bytes32 customGatewaySalt
+    ) external returns (YbbDeploymentResult memory result) {
+        result.masterVaultFactory = _deployProxy(
+            masterVaultSalt, templates.masterVaultFactoryTemplate, params.proxyAdmin
+        );
+
+        {
+            address template = params.isFeeTokenBased
+                ? templates.feeTokenBasedYbbStandardGatewayTemplate
+                : templates.ybbStandardGatewayTemplate;
+
+            result.standardGateway = _deployProxy(standardGatewaySalt, template, params.proxyAdmin);
+
+            L1YbbERC20Gateway(result.standardGateway)
+                .initialize(
+                    params.l2StandardGateway,
+                    params.router,
+                    params.inbox,
+                    keccak256(type(ClonableBeaconProxy).creationCode),
+                    params.l2BeaconProxyFactory,
+                    result.masterVaultFactory
+                );
+        }
+
+        {
+            address template = params.isFeeTokenBased
+                ? templates.feeTokenBasedYbbCustomGatewayTemplate
+                : templates.ybbCustomGatewayTemplate;
+
+            result.customGateway = _deployProxy(customGatewaySalt, template, params.proxyAdmin);
+
+            L1YbbCustomGateway(result.customGateway)
+                .initialize(
+                    params.l2CustomGateway,
+                    params.router,
+                    params.inbox,
+                    params.upgradeExecutor,
+                    result.masterVaultFactory
+                );
+        }
+
+        return result;
+    }
+
+    function initializeMasterVaultFactory(
+        address masterVaultFactory,
+        address masterVaultImplementation,
+        address admin,
+        address router
+    ) external {
+        IMasterVaultFactory(masterVaultFactory)
+            .initialize(masterVaultImplementation, admin, IGatewayRouter(router));
+    }
+
+    // ============ Internal ============
+
+    function _deployProxy(bytes32 salt, address logic, address admin) internal returns (address) {
+        return address(new TransparentUpgradeableProxy{salt: salt}(logic, admin, bytes("")));
+    }
+}

contracts/tokenbridge/ethereum/gateway/L1ERC20Gateway.sol

@@ -129,7 +129,7 @@ contract L1ERC20Gateway is L1ArbitrumExtendedGateway {
         address _to,
         uint256 _amount,
         bytes memory _data
-    ) public view override returns (bytes memory outboundCalldata) {
+    ) public view virtual override returns (bytes memory outboundCalldata) {
         // TODO: cheaper to make static calls or save isDeployed to storage?
         bytes memory deployData = abi.encode(
             callStatic(_token, ERC20.name.selector),

contracts/tokenbridge/ethereum/gateway/L1OrbitYbbCustomGateway.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.8.0;
+
+import {L1OrbitCustomGateway} from "./L1OrbitCustomGateway.sol";
+import {L1CustomGateway} from "./L1CustomGateway.sol";
+import {IMasterVault} from "../../libraries/vault/IMasterVault.sol";
+import {IMasterVaultFactory} from "../../libraries/vault/IMasterVaultFactory.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+/**
+ * @title Layer 1 Gateway contract for bridging Custom ERC20s with YBB enabled in ERC20-based rollup
+ * @notice Escrows funds into MasterVaults for yield bearing bridging.
+ */
+contract L1OrbitYbbCustomGateway is L1OrbitCustomGateway {
+    using SafeERC20 for IERC20;
+
+    /// @notice Address of the MasterVaultFactory contract
+    address public masterVaultFactory;
+
+    function initialize(
+        address _l1Counterpart,
+        address _l1Router,
+        address _inbox,
+        address _owner,
+        address _masterVaultFactory
+    ) public virtual {
+        L1CustomGateway.initialize(_l1Counterpart, _l1Router, _inbox, _owner);
+        _setMasterVaultFactory(_masterVaultFactory);
+    }
+
+    function inboundEscrowTransfer(address _l1Token, address _dest, uint256 _amount)
+        internal
+        override
+    {
+        address masterVault = IMasterVaultFactory(masterVaultFactory).getVault(_l1Token);
+        IERC20(masterVault).safeTransfer(_dest, _amount);
+    }
+
+    function outboundEscrowTransfer(address _l1Token, address _from, uint256 _amount)
+        internal
+        override
+        returns (uint256 amountReceived)
+    {
+        uint256 prevBalance = IERC20(_l1Token).balanceOf(address(this));
+        IERC20(_l1Token).safeTransferFrom(_from, address(this), _amount);
+        uint256 postBalance = IERC20(_l1Token).balanceOf(address(this));
+        amountReceived = postBalance - prevBalance;
+
+        address masterVault = IMasterVaultFactory(masterVaultFactory).getVault(_l1Token);
+        IERC20(_l1Token).safeIncreaseAllowance(masterVault, amountReceived);
+        amountReceived = IMasterVault(masterVault).deposit(amountReceived);
+        require(amountReceived > 0, "ZERO_SHARES");
+    }
+
+    function _setMasterVaultFactory(address _masterVaultFactory) internal {
+        require(_masterVaultFactory != address(0), "BAD_MASTER_VAULT_FACTORY");
+        masterVaultFactory = _masterVaultFactory;
+    }
+}

contracts/tokenbridge/ethereum/gateway/L1OrbitYbbERC20Gateway.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.8.0;
+
+import {L1OrbitERC20Gateway} from "./L1OrbitERC20Gateway.sol";
+import {L1ERC20Gateway} from "./L1ERC20Gateway.sol";
+import {IMasterVault} from "../../libraries/vault/IMasterVault.sol";
+import {IMasterVaultFactory} from "../../libraries/vault/IMasterVaultFactory.sol";
+import {IERC20, ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {GatewayMessageHandler} from "../../libraries/gateway/GatewayMessageHandler.sol";
+import {ITokenGateway} from "../../libraries/gateway/ITokenGateway.sol";
+
+/**
+ * @title Layer 1 Gateway contract for bridging standard ERC20s with YBB enabled in ERC20-based rollup
+ * @notice Escrows funds into MasterVaults for yield bearing bridging.
+ */
+contract L1OrbitYbbERC20Gateway is L1OrbitERC20Gateway {
+    using SafeERC20 for IERC20;
+
+    /// @notice Address of the MasterVaultFactory contract
+    address public masterVaultFactory;
+
+    function initialize(
+        address _l2Counterpart,
+        address _router,
+        address _inbox,
+        bytes32 _cloneableProxyHash,
+        address _l2BeaconProxyFactory,
+        address _masterVaultFactory
+    ) public {
+        L1ERC20Gateway.initialize(
+            _l2Counterpart, _router, _inbox, _cloneableProxyHash, _l2BeaconProxyFactory
+        );
+        _setMasterVaultFactory(_masterVaultFactory);
+    }
+
+    function inboundEscrowTransfer(address _l1Token, address _dest, uint256 _amount)
+        internal
+        override
+    {
+        address masterVault = IMasterVaultFactory(masterVaultFactory).getVault(_l1Token);
+        IERC20(masterVault).safeTransfer(_dest, _amount);
+    }
+
+    function outboundEscrowTransfer(address _l1Token, address _from, uint256 _amount)
+        internal
+        override
+        returns (uint256 amountReceived)
+    {
+        uint256 prevBalance = IERC20(_l1Token).balanceOf(address(this));
+        IERC20(_l1Token).safeTransferFrom(_from, address(this), _amount);
+        uint256 postBalance = IERC20(_l1Token).balanceOf(address(this));
+        amountReceived = postBalance - prevBalance;
+
+        address masterVault = IMasterVaultFactory(masterVaultFactory).getVault(_l1Token);
+        IERC20(_l1Token).safeIncreaseAllowance(masterVault, amountReceived);
+        amountReceived = IMasterVault(masterVault).deposit(amountReceived);
+        require(amountReceived > 0, "ZERO_SHARES");
+    }
+
+    function getOutboundCalldata(
+        address _token,
+        address _from,
+        address _to,
+        uint256 _amount,
+        bytes memory _data
+    ) public view override returns (bytes memory outboundCalldata) {
+        address vault = IMasterVaultFactory(masterVaultFactory).calculateVaultAddress(_token);
+
+        bytes memory deployData = abi.encode(
+            callStatic(_token, ERC20.name.selector),
+            callStatic(_token, ERC20.symbol.selector),
+            callStatic(vault, ERC20.decimals.selector)
+        );
+
+        outboundCalldata = abi.encodeWithSelector(
+            ITokenGateway.finalizeInboundTransfer.selector,
+            _token,
+            _from,
+            _to,
+            _amount,
+            GatewayMessageHandler.encodeToL2GatewayMsg(deployData, _data)
+        );
+    }
+
+    function _setMasterVaultFactory(address _masterVaultFactory) internal {
+        require(_masterVaultFactory != address(0), "BAD_MASTER_VAULT_FACTORY");
+        masterVaultFactory = _masterVaultFactory;
+    }
+}