diff --git a/test/TestStableToken.sol b/test/TestStableToken.sol
index 64a6c9b..293c2e0 100644
--- a/test/TestStableToken.sol
+++ b/test/TestStableToken.sol
@@ -6,31 +6,31 @@ import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import { ERC20Permit } from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
 import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
 
-error AccountNotApproved();
-error AccountAlreadyApproved();
-error AccountNotInList();
+error AccountNotMinter();
+error AccountAlreadyMinter();
+error AccountNotInMinterList();
 
 contract TestStableToken is ERC20, ERC20Permit, Ownable {
-    mapping(address => bool) public approvedAccounts;
+    mapping(address => bool) public minterRole;
 
-    modifier onlyOwnerOrApproved() {
-        if (msg.sender != owner() && !approvedAccounts[msg.sender]) revert AccountNotApproved();
+    modifier onlyOwnerOrMinter() {
+        if (msg.sender != owner() && !minterRole[msg.sender]) revert AccountNotMinter();
         _;
     }
 
     constructor() ERC20("TestStableToken", "TST") ERC20Permit("TestStableToken") Ownable() { }
 
-    function addApprovedAccount(address account) external onlyOwner {
-        if (approvedAccounts[account]) revert AccountAlreadyApproved();
-        approvedAccounts[account] = true;
+    function addMinterRole(address account) external onlyOwner {
+        if (minterRole[account]) revert AccountAlreadyMinter();
+        minterRole[account] = true;
     }
 
-    function removeApprovedAccount(address account) external onlyOwner {
-        if (!approvedAccounts[account]) revert AccountNotInList();
-        approvedAccounts[account] = false;
+    function removeMinterRole(address account) external onlyOwner {
+        if (!minterRole[account]) revert AccountNotInMinterList();
+        minterRole[account] = false;
     }
 
-    function mint(address to, uint256 amount) external onlyOwnerOrApproved {
+    function mint(address to, uint256 amount) external onlyOwnerOrMinter {
         _mint(to, amount);
     }
 }
diff --git a/test/TestStableToken.t.sol b/test/TestStableToken.t.sol
index 2b6d8fd..dbadcd0 100644
--- a/test/TestStableToken.t.sol
+++ b/test/TestStableToken.t.sol
@@ -2,157 +2,156 @@
 pragma solidity >=0.8.19 <0.9.0;
 
 import { Test } from "forge-std/Test.sol";
-import { TestStableToken, AccountNotApproved, AccountAlreadyApproved, AccountNotInList } from "./TestStableToken.sol";
+import { TestStableToken, AccountNotMinter, AccountAlreadyMinter, AccountNotInMinterList } from "./TestStableToken.sol";
 
 contract TestStableTokenTest is Test {
     TestStableToken internal token;
     address internal owner;
     address internal user1;
     address internal user2;
-    address internal nonApproved;
+    address internal nonMinter;
 
     function setUp() public {
         token = new TestStableToken();
         owner = address(this);
         user1 = vm.addr(1);
         user2 = vm.addr(2);
-        nonApproved = vm.addr(3);
+        nonMinter = vm.addr(3);
     }
 
-    function test__OwnerCanAddApprovedAccount() external {
-        assertFalse(token.approvedAccounts(user1));
-        
-        token.addApprovedAccount(user1);
-        
-        assertTrue(token.approvedAccounts(user1));
+    function test__OwnerCanAddMinterRole() external {
+        assertFalse(token.minterRole(user1));
+
+        token.addMinterRole(user1);
+
+        assertTrue(token.minterRole(user1));
     }
 
-    function test__OwnerCanRemoveApprovedAccount() external {
-        token.addApprovedAccount(user1);
-        assertTrue(token.approvedAccounts(user1));
-        
-        token.removeApprovedAccount(user1);
-        
-        assertFalse(token.approvedAccounts(user1));
+    function test__OwnerCanRemoveMinterRole() external {
+        token.addMinterRole(user1);
+        assertTrue(token.minterRole(user1));
+
+        token.removeMinterRole(user1);
+
+        assertFalse(token.minterRole(user1));
     }
 
-    function test__OwnerCanMintWithoutApproval() external {
+    function test__OwnerCanMintWithoutMinterRole() external {
         uint256 mintAmount = 1000 ether;
-        
+
         token.mint(user1, mintAmount);
-        
+
         assertEq(token.balanceOf(user1), mintAmount);
     }
 
-    function test__NonOwnerCannotAddApprovedAccount() external {
+    function test__NonOwnerCannotAddMinterRole() external {
         vm.prank(user1);
         vm.expectRevert("Ownable: caller is not the owner");
-        token.addApprovedAccount(user1);
+        token.addMinterRole(user1);
     }
 
-    function test__NonOwnerCannotRemoveApprovedAccount() external {
-        token.addApprovedAccount(user1);
-        
+    function test__NonOwnerCannotRemoveMinterRole() external {
+        token.addMinterRole(user1);
+
         vm.prank(user1);
         vm.expectRevert("Ownable: caller is not the owner");
-        token.removeApprovedAccount(user1);
+        token.removeMinterRole(user1);
     }
 
-    function test__CannotAddAlreadyApprovedAccount() external {
-        token.addApprovedAccount(user1);
-        
-        vm.expectRevert(abi.encodeWithSelector(AccountAlreadyApproved.selector));
-        token.addApprovedAccount(user1);
+    function test__CannotAddAlreadyMinterRole() external {
+        token.addMinterRole(user1);
+
+        vm.expectRevert(abi.encodeWithSelector(AccountAlreadyMinter.selector));
+        token.addMinterRole(user1);
     }
 
-    function test__CannotRemoveNonApprovedAccount() external {
-        vm.expectRevert(abi.encodeWithSelector(AccountNotInList.selector));
-        token.removeApprovedAccount(user1);
+    function test__CannotRemoveNonMinterRole() external {
+        vm.expectRevert(abi.encodeWithSelector(AccountNotInMinterList.selector));
+        token.removeMinterRole(user1);
     }
 
-    function test__ApprovedAccountCanMint() external {
+    function test__MinterRoleCanMint() external {
         uint256 mintAmount = 1000 ether;
-        token.addApprovedAccount(user1);
-        
+        token.addMinterRole(user1);
+
         vm.prank(user1);
         token.mint(user2, mintAmount);
-        
+
         assertEq(token.balanceOf(user2), mintAmount);
     }
 
-    function test__NonApprovedNonOwnerAccountCannotMint() external {
+    function test__NonMinterNonOwnerAccountCannotMint() external {
         uint256 mintAmount = 1000 ether;
-        
-        vm.prank(nonApproved);
-        vm.expectRevert(abi.encodeWithSelector(AccountNotApproved.selector));
+
+        vm.prank(nonMinter);
+        vm.expectRevert(abi.encodeWithSelector(AccountNotMinter.selector));
         token.mint(user1, mintAmount);
     }
 
-    function test__MultipleApprovedAccountsCanMint() external {
+    function test__MultipleMinterRolesCanMint() external {
         uint256 mintAmount = 500 ether;
-        token.addApprovedAccount(user1);
-        token.addApprovedAccount(user2);
-        
+        token.addMinterRole(user1);
+        token.addMinterRole(user2);
+
         vm.prank(user1);
         token.mint(owner, mintAmount);
-        
+
         vm.prank(user2);
         token.mint(owner, mintAmount);
-        
+
         assertEq(token.balanceOf(owner), mintAmount * 2);
     }
 
-    function test__RemovedAccountCannotMint() external {
+    function test__RemovedMinterRoleCannotMint() external {
         uint256 mintAmount = 1000 ether;
-        token.addApprovedAccount(user1);
-        token.removeApprovedAccount(user1);
-        
+        token.addMinterRole(user1);
+        token.removeMinterRole(user1);
+
         vm.prank(user1);
-        vm.expectRevert(abi.encodeWithSelector(AccountNotApproved.selector));
+        vm.expectRevert(abi.encodeWithSelector(AccountNotMinter.selector));
         token.mint(user2, mintAmount);
     }
 
-    function test__OwnerCanAlwaysMintEvenWhenNotApproved() external {
+    function test__OwnerCanAlwaysMintEvenWithoutMinterRole() external {
         uint256 mintAmount = 500 ether;
-        
-        // Owner is not in approved accounts but should still be able to mint
-        assertFalse(token.approvedAccounts(address(this)));
+
+        // Owner is not in minter role but should still be able to mint
+        assertFalse(token.minterRole(address(this)));
         token.mint(user1, mintAmount);
         assertEq(token.balanceOf(user1), mintAmount);
     }
 
-    function test__CheckApprovedAccountsMapping() external {
-        assertFalse(token.approvedAccounts(user1));
-        assertFalse(token.approvedAccounts(user2));
-        
-        token.addApprovedAccount(user1);
-        assertTrue(token.approvedAccounts(user1));
-        assertFalse(token.approvedAccounts(user2));
-        
-        token.addApprovedAccount(user2);
-        assertTrue(token.approvedAccounts(user1));
-        assertTrue(token.approvedAccounts(user2));
-        
-        token.removeApprovedAccount(user1);
-        assertFalse(token.approvedAccounts(user1));
-        assertTrue(token.approvedAccounts(user2));
+    function test__CheckMinterRoleMapping() external {
+        assertFalse(token.minterRole(user1));
+        assertFalse(token.minterRole(user2));
+
+        token.addMinterRole(user1);
+        assertTrue(token.minterRole(user1));
+        assertFalse(token.minterRole(user2));
+
+        token.addMinterRole(user2);
+        assertTrue(token.minterRole(user1));
+        assertTrue(token.minterRole(user2));
+
+        token.removeMinterRole(user1);
+        assertFalse(token.minterRole(user1));
+        assertTrue(token.minterRole(user2));
     }
 
     function test__ERC20BasicFunctionality() external {
-        token.addApprovedAccount(user1);
+        token.addMinterRole(user1);
         uint256 mintAmount = 1000 ether;
-        
+
         vm.prank(user1);
         token.mint(user2, mintAmount);
-        
+
         assertEq(token.balanceOf(user2), mintAmount);
         assertEq(token.totalSupply(), mintAmount);
-        
+
         vm.prank(user2);
         token.transfer(owner, 200 ether);
-        
+
         assertEq(token.balanceOf(user2), 800 ether);
         assertEq(token.balanceOf(owner), 200 ether);
     }
-
-}
\ No newline at end of file
+}