Smart Contract Framework

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@bloklab/contracts/token/AssetToken.sol";
import "@bloklab/contracts/compliance/KYCRegistry.sol";
import "@bloklab/contracts/access/RoleManager.sol";

contract EnterpriseAssetToken is AssetToken, RoleManager {
    bytes32 public constant COMPLIANCE_ROLE = keccak256("COMPLIANCE_ROLE");
    
    KYCRegistry public immutable kycRegistry;
    mapping(address => bool) public accreditedInvestors;
    
    uint256 public maxInvestors = 499; // Under SEC exemption
    uint256 public currentInvestorCount;
    
    constructor(
        string memory name,
        string memory symbol,
        address _kycRegistry
    ) AssetToken(name, symbol) {
        kycRegistry = KYCRegistry(_kycRegistry);
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }
    
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        super._beforeTokenTransfer(from, to, amount);
        
        if (to != address(0)) {
            require(kycRegistry.isVerified(to), "Recipient not KYC verified");
            require(accreditedInvestors[to], "Recipient not accredited");
            
            if (balanceOf(to) == 0) {
                require(currentInvestorCount < maxInvestors, "Max investors exceeded");
                currentInvestorCount++;
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";

contract ComplianceRegistry is AccessControl, Pausable {
    bytes32 public constant COMPLIANCE_OFFICER = keccak256("COMPLIANCE_OFFICER");
    bytes32 public constant KYC_PROVIDER = keccak256("KYC_PROVIDER");
    
    struct InvestorProfile {
        bool isVerified;
        bool isAccredited;
        uint256 verificationDate;
        uint256 expirationDate;
        string jurisdiction;
    }
    
    mapping(address => InvestorProfile) public investors;
    mapping(string => bool) public supportedJurisdictions;
    
    event InvestorVerified(address indexed investor, string jurisdiction);
    event InvestorRevoked(address indexed investor, string reason);
    
    constructor() {
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(COMPLIANCE_OFFICER, msg.sender);
        
        // Initialize supported jurisdictions
        supportedJurisdictions["US"] = true;
        supportedJurisdictions["EU"] = true;
        supportedJurisdictions["UK"] = true;
    }
    
    function verifyInvestor(
        address investor,
        bool isAccredited,
        string memory jurisdiction,
        uint256 validityPeriod
    ) external onlyRole(KYC_PROVIDER) whenNotPaused {
        require(supportedJurisdictions[jurisdiction], "Unsupported jurisdiction");
        
        investors[investor] = InvestorProfile({
            isVerified: true,
            isAccredited: isAccredited,
            verificationDate: block.timestamp,
            expirationDate: block.timestamp + validityPeriod,
            jurisdiction: jurisdiction
        });
        
        emit InvestorVerified(investor, jurisdiction);
    }
}