Bridging

brownie-config.yaml

@@ -36,7 +36,7 @@ networks:
 compiler:
     evm_version: shanghai
     solc:
-        version: null
+        version: 0.8.26
         optimizer:
             enabled: true
             runs: 200

contracts/airdrop/MerkleAirdrop.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.26;
+
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "contracts/token/LinearVestingWithPenalty.sol";
+import "contracts/farm/SophonFarmingL2.sol";
+
+contract MerkleAirdrop is Initializable, AccessControlUpgradeable, UUPSUpgradeable {
+    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
+    SophonFarmingL2 public SF_L2;
+    bytes32 public merkleRoot;
+
+    // Changed mapping to track claims per user per PID
+    mapping(address => mapping(uint256 => bool)) public hasClaimed;
+
+
+    event Claimed(address indexed account, uint256 pid);
+    event MerkleRootUpdated(bytes32 newMerkleRoot);
+
+    error AlreadyClaimed();
+    error InvalidMerkleProof();
+    error NotAuthorized();
+    error InvalidInputLengths();
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(address _SF_L2) public initializer {
+        SF_L2 = SophonFarmingL2(_SF_L2);
+
+        __AccessControl_init();
+        __UUPSUpgradeable_init();
+
+        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
+        _grantRole(ADMIN_ROLE, msg.sender);
+    }
+
+    /**
+     * @dev Sets the Merkle root for the airdrop.
+     * @param _merkleRoot The new Merkle root.
+     */
+    function setMerkleRoot(bytes32 _merkleRoot) external onlyRole(ADMIN_ROLE) {
+        merkleRoot = _merkleRoot;
+        emit MerkleRootUpdated(_merkleRoot);
+    }
+
+
+    function claim(address _user, address _customReceiver, uint256 _pid, SophonFarmingState.UserInfo memory _userInfo, bytes32[] calldata _merkleProof) external onlyRole(ADMIN_ROLE) {
+        _claim(_user, _customReceiver, _pid, _userInfo, _merkleProof);
+    }
+
+    /**
+     * @dev Allows users to claim their tokens if they are part of the Merkle tree.
+     * @param _user The address of the user that is participating.
+     * @param _pid The pool ID that the user is participating in.
+     * @param _userInfo The `UserInfo` struct containing the user's info.
+     * @param _merkleProof The Merkle proof to verify the user's inclusion in the tree.
+     */
+    function claim(address _user, uint256 _pid, SophonFarmingState.UserInfo memory _userInfo, bytes32[] calldata _merkleProof) external {
+        if (msg.sender != _user) revert NotAuthorized();
+        _claim(_user, _user, _pid, _userInfo, _merkleProof);
+    }
+
+    /**
+    * @dev Allows users to claim multiple tokens if they are part of the Merkle tree.
+    * @param _user The address of the user that is participating.
+    * @param _pids An array of pool IDs that the user is participating in.
+    * @param _userInfos An array of `UserInfo` structs containing the user's info for each pool.
+    * @param _merkleProofs An array of Merkle proofs to verify the user's inclusion in the tree for each pool.
+    */
+    function claimMultiple(
+        address _user,
+        uint256[] calldata _pids,
+        SophonFarmingState.UserInfo[] calldata _userInfos,
+        bytes32[][] calldata _merkleProofs
+    ) external {
+        if (msg.sender != _user) revert NotAuthorized();
+        if (_pids.length != _userInfos.length || _userInfos.length != _merkleProofs.length) revert InvalidInputLengths();
+
+        for (uint256 i = 0; i < _pids.length; i++) {
+            _claim(_user, _user, _pids[i], _userInfos[i], _merkleProofs[i]);
+        }
+    }
+
+    // TODO add index
+    function _claim(address _user, address _customReceiver, uint256 _pid, SophonFarmingState.UserInfo memory _userInfo, bytes32[] calldata _merkleProof) internal {
+        if (hasClaimed[_user][_pid]) revert AlreadyClaimed();
+
+        // Verify the Merkle proof.
+        bytes32 leaf = keccak256(abi.encodePacked(_user, _pid, _userInfo.amount, _userInfo.boostAmount, _userInfo.depositAmount, _userInfo.rewardSettled, _userInfo.rewardDebt));
+        if (!MerkleProof.verify(_merkleProof, merkleRoot, leaf)) revert InvalidMerkleProof();
+
+        // Mark it claimed and transfer the tokens.
+        hasClaimed[_user][_pid] = true;
+
+        _userInfo.rewardSettled = 0;
+        SF_L2.updateUserInfo(_customReceiver, _pid, _userInfo);
+        emit Claimed(_user, _pid);
+    }
+
+    /**
+     * @dev Allows the recovery of any ERC20 tokens sent to the contract by mistake.
+     * @param token The address of the token to recover.
+     * @param to The address to send the recovered tokens to.
+     */
+    function rescue(IERC20 token, address to) external onlyRole(ADMIN_ROLE) {
+        SafeERC20.safeTransfer(token, to, token.balanceOf(address(this)));
+    }
+
+    /**
+     * @dev Required by UUPSUpgradeable to authorize upgrades.
+     * @param newImplementation The address of the new implementation.
+     */
+    function _authorizeUpgrade(address newImplementation) internal override onlyRole(ADMIN_ROLE) {}
+}

contracts/farm/SophonFarming.sol

@@ -13,6 +13,7 @@ import "./interfaces/IeETHLiquidityPool.sol";
 import "./interfaces/IweETH.sol";
 import "../proxies/Upgradeable2Step.sol";
 import "./SophonFarmingState.sol";
+import 'contracts/interfaces/uniswap/IUniswapV2Router02.sol';
 
 /**
  * @title Sophon Farming Contract
@@ -42,9 +43,6 @@ contract SophonFarming is Upgradeable2Step, SophonFarmingState {
     /// @notice Emitted when all pool funds are bridged to Sophon blockchain
     event BridgePool(address indexed user, uint256 indexed pid, uint256 amount);
 
-    /// @notice Emitted when the admin bridges booster proceeds
-    event BridgeProceeds(uint256 indexed pid, uint256 proceeds);
-
     /// @notice Emitted when the the revertFailedBridge function is called
     event RevertFailedBridge(uint256 indexed pid);
 
@@ -85,13 +83,16 @@ contract SophonFarming is Upgradeable2Step, SophonFarmingState {
     address public immutable eETH;
     address public immutable eETHLiquidityPool;
     address public immutable weETH;
+    uint256 public immutable CHAINID;
+    uint256 internal constant BEAM_WEHT_PID = 4;
+    address internal constant PENDLE_EXCEPTION = 0x065347C1Dd7A23Aa043e3844B4D0746ff7715246;
 
     /**
      * @notice Construct SophonFarming
      * @param tokens_ Immutable token addresses
      * @dev 0:dai, 1:sDAI, 2:weth, 3:stETH, 4:wstETH, 5:eETH, 6:eETHLiquidityPool, 7:weETH
      */
-    constructor(address[8] memory tokens_) {
+    constructor(address[8] memory tokens_, uint256 _CHAINID) {
         dai = tokens_[0];
         sDAI = tokens_[1];
         weth = tokens_[2];
@@ -100,6 +101,7 @@ contract SophonFarming is Upgradeable2Step, SophonFarmingState {
         eETH = tokens_[5];
         eETHLiquidityPool = tokens_[6];
         weETH = tokens_[7];
+        CHAINID = _CHAINID;
     }
 
     /**
@@ -286,7 +288,7 @@ contract SophonFarming is Upgradeable2Step, SophonFarmingState {
         if (_bridge == address(0)) {
             revert ZeroAddress();
         }
-        bridge = BridgeLike(_bridge);
+        bridge = IBridgehub(_bridge);
     }
 
     /**
@@ -332,7 +334,7 @@ contract SophonFarming is Upgradeable2Step, SophonFarmingState {
      * @notice Set points per block
      * @param _pointsPerBlock points per block to set
      */
-    function setPointsPerBlock(uint256 _pointsPerBlock) public onlyOwner {
+    function setPointsPerBlock(uint256 _pointsPerBlock) virtual public onlyOwner {
         if (isFarmingEnded()) {
             revert FarmingIsEnded();
         }
@@ -348,7 +350,7 @@ contract SophonFarming is Upgradeable2Step, SophonFarmingState {
      * @notice Set booster multiplier
      * @param _boosterMultiplier booster multiplier to set
      */
-    function setBoosterMultiplier(uint256 _boosterMultiplier) external onlyOwner {
+    function setBoosterMultiplier(uint256 _boosterMultiplier) virtual external onlyOwner {
         if (_boosterMultiplier < 1e18 || _boosterMultiplier > 10e18) {
             revert InvalidBooster();
         }
@@ -808,14 +810,23 @@ contract SophonFarming is Upgradeable2Step, SophonFarmingState {
         emit Withdraw(msg.sender, _pid, _withdrawAmount);
     }
 
+
     /**
      * @notice Permissionless function to allow anyone to bridge during the correct period
      * @param _pid pid to bridge
-     * @param _l2TxGasLimit l2TxGasLimit for the bridge txn
-     * @param _l2TxGasPerPubdataByte l2TxGasPerPubdataByte for the bridge txn
+     * @param _mintValue _mintValue SOPH gas price
      */
-    function bridgePool(uint256 _pid, uint256 _l2TxGasLimit, uint256 _l2TxGasPerPubdataByte) external payable {
-        revert Unauthorized(); // NOTE: function not fully implemented, an upgrade will implement this later
+
+    function bridgePool(uint256 _pid, uint256 _mintValue, address _sophToken) external payable {
+        // USDC exception
+        if (_pid == 7) {
+            revert Unauthorized();
+        }
+
+        _bridgePool(_pid, _mintValue, _sophToken, bridge);
+    }
+
+    function _bridgePool(uint256 _pid, uint256 _mintValue, address _sophToken, IBridgehub _bridge) internal {
 
         if (!isFarmingEnded() || !isWithdrawPeriodEnded() || isBridged[_pid]) {
             revert Unauthorized();
@@ -824,41 +835,105 @@ contract SophonFarming is Upgradeable2Step, SophonFarmingState {
         updatePool(_pid);
         PoolInfo storage pool = poolInfo[_pid];
 
-        uint256 depositAmount = pool.depositAmount;
-        if (depositAmount == 0 || address(bridge) == address(0) || pool.l2Farm == address(0)) {
+        if (pool.depositAmount == 0 || address(bridge) == address(0) || pool.l2Farm == address(0)) {
             revert BridgeInvalid();
         }
+        uint256 depositAmount = IERC20(pool.lpToken).balanceOf(address(this));
 
-        isBridged[_pid] = true;
-
-        IERC20 lpToken = pool.lpToken;
-        lpToken.approve(address(bridge), depositAmount);
+        if (_pid == BEAM_WEHT_PID) {
+            UserInfo storage user = userInfo[BEAM_WEHT_PID][PENDLE_EXCEPTION];
+            depositAmount -= user.depositAmount - user.boostAmount / boosterMultiplier;
+        }
 
+        L2TransactionRequestTwoBridgesOuter memory _request = L2TransactionRequestTwoBridgesOuter({
+            chainId: CHAINID,
+            mintValue: _mintValue,
+            l2Value: 0,
+            l2GasLimit: 2000000,
+            l2GasPerPubdataByteLimit: 800,
+            refundRecipient: address(this),
+            secondBridgeAddress: address(bridge.sharedBridge()),
+            secondBridgeValue: 0,
+            secondBridgeCalldata: abi.encode(pool.lpToken, depositAmount, pool.l2Farm)
+        });
+
+        if (pool.lpToken.allowance(address(this), _request.secondBridgeAddress) < depositAmount) {
+            pool.lpToken.safeIncreaseAllowance(_request.secondBridgeAddress, type(uint256).max);
+        }
+        IERC20(_sophToken).safeTransferFrom(msg.sender, address(this), _mintValue);
+        IERC20(_sophToken).safeIncreaseAllowance(_request.secondBridgeAddress, _mintValue);
+
         // Actual values are pending the launch of Sophon testnet
-        bridge.deposit{value: msg.value}(
-            pool.l2Farm,            // _l2Receiver
-            address(lpToken),       // _l1Token
-            depositAmount,          // _amount
-            _l2TxGasLimit,          // _l2TxGasLimit
-            _l2TxGasPerPubdataByte, // _l2TxGasPerPubdataByte
-            owner()                 // _refundRecipient
-        );
+        _bridge.requestL2TransactionTwoBridges(_request);
 
+        isBridged[_pid] = true;
         emit BridgePool(msg.sender, _pid, depositAmount);
     }
 
-    // TODO: does this function need to call claimFailedDeposit on the bridge?
-    // This is pending the launch of Sophon testnet
+
+    // bridge USDC
+    function bridgeUSDC(uint256 _mintValue, address _sophToken, IBridgehub _bridge) external onlyOwner {
+        uint256 _pid = 7;
+        if (!isFarmingEnded() || !isWithdrawPeriodEnded() || isBridged[_pid]) {
+            revert Unauthorized();
+        }
+
+        // IBridgehub _bridge = IBridgehub(address(0));
+        _bridgePool(_pid, _mintValue, _sophToken, _bridge);
+
+    }
+
+    /**
+     * @notice Set L2Farming contract for particular pool
+     * @param _pid pid to bridge
+     * @param _l2Farm address of the contract for farming on L2 side
+     */
+    function setL2Farm(uint256 _pid, address _l2Farm) external onlyOwner {
+        if (_pid >= poolInfo.length) {
+            revert PoolExists();
+        }
+
+        if (_l2Farm == address(0)) {
+            revert ZeroAddress();
+        }
+
+        poolInfo[_pid].l2Farm = _l2Farm;
+    }
+
+
     /**
      * @notice Called by an admin if a bridge process to Sophon fails
      * @param _pid pid of the failed bridge to revert
      */
-    function revertFailedBridge(uint256 _pid) external onlyOwner {
-        revert Unauthorized(); // NOTE: function not fully implemented, an upgrade will implement this later
+    function revertFailedBridge(
+        address _l1SharedBridge,
+        uint256 _pid,       
+        uint256 _chainId,
+        address _depositSender,
+        address _l1Token,
+        uint256 _amount,
+        bytes32 _l2TxHash,
+        uint256 _l2BatchNumber,
+        uint256 _l2MessageIndex,
+        uint16 _l2TxNumberInBatch,
+        bytes32[] calldata _merkleProof) external onlyOwner {
 
         if (address(poolInfo[_pid].lpToken) == address(0)) {
             revert PoolDoesNotExist();
         }
+
+        IL1SharedBridge(_l1SharedBridge).claimFailedDeposit(
+            _chainId,
+            _depositSender,
+            _l1Token,
+            _amount,
+            _l2TxHash,
+            _l2BatchNumber,
+            _l2MessageIndex,
+            _l2TxNumberInBatch,
+            _merkleProof
+        );
+
         isBridged[_pid] = false;
         emit RevertFailedBridge(_pid);
     }
@@ -998,23 +1073,6 @@ contract SophonFarming is Upgradeable2Step, SophonFarmingState {
         return IsDAI(sDAI).deposit(_amount, address(this));
     }
 
-    // This is pending the launch of Sophon testnet
-    /**
-     * @notice Allows an admin to bridge booster proceeds
-     * @param _pid pid to bridge proceeds from
-     * @param _l2TxGasLimit l2TxGasLimit for the bridge txn
-     * @param _l2TxGasPerPubdataByte l2TxGasPerPubdataByte for the bridge txn
-     */
-    function bridgeProceeds(uint256 _pid, uint256 _l2TxGasLimit, uint256 _l2TxGasPerPubdataByte) external payable onlyOwner {
-        revert Unauthorized(); // NOTE: function not fully implemented, an upgrade will implement this later
-
-        uint256 _proceeds = heldProceeds[_pid];
-        heldProceeds[_pid] = 0;
-
-        // TODO: add bridging logic
-
-        emit BridgeProceeds(_pid, _proceeds);
-    }
 
     /**
      * @notice Returns the current block number