chore: cross chain struct implementation

contracts/cross-chain/BridgeDefine.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+enum MessageType {
+    AddNewCrossChainERC721,
+    BridgeERC721,
+    ERC721DELEGATION
+}
+
+struct BridgeMessage {
+    MessageType msgType;
+    bytes data;
+}
+
+struct BridgeERC721Message {
+    address asset;
+    uint256[] tokenIds;
+    address receiver;
+}
+
+struct ERC721DelegationMessage {
+    address asset;
+    address delegateTo;
+    uint256[] tokenIds;
+    bool value;
+}
+
+//library BridgeDefine {
+//
+//
+//}

contracts/cross-chain/L1/IParaxBridgeNFTVault.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {BridgeERC721Message, ERC721DelegationMessage} from "../BridgeDefine.sol";
+
+interface IParaxBridgeNFTVault {
+    function releaseNFT(BridgeERC721Message calldata message) external;
+
+    function updateTokenDelegation(
+        ERC721DelegationMessage calldata delegationInfo
+    ) external;
+}

contracts/cross-chain/L1/IParaxL1MessageHandler.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {MessageType, BridgeMessage, BridgeERC721Message} from "../BridgeDefine.sol";
+
+interface IParaxL1MessageHandler {
+    function addBridgeAsset(address asset) external;
+
+    function bridgeAsset(BridgeERC721Message calldata message) external;
+}

contracts/cross-chain/L1/ParaxBridgeNFTVault.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {BridgeERC721Message, ERC721DelegationMessage} from "../BridgeDefine.sol";
+import {IERC721} from "../../dependencies/openzeppelin/contracts/IERC721.sol";
+import {Errors} from "../../protocol/libraries/helpers/Errors.sol";
+import "../../dependencies/openzeppelin/upgradeability/Initializable.sol";
+import "../../dependencies/openzeppelin/upgradeability/OwnableUpgradeable.sol";
+import "./IParaxL1MessageHandler.sol";
+import {IDelegateRegistry} from "../../dependencies/delegation/IDelegateRegistry.sol";
+
+contract ParaxBridgeNFTVault is Initializable, OwnableUpgradeable {
+    IParaxL1MessageHandler internal immutable l1MsgHander;
+
+    IDelegateRegistry delegationRegistry;
+
+    mapping(address => bool) supportAsset;
+
+    constructor(IParaxL1MessageHandler msgHandler) {
+        l1MsgHander = msgHandler;
+    }
+
+    modifier onlyMsgHandler() {
+        require(msg.sender == address(l1MsgHander), Errors.ONLY_MSG_HANDLER);
+        _;
+    }
+
+    function addBridgeAsset(address asset) external {
+        require(supportAsset[asset] == false, "asset already added");
+        supportAsset[asset] = true;
+        l1MsgHander.addBridgeAsset(asset);
+    }
+
+    function bridgeAsset(
+        address asset,
+        uint256[] calldata tokenIds,
+        address receiver
+    ) external {
+        require(supportAsset[asset] == true, "asset already added");
+        //lock asset
+        uint256 length = tokenIds.length;
+        for (uint256 index = 0; index < length; index++) {
+            uint256 tokenId = tokenIds[index];
+            IERC721(asset).safeTransferFrom(msg.sender, address(this), tokenId);
+        }
+
+        //send cross chain msg
+        l1MsgHander.bridgeAsset(
+            BridgeERC721Message({
+                asset: asset,
+                tokenIds: tokenIds,
+                receiver: receiver
+            })
+        );
+    }
+
+    function releaseNFT(
+        BridgeERC721Message calldata message
+    ) external onlyMsgHandler {
+        uint256 length = message.tokenIds.length;
+        for (uint256 index = 0; index < length; index++) {
+            uint256 tokenId = message.tokenIds[index];
+            IERC721(message.asset).safeTransferFrom(
+                address(this),
+                message.receiver,
+                tokenId
+            );
+        }
+    }
+
+    function updateTokenDelegation(
+        ERC721DelegationMessage calldata delegationInfo
+    ) external onlyMsgHandler {
+        uint256 length = delegationInfo.tokenIds.length;
+        for (uint256 index = 0; index < length; index++) {
+            uint256 tokenId = delegationInfo.tokenIds[index];
+            delegationRegistry.delegateERC721(
+                delegationInfo.delegateTo,
+                delegationInfo.asset,
+                tokenId,
+                "",
+                delegationInfo.value
+            );
+        }
+    }
+}

contracts/cross-chain/L1/ParaxL1MessageHandler.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+pragma abicoder v2;
+
+import {MessageType, BridgeMessage, BridgeERC721Message} from "../BridgeDefine.sol";
+import {Errors} from "../../protocol/libraries/helpers/Errors.sol";
+import "./IParaxBridgeNFTVault.sol";
+
+contract ParaxL1MessageHandler {
+    IParaxBridgeNFTVault internal immutable nftVault;
+    address immutable bridgeImpl;
+
+    constructor(IParaxBridgeNFTVault vault, address bridge) {
+        nftVault = vault;
+        bridgeImpl = bridge;
+    }
+
+    modifier onlyVault() {
+        require(msg.sender == address(nftVault), Errors.ONLY_VAULT);
+        _;
+    }
+
+    modifier onlyBridge() {
+        require(msg.sender == address(bridgeImpl), Errors.ONLY_BRIDGE);
+        _;
+    }
+
+    function addBridgeAsset(address asset) external onlyVault {}
+
+    function bridgeAsset(
+        BridgeERC721Message calldata message
+    ) external onlyVault {}
+
+    function bridgeReceive(BridgeMessage calldata message) external onlyBridge {
+        if (message.msgType == MessageType.BridgeERC721) {
+            BridgeERC721Message memory message = abi.decode(
+                message.data,
+                (BridgeERC721Message)
+            );
+            nftVault.releaseNFT(message);
+        } else if (message.msgType == MessageType.ERC721DELEGATION) {
+            ERC721DelegationMessage memory message = abi.decode(
+                message.data,
+                (ERC721DelegationMessage)
+            );
+            nftVault.updateTokenDelegation(message);
+        }
+    }
+}

contracts/cross-chain/L2/BridgeERC721.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {ERC721} from "../../dependencies/openzeppelin/contracts/ERC721.sol";
+import {ERC721Enumerable} from "../../dependencies/openzeppelin/contracts/ERC721Enumerable.sol";
+import {Errors} from "../../protocol/libraries/helpers/Errors.sol";
+
+contract BridgeERC21 is ERC721Enumerable {
+    address internal immutable handler;
+
+    modifier onlyHandler() {
+        require(msg.sender == handler, Errors.ONLY_VAULT);
+        _;
+    }
+
+    constructor(
+        string memory name,
+        string memory symbol,
+        address _handler
+    ) ERC721(name, symbol) {
+        handler = _handler;
+    }
+
+    function mint(
+        address to,
+        uint256[] calldata tokenIds
+    ) external onlyHandler {
+        uint256 length = tokenIds.length;
+        for (uint256 index = 0; index < length; index++) {
+            uint256 tokenId = tokenIds[index];
+            _mint(to, tokenId);
+        }
+    }
+
+    function burn(
+        address from,
+        uint256[] calldata tokenIds
+    ) external onlyHandler {
+        uint256 length = tokenIds.length;
+        for (uint256 index = 0; index < length; index++) {
+            uint256 tokenId = tokenIds[index];
+            address owner = ownerOf(tokenId);
+            require(owner == from, "invalid");
+            _burn(tokenId);
+        }
+    }
+}

contracts/cross-chain/L2/BridgeERC721Handler.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {MessageType, BridgeMessage, BridgeERC721Message} from "../BridgeDefine.sol";
+import {ERC721} from "../../dependencies/openzeppelin/contracts/ERC721.sol";
+import "./IParaxL2MessageHandler.sol";
+import "./IBridgeERC721.sol";
+import {Errors} from "../../protocol/libraries/helpers/Errors.sol";
+
+contract BridgeERC21Handler {
+    IParaxL2MessageHandler internal immutable l2MsgHandler;
+
+    //origin asset -> bridge asset
+    mapping(address => address) getBridgeAsset;
+    mapping(address => address) getOriginAsset;
+
+    constructor(IParaxL2MessageHandler msgHandler) {
+        l2MsgHandler = msgHandler;
+    }
+
+    modifier onlyMsgHandler() {
+        require(msg.sender == address(l2MsgHandler), Errors.ONLY_HANDLER);
+        _;
+    }
+
+    function bridgeAsset(
+        BridgeERC721Message calldata message
+    ) external onlyMsgHandler {
+        address bridgeAsset = getBridgeAsset[message.asset];
+        require(bridgeAsset != address(0), "invalid");
+
+        IBridgeERC721(bridgeAsset).mint(message.receiver, message.tokenIds);
+    }
+}

contracts/cross-chain/L2/IBridgeERC721.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IBridgeERC721 {
+    function mint(address to, uint256[] calldata tokenId) external;
+
+    function burn(address from, uint256[] calldata tokenId) external;
+}

contracts/cross-chain/L2/IParaxL2MessageHandler.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {MessageType, BridgeMessage, BridgeERC721Message, ERC721DelegationMessage} from "../BridgeDefine.sol";
+
+interface IParaxL2MessageHandler {
+    //function bridgeAsset(BridgeERC721Message calldata message) external;
+
+    function updateTokenDelegation(
+        ERC721DelegationMessage calldata delegationInfo
+    ) external;
+}

contracts/cross-chain/L2/ParaxL2MessageHandler.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {MessageType, BridgeMessage} from "../BridgeDefine.sol";
+import "./BridgeERC721Handler.sol";
+import "./IParaxL2MessageHandler.sol";
+
+contract ParaxL2MessageHandler is IParaxL2MessageHandler {
+    BridgeERC21Handler internal immutable erc712Handler;
+    address immutable bridgeImpl;
+    address immutable paraX;
+
+    constructor(BridgeERC21Handler handler) {
+        erc712Handler = handler;
+    }
+
+    function bridgeReceive(BridgeMessage calldata message) external {
+        require(msg.sender == bridgeImpl, "");
+        if (message.msgType == MessageType.BridgeERC721) {
+            BridgeERC721Message memory message = abi.decode(
+                message.data,
+                (BridgeERC721Message)
+            );
+            erc712Handler.bridgeAsset(message);
+        } else {}
+    }
+
+    function updateTokenDelegation(
+        ERC721DelegationMessage calldata delegationInfo
+    ) external {
+        require(msg.sender == paraX, Errors.ONLY_PARAX);
+
+        BridgeMessage memory message;
+        message.msgType = MessageType.ERC721DELEGATION;
+        message.data = abi.encode(delegationInfo);
+        //send msg
+    }
+}

contracts/interfaces/IPool.sol

@@ -9,6 +9,7 @@ import {IPoolPositionMover} from "./IPoolPositionMover.sol";
 import {IPoolAAPositionMover} from "./IPoolAAPositionMover.sol";
 import "./IPoolApeStaking.sol";
 import "./IPoolBorrowAndStake.sol";
+import "./IPoolCrossChain.sol";
 
 /**
  * @title IPool
@@ -23,7 +24,8 @@ interface IPool is
     IParaProxyInterfaces,
     IPoolPositionMover,
     IPoolBorrowAndStake,
-    IPoolAAPositionMover
+    IPoolAAPositionMover,
+    IPoolCrossChain
 {
 
 }

contracts/interfaces/IPoolCrossChain.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.0;
+
+import {DataTypes} from "../protocol/libraries/types/DataTypes.sol";
+
+/**
+ * @title IPool
+ *
+ * @notice Defines the basic interface for an ParaSpace Pool.
+ **/
+interface IPoolCrossChain {
+    function updateTokenDelegation(
+        address delegateTo,
+        address underlyingAsset,
+        uint256[] calldata tokenIds,
+        bool value
+    ) external;
+
+    function CROSS_CHAIN_MSG_HANDLER() external view returns (address);
+}

contracts/interfaces/ITokenDelegation.sol

@@ -13,10 +13,4 @@ interface ITokenDelegation {
         uint256[] calldata tokenIds,
         bool value
     ) external;
-
-    /**
-     * @notice Returns the address of the delegation registry of this nToken
-     * @return The address of the delegation registry
-     **/
-    function DELEGATE_REGISTRY() external view returns (address);
 }

contracts/mocks/upgradeability/MockNToken.sol

@@ -6,7 +6,7 @@ import {IPool} from "../../interfaces/IPool.sol";
 import {IRewardController} from "../../interfaces/IRewardController.sol";
 
 contract MockNToken is NToken {
-    constructor(IPool pool, address delegateRegistry) NToken(pool, false, delegateRegistry) {}
+    constructor(IPool pool) NToken(pool, false) {}
 
     function getRevision() internal pure override returns (uint256) {
         return 999;