feat(be): add Forge setCoolDownDuration function and tests

be/script/Forge_Constants.sol

@@ -7,5 +7,5 @@ contract FToken_Constants {
 
 contract Forge_Constants is FToken_Constants {
     uint256 internal constant MAX_TOKEN_ID = 6;
-    uint256 internal constant COOL_DOWN_DELAY = 60 seconds;
+    uint256 internal constant COOL_DOWN_DELAY = 15 seconds;
 }

be/src/Forge.sol

@@ -11,37 +11,54 @@ import {FToken} from "./FToken.sol";
 /**
  * errors
  */
+error Forge__OnlyOwnerAllowed();
 error Forge__UserInCoolDown(address user);
 error Forge__InvalidToken(uint256 tokenId);
 error Forge__CanOnlyBurnForgedToken(uint256 tokenId);
 error Forge__CanNotTradeForSameToken(uint256 tokenId);
 error Forge__CanOnlyTradeForBasicToken(uint256 tokenId);
 
 contract Forge {
+    /**
+     * events
+     */
+    event Forge__MintToken(address indexed user, uint256 indexed tokenId, uint256 indexed amount);
+    event Forge__ForgeToken(address indexed user, uint256 indexed tokenId, uint256 indexed amount);
+    event Forge__BurnToken(address indexed user, uint256 indexed tokenId, uint256 indexed amount);
+    event Forge__Trade(address indexed user, uint256 indexed burnedTokenId, uint256 indexed mintedTokenId);
+
     /**
      * state
      */
+    address public immutable I_OWNER;
     FToken public immutable I_TOKEN;
-    uint256 public immutable I_COOL_DOWN_DELAY;
     uint256 public immutable I_MAX_TOKEN_ID;
+    uint256 public coolDownDelay;
     mapping(address user => uint256 coolDownTimer) public userCoolDownTimer;
 
     /**
-     * events
+     * modifiers
      */
-    event Forge__MintToken(address indexed user, uint256 indexed tokenId, uint256 indexed amount);
-    event Forge__ForgeToken(address indexed user, uint256 indexed tokenId, uint256 indexed amount);
-    event Forge__BurnToken(address indexed user, uint256 indexed tokenId, uint256 indexed amount);
-    event Forge__Trade(address indexed user, uint256 indexed burnedTokenId, uint256 indexed mintedTokenId);
+    modifier onlyOwner() {
+        _onlyOwner();
+        _;
+    }
+
+    function _onlyOwner() internal view {
+        if (msg.sender != I_OWNER) {
+            revert Forge__OnlyOwnerAllowed();
+        }
+    }
 
     /**
      * functions - constructor
      * deploy Token contract and set pointer
      */
     constructor(string memory _tokenUri, uint256 _maxTokenId, uint256 _coolDownDelay) {
+        I_OWNER = msg.sender;
         I_MAX_TOKEN_ID = _maxTokenId;
-        I_COOL_DOWN_DELAY = _coolDownDelay;
         I_TOKEN = new FToken(_tokenUri);
+        coolDownDelay = _coolDownDelay;
     }
 
     /**
@@ -61,7 +78,7 @@ contract Forge {
             if (block.timestamp < userCoolDownTimer[msg.sender]) {
                 revert Forge__UserInCoolDown(msg.sender);
             } else {
-                userCoolDownTimer[msg.sender] = block.timestamp + I_COOL_DOWN_DELAY;
+                userCoolDownTimer[msg.sender] = block.timestamp + coolDownDelay;
                 I_TOKEN.mint(msg.sender, _tokenId, 1);
 
                 emit Forge__MintToken(msg.sender, _tokenId, 1);
@@ -119,6 +136,13 @@ contract Forge {
         emit Forge__Trade(msg.sender, _tokenIdToBurn, _tokenIdToMint);
     }
 
+    /**
+     * Admin function to set coolDownDelay
+     */
+    function setCoolDownDelay(uint256 _coolDownDelay) public onlyOwner {
+        coolDownDelay = _coolDownDelay;
+    }
+
     /**
      * helpers
      */

be/test/ForgeTest.t.sol

@@ -10,7 +10,8 @@ import {
     Forge__UserInCoolDown,
     Forge__CanOnlyBurnForgedToken,
     Forge__CanNotTradeForSameToken,
-    Forge__CanOnlyTradeForBasicToken
+    Forge__CanOnlyTradeForBasicToken,
+    Forge__OnlyOwnerAllowed
 } from "../src/Forge.sol";
 import {Forge_Constants} from "../script/Forge_Constants.sol";
 import {ForgeScript} from "../script/ForgeScript.s.sol";
@@ -34,8 +35,9 @@ contract ForgeTest is Test, Forge_Constants {
 
     // === deployment Tests ===
     function test_deployment() public view {
+        assertEq(forge.I_OWNER(), owner);
         assertEq(forge.I_MAX_TOKEN_ID(), MAX_TOKEN_ID);
-        assertEq(forge.I_COOL_DOWN_DELAY(), COOL_DOWN_DELAY);
+        assertEq(forge.coolDownDelay(), COOL_DOWN_DELAY);
 
         FToken _token = forge.I_TOKEN();
         address tokenContractOwner = _token.I_OWNER();
@@ -480,4 +482,19 @@ contract ForgeTest is Test, Forge_Constants {
         assertEq(values[1], 1);
         assertEq(values[2], 1);
     }
+
+    // === setCoolDownDelay Tests ===
+    function test_setCoolDownDelay() public {
+        vm.prank(owner);
+        forge.setCoolDownDelay(2 days);
+        assertEq(forge.coolDownDelay(), 2 days);
+    }
+
+    function test_setCoolDownDelay_RevertWhen_NotAdmin() public {
+        vm.prank(player01);
+        vm.expectRevert(Forge__OnlyOwnerAllowed.selector);
+        forge.setCoolDownDelay(2 days);
+
+        assertEq(forge.coolDownDelay(), COOL_DOWN_DELAY);
+    }
 }