logos-messaging/logos-messaging-rlnv2-contract
1
0
Fork 0
mirror of https://github.com/logos-messaging/logos-messaging-rlnv2-contract.git synced 2026-04-01 17:33:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update Approver to Minter role

Browse Source
This commit is contained in:
stubbsta 2025-08-05 14:40:07 +02:00
parent c977fabaa1
commit da9ec0e08b
No known key found for this signature in database
2 changed files with 90 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
test/TestStableToken.sol
View File

@ -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);
}
}

155
test/TestStableToken.t.sol
View File

@ -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);
}
}
}