Address

• PLSC.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

contract PLSC {
    string public constant name = "PLSChat Token";
    string public constant symbol = "PLSC";
    uint8 public constant decimals = 18;
    uint256 public constant TOTAL_SUPPLY = 1_000_000 * 10**18;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    // ✅ Correct checksummed address
    address public immutable TREASURY = 0xE160d657C7d98f5c7e14fDC38b9b03911538Fe70;

    uint256 public constant LICENSE_PRICE = 100 * 10**18;   // 100 PLSC

    mapping(string => bool) public usedLicenseIds;
    uint256 public totalLicensesIssued;

    event LicenseIssued(address indexed user, string deviceId, string licenseKey);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Burn(address indexed from, uint256 amount);

    constructor() {
        balanceOf[msg.sender] = TOTAL_SUPPLY;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        require(balanceOf[msg.sender] >= amount, "Insufficient balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    function buyLicense(string calldata deviceHardwareId) external {
        require(balanceOf[msg.sender] >= LICENSE_PRICE, "Not enough PLSC");

        uint256 payment = LICENSE_PRICE;

        uint256 burnAmount = (payment * 20) / 100;
        uint256 treasuryAmount = (payment * 60) / 100;
        // 20% stays in contract for rewards pool

        balanceOf[msg.sender] -= payment;
        balanceOf[TREASURY] += treasuryAmount;
        balanceOf[address(0)] += burnAmount; // Burn

        usedLicenseIds[deviceHardwareId] = true;
        totalLicensesIssued++;

        string memory licenseKey = string(abi.encodePacked(
            "PLSC-LICENSE-", 
            deviceHardwareId, 
            "-", 
            uintToString(block.timestamp)
        ));

        emit LicenseIssued(msg.sender, deviceHardwareId, licenseKey);
        emit Burn(msg.sender, burnAmount);
        emit Transfer(msg.sender, TREASURY, treasuryAmount);
        emit Transfer(msg.sender, address(0), burnAmount);
    }

    function uintToString(uint256 value) internal pure returns (string memory) {
        if (value == 0) return "0";
        uint256 temp = value;
        uint256 digits = 0;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits--;
            buffer[digits] = bytes1(uint8(48 + (value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    // Optional: Withdraw from rewards pool (you control this from your Ledger)
    function withdrawRewards(uint256 amount) external {
        require(msg.sender == TREASURY, "Only treasury");
        require(balanceOf[address(this)] >= amount, "Insufficient rewards pool");
        balanceOf[address(this)] -= amount;
        balanceOf[TREASURY] += amount;
        emit Transfer(address(this), TREASURY, amount);
    }
}