feat: allow incoming and outgoing transfers

contracts/nft/.gitignore

@@ -17,3 +17,5 @@ cache_forge
 access_token
 
 localnet.json
+
+.openzeppelin

contracts/nft/contracts/evm/UniversalNFT.sol

@@ -2,49 +2,85 @@
 pragma solidity 0.8.26;
 
 import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
-import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
-import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
-import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
-import "@openzeppelin/contracts/access/Ownable2Step.sol";
 import "@zetachain/protocol-contracts/contracts/evm/GatewayEVM.sol";
 import {RevertContext} from "@zetachain/protocol-contracts/contracts/Revert.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import {ERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
+import {ERC721EnumerableUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
+import {ERC721URIStorageUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721URIStorageUpgradeable.sol";
+import {ERC721BurnableUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721BurnableUpgradeable.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
 import "../shared/Events.sol";
 
-abstract contract UniversalNFT is
-    ERC721,
-    ERC721Enumerable,
-    ERC721URIStorage,
-    Ownable2Step,
+contract UniversalNFT is
+    Initializable,
+    ERC721Upgradeable,
+    ERC721EnumerableUpgradeable,
+    ERC721URIStorageUpgradeable,
+    ERC721BurnableUpgradeable,
+    OwnableUpgradeable,
+    UUPSUpgradeable,
     Events
 {
-    GatewayEVM public immutable gateway;
+    GatewayEVM public gateway;
     uint256 private _nextTokenId;
     address public universal;
-    uint256 public immutable gasLimitAmount;
+    uint256 public gasLimitAmount;
+
+    bool public allowOutgoing = true;
+    bool public allowIncoming = true;
 
     error InvalidAddress();
     error Unauthorized();
     error InvalidGasLimit();
     error GasTokenTransferFailed();
-
-    function setUniversal(address contractAddress) external onlyOwner {
-        if (contractAddress == address(0)) revert InvalidAddress();
-        universal = contractAddress;
-        emit SetUniversal(contractAddress);
-    }
+    error OutgoingTransfersNotAllowed();
+    error IncomingTransfersNotAllowed();
 
     modifier onlyGateway() {
         if (msg.sender != address(gateway)) revert Unauthorized();
         _;
     }
 
-    constructor(address payable gatewayAddress, uint256 gas) {
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(
+        address initialOwner,
+        string memory name,
+        string memory symbol,
+        address payable gatewayAddress,
+        uint256 gas
+    ) public initializer {
+        __ERC721_init(name, symbol);
+        __ERC721Enumerable_init();
+        __ERC721URIStorage_init();
+        __Ownable_init(initialOwner);
+        __UUPSUpgradeable_init();
         if (gatewayAddress == address(0)) revert InvalidAddress();
         if (gas == 0) revert InvalidGasLimit();
         gasLimitAmount = gas;
         gateway = GatewayEVM(gatewayAddress);
     }
 
+    function setAllowOutgoing(bool _allowOutgoing) external onlyOwner {
+        allowOutgoing = _allowOutgoing;
+    }
+
+    function setAllowIncoming(bool _allowIncoming) external onlyOwner {
+        allowIncoming = _allowIncoming;
+    }
+
+    function setUniversal(address contractAddress) external onlyOwner {
+        if (contractAddress == address(0)) revert InvalidAddress();
+        universal = contractAddress;
+        emit SetUniversal(contractAddress);
+    }
+
     function safeMint(address to, string memory uri) public onlyOwner {
         uint256 hash = uint256(
             keccak256(
@@ -64,6 +100,7 @@
         address receiver,
         address destination
     ) external payable {
+        if (!allowOutgoing) revert OutgoingTransfersNotAllowed();
         if (receiver == address(0)) revert InvalidAddress();
 
         string memory uri = tokenURI(tokenId);
@@ -102,6 +139,7 @@
         MessageContext calldata context,
         bytes calldata message
     ) external payable onlyGateway returns (bytes4) {
+        if (!allowIncoming) revert IncomingTransfersNotAllowed();
         if (context.sender != universal) revert Unauthorized();
 
         (
@@ -144,20 +182,29 @@
         address to,
         uint256 tokenId,
         address auth
-    ) internal override(ERC721, ERC721Enumerable) returns (address) {
+    )
+        internal
+        override(ERC721Upgradeable, ERC721EnumerableUpgradeable)
+        returns (address)
+    {
         return super._update(to, tokenId, auth);
     }
 
     function _increaseBalance(
         address account,
         uint128 value
-    ) internal override(ERC721, ERC721Enumerable) {
+    ) internal override(ERC721Upgradeable, ERC721EnumerableUpgradeable) {
         super._increaseBalance(account, value);
     }
 
     function tokenURI(
         uint256 tokenId
-    ) public view override(ERC721, ERC721URIStorage) returns (string memory) {
+    )
+        public
+        view
+        override(ERC721Upgradeable, ERC721URIStorageUpgradeable)
+        returns (string memory)
+    {
         return super.tokenURI(tokenId);
     }
 
@@ -166,9 +213,17 @@
     )
         public
         view
-        override(ERC721, ERC721Enumerable, ERC721URIStorage)
+        override(
+            ERC721Upgradeable,
+            ERC721EnumerableUpgradeable,
+            ERC721URIStorageUpgradeable
+        )
         returns (bool)
     {
         return super.supportsInterface(interfaceId);
     }
+
+    function _authorizeUpgrade(
+        address newImplementation
+    ) internal override onlyOwner {}
 }

contracts/nft/contracts/example/EVMUniversalNFT.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "../evm/UniversalNFT.sol";
+
+contract EVMUniversalNFT is UniversalNFT {}

contracts/nft/contracts/example/ZetaChainUniversalNFT.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import "../zetachain/UniversalNFT.sol";
+
+contract ZetaChainUniversalNFT is UniversalNFT {}