security token added

Author: panditdhamdhere

script/token/DeploySecurityToken.s.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Script} from "forge-std/Script.sol";
+import {SecurityToken} from "../../src/tokens/SecurityToken.sol";
+
+contract DeploySecurityToken is Script {
+    function run() external {
+        // Retrieve private key from environment
+        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+
+        // Start broadcasting transactions
+        vm.startBroadcast(deployerPrivateKey);
+
+        // Deploy the token
+        SecurityToken token = new SecurityToken(
+            "Security Token",
+            "STKN",
+            vm.addr(deployerPrivateKey)
+        );
+
+        vm.stopBroadcast();
+    }
+}

src/tokens/SecurityToken.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+contract SecurityToken is ERC20, Ownable {
+    // Identity Registry to store KYC/AML status
+    mapping(address => bool) public identityRegistry;
+
+    // Transfer restriction status
+    bool public transfersFrozen;
+
+    // Events
+    event AddedToIdentityRegistry(address indexed investor);
+    event RemovedFromIdentityRegistry(address indexed investor);
+    event TransfersFrozen();
+    event TransfersUnfrozen();
+
+    constructor(
+        string memory name,
+        string memory symbol,
+        address initialOwner
+    ) ERC20(name, symbol) Ownable(initialOwner) {}
+
+    // Modifier to check if an address is verified
+    modifier onlyVerified(address _address) {
+        require(identityRegistry[_address], "Identity not verified");
+        _;
+    }
+
+    // Add an investor to the identity registry
+    function addToIdentityRegistry(address investor) external onlyOwner {
+        identityRegistry[investor] = true;
+        emit AddedToIdentityRegistry(investor);
+    }
+
+    // Remove an investor from the identity registry
+    function removeFromIdentityRegistry(address investor) external onlyOwner {
+        identityRegistry[investor] = false;
+        emit RemovedFromIdentityRegistry(investor);
+    }
+
+    // Freeze all transfers
+    function freezeTransfers() external onlyOwner {
+        transfersFrozen = true;
+        emit TransfersFrozen();
+    }
+
+    // Unfreeze all transfers
+    function unfreezeTransfers() external onlyOwner {
+        transfersFrozen = false;
+        emit TransfersUnfrozen();
+    }
+
+    // Mint new tokens (only owner)
+    function mint(
+        address to,
+        uint256 amount
+    ) external onlyOwner onlyVerified(to) {
+        _mint(to, amount);
+    }
+
+    // Override transfer function to add compliance checks
+    function transfer(
+        address to,
+        uint256 amount
+    ) public override onlyVerified(msg.sender) onlyVerified(to) returns (bool) {
+        require(!transfersFrozen, "Transfers are frozen");
+        return super.transfer(to, amount);
+    }
+
+    // Override transferFrom function to add compliance checks
+    function transferFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) public override onlyVerified(from) onlyVerified(to) returns (bool) {
+        require(!transfersFrozen, "Transfers are frozen");
+        return super.transferFrom(from, to, amount);
+    }
+}

test/token/SecurityToken.t.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {SecurityToken} from "../../src/tokens/SecurityToken.sol";
+
+contract SecurityTokenTest is Test {
+    SecurityToken public token;
+    address public owner;
+    address public alice;
+    address public bob;
+
+    function setUp() public {
+        owner = address(this);
+        alice = address(0x1);
+        bob = address(0x2);
+
+        // Deploy token
+        token = new SecurityToken("Security Token", "STKN", owner);
+
+        // Add alice and bob to identity registry
+        token.addToIdentityRegistry(alice);
+        token.addToIdentityRegistry(bob);
+
+        // Mint initial tokens to alice
+        token.mint(alice, 1000);
+    }
+
+    function testInitialSetup() public {
+        assertEq(token.name(), "Security Token");
+        assertEq(token.symbol(), "STKN");
+        assertEq(token.balanceOf(alice), 1000);
+    }
+
+    function testTransferBetweenVerifiedAddresses() public {
+        vm.prank(alice);
+        token.transfer(bob, 500);
+        assertEq(token.balanceOf(alice), 500);
+        assertEq(token.balanceOf(bob), 500);
+    }
+
+    function testFailTransferToUnverifiedAddress() public {
+        address unverified = address(0x3);
+        vm.prank(alice);
+        token.transfer(unverified, 500);
+    }
+
+    function testFailTransferWhenFrozen() public {
+        token.freezeTransfers();
+        vm.prank(alice);
+        token.transfer(bob, 500);
+    }
+
+    function testIdentityRegistryManagement() public {
+        address charlie = address(0x4);
+        assertFalse(token.identityRegistry(charlie));
+
+        token.addToIdentityRegistry(charlie);
+        assertTrue(token.identityRegistry(charlie));
+
+        token.removeFromIdentityRegistry(charlie);
+        assertFalse(token.identityRegistry(charlie));
+    }
+}