@pru.pinya/contracts 1.0.0

package/contracts/token/KAP-20/KAP20.sol

@@ -0,0 +1,276 @@
+//SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import {IKAP20} from "./interfaces/IKAP20.sol";
+import {IKToken} from "./interfaces/IKToken.sol";
+import {Pausable} from "../../utils/Pausable.sol";
+import {AccessController} from "../../access/AccessController.sol";
+import {IKYCBitkubChain} from "../../interfaces/IKYCBitkubChain.sol";
+import {IAdminProjectRouter} from "../../interfaces/IAdminProjectRouter.sol";
+
+abstract contract KAP20 is IKAP20, IKToken, Pausable, AccessController {
+    mapping(address => uint256) _balances;
+
+    mapping(address => mapping(address => uint256)) internal _allowances;
+
+    uint256 public override totalSupply;
+    string public override name;
+    string public override symbol;
+    uint8 public override decimals;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        string memory _projectName,
+        uint8 _decimals,
+        address _kyc,
+        address _adminProjectRouter,
+        address _committee,
+        address _transferRouter,
+        uint256 _acceptedKYCLevel
+    ) {
+        name = _name;
+        symbol = _symbol;
+        PROJECT = _projectName;
+        decimals = _decimals;
+        kyc = IKYCBitkubChain(_kyc);
+        adminProjectRouter = IAdminProjectRouter(_adminProjectRouter);
+        committee = _committee;
+        transferRouter = _transferRouter;
+        acceptedKYCLevel = _acceptedKYCLevel;
+    }
+
+    function balanceOf(address account)
+        public
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        return _balances[account];
+    }
+
+    function transfer(address recipient, uint256 amount)
+        public
+        virtual
+        override
+        whenNotPaused
+        returns (bool)
+    {
+        _transfer(msg.sender, recipient, amount);
+        return true;
+    }
+
+    function allowance(address owner, address spender)
+        public
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        return _allowances[owner][spender];
+    }
+
+    function approve(address spender, uint256 amount)
+        public
+        virtual
+        override
+        returns (bool)
+    {
+        _approve(msg.sender, spender, amount);
+        return true;
+    }
+
+    function adminApprove(
+        address owner,
+        address spender,
+        uint256 amount
+    )
+        public
+        virtual
+        override
+        whenNotPaused
+        onlySuperAdminOrAdmin
+        returns (bool)
+    {
+        require(
+            kyc.kycsLevel(owner) >= acceptedKYCLevel &&
+                kyc.kycsLevel(spender) >= acceptedKYCLevel,
+            "KAP20: owner or spender address is not a KYC user"
+        );
+
+        _approve(owner, spender, amount);
+        return true;
+    }
+
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) public virtual override whenNotPaused returns (bool) {
+        _transfer(sender, recipient, amount);
+
+        uint256 currentAllowance = _allowances[sender][msg.sender];
+        require(
+            currentAllowance >= amount,
+            "KAP20: transfer amount exceeds allowance"
+        );
+        unchecked {
+            _approve(sender, msg.sender, currentAllowance - amount);
+        }
+
+        return true;
+    }
+
+    function increaseAllowance(address spender, uint256 addedValue)
+        public
+        virtual
+        returns (bool)
+    {
+        _approve(
+            msg.sender,
+            spender,
+            _allowances[msg.sender][spender] + addedValue
+        );
+        return true;
+    }
+
+    function decreaseAllowance(address spender, uint256 subtractedValue)
+        public
+        virtual
+        returns (bool)
+    {
+        uint256 currentAllowance = _allowances[msg.sender][spender];
+        require(
+            currentAllowance >= subtractedValue,
+            "KAP20: decreased allowance below zero"
+        );
+        unchecked {
+            _approve(msg.sender, spender, currentAllowance - subtractedValue);
+        }
+
+        return true;
+    }
+
+    function _transfer(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) internal virtual {
+        require(sender != address(0), "KAP20: transfer from the zero address");
+        require(recipient != address(0), "KAP20: transfer to the zero address");
+
+        uint256 senderBalance = _balances[sender];
+        require(
+            senderBalance >= amount,
+            "KAP20: transfer amount exceeds balance"
+        );
+        unchecked {
+            _balances[sender] = senderBalance - amount;
+        }
+        _balances[recipient] += amount;
+
+        emit Transfer(sender, recipient, amount);
+    }
+
+    function _mint(address account, uint256 amount) internal virtual {
+        require(account != address(0), "KAP20: mint to the zero address");
+
+        totalSupply += amount;
+        _balances[account] += amount;
+        emit Transfer(address(0), account, amount);
+    }
+
+    function _burn(address account, uint256 amount) internal virtual {
+        require(account != address(0), "KAP20: burn from the zero address");
+
+        uint256 accountBalance = _balances[account];
+        require(accountBalance >= amount, "KAP20: burn amount exceeds balance");
+        unchecked {
+            _balances[account] = accountBalance - amount;
+        }
+        totalSupply -= amount;
+
+        emit Transfer(account, address(0), amount);
+    }
+
+    function _approve(
+        address owner,
+        address spender,
+        uint256 amount
+    ) internal virtual {
+        require(owner != address(0), "KAP20: approve from the zero address");
+        require(spender != address(0), "KAP20: approve to the zero address");
+
+        _allowances[owner][spender] = amount;
+        emit Approval(owner, spender, amount);
+    }
+
+    function adminTransfer(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) public virtual override onlyCommittee returns (bool) {
+        if (isActivatedOnlyKYCAddress) {
+            require(
+                kyc.kycsLevel(sender) > 0 && kyc.kycsLevel(recipient) > 0,
+                "KAP20: only internal purpose"
+            );
+        }
+        uint256 senderBalance = _balances[sender];
+        require(
+            senderBalance >= amount,
+            "KAP20: transfer amount exceeds balance"
+        );
+        unchecked {
+            _balances[sender] = senderBalance - amount;
+        }
+        _balances[recipient] += amount;
+
+        emit Transfer(sender, recipient, amount);
+
+        return true;
+    }
+
+    function internalTransfer(
+        address sender,
+        address recipient,
+        uint256 amount
+    )
+        external
+        override
+        whenNotPaused
+        onlySuperAdminOrTransferRouter
+        returns (bool)
+    {
+        require(
+            kyc.kycsLevel(sender) >= acceptedKYCLevel &&
+                kyc.kycsLevel(recipient) >= acceptedKYCLevel,
+            "KAP20: only internal purpose"
+        );
+
+        _transfer(sender, recipient, amount);
+        return true;
+    }
+
+    function externalTransfer(
+        address sender,
+        address recipient,
+        uint256 amount
+    )
+        external
+        override
+        whenNotPaused
+        onlySuperAdminOrTransferRouter
+        returns (bool)
+    {
+        require(
+            kyc.kycsLevel(sender) >= acceptedKYCLevel,
+            "KAP20: only internal purpose"
+        );
+
+        _transfer(sender, recipient, amount);
+        return true;
+    }
+}

package/contracts/token/KAP-20/interfaces/IKAP20.sol

@@ -0,0 +1,43 @@
+//SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0 <0.9.0;
+
+interface IKAP20 {
+    function totalSupply() external view returns (uint256);
+
+    function decimals() external view returns (uint8);
+
+    function symbol() external view returns (string memory);
+
+    function name() external view returns (string memory);
+
+    function balanceOf(address account) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function approve(address spender, uint256 amount) external returns (bool);
+
+    function adminApprove(
+        address owner,
+        address spender,
+        uint256 amount
+    ) external returns (bool);
+
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+
+    function adminTransfer(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}

package/contracts/token/KAP-20/interfaces/IKToken.sol

@@ -0,0 +1,17 @@
+//SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0 <0.9.0;
+
+interface IKToken {
+    function internalTransfer(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+
+    function externalTransfer(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+}

package/contracts/token/KAP-22/KAP22.sol

@@ -0,0 +1,358 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import {IKAP20} from "../KAP-20/interfaces/IKAP20.sol";
+import {IKAP22} from "./interfaces/IKAP22.sol";
+import {IKToken} from "../KAP-20/interfaces/IKToken.sol";
+import {TransferRouter} from "./utils/TransferRouter.sol";
+import {IKYCBitkubChain} from "../../interfaces/IKYCBitkubChain.sol";
+import {KYCHandler} from "../../kyc/KYCHandler.sol";
+import {AccessControllerKAP} from "../../access/AccessControllerKAP.sol";
+import {WhitelistAddress} from "./utils/WhitelistAddress.sol";
+import {EnumerableSetAddress} from "../../libs/EnumerableSetAddress.sol";
+
+abstract contract KAP22 is IKAP20, IKAP22, IKToken, AccessControllerKAP {
+    mapping(address => mapping(uint256 => uint256)) private _balances; // owner => period => balance
+    mapping(address => uint256) private _unStampBalance; // owner => balance
+    mapping(address => mapping(address => uint256)) private _allowances; // owner => spender => amount
+
+    string public override name;
+    string public override symbol;
+    uint8 public immutable override decimals;
+    uint256 public override cap;
+    uint256 public override totalSupply;
+    uint256 public override currentIndex;
+    uint256 public override startTime;
+    uint256 public override periodLength;
+
+    modifier updatePeriod() {
+        _updatePeriod();
+        _;
+    }
+
+    // constructor(
+    //     // string memory name_,
+    //     // string memory symbol_,
+    //     // uint8 decimals_,
+    //     address owner_,
+    //     address vault_,
+    //     address minter_,
+    //     address burner_,
+    //     address transferRouter_,
+    //     address kyc_,
+    //     uint256 acceptedKycLevel_,
+    //     uint256 startTime_,
+    //     uint256 periodLength_
+    // ) AccessControllerKAP(owner_, vault_, minter_, burner_, transferRouter_, kyc_, acceptedKycLevel_) {
+    //     name = "name_";
+    //     symbol = "symbol_";
+    //     decimals = 18;
+    //     startTime = startTime_;
+    //     periodLength = periodLength_;
+    // }
+
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        address owner_,
+        uint256 startTime_,
+        uint256 periodLength_,
+        uint256 cap_
+    ) AccessControllerKAP(owner_, address(0), address(0), 4) {
+        name = name_;
+        symbol = symbol_;
+        decimals = 18;
+        startTime = startTime_;
+        periodLength = periodLength_;
+        cap = cap_;
+    }
+
+    function setCap(uint256 amount) external onlyOwner updatePeriod returns (bool) {
+        require(cap <= amount, "KAP22: can't set less than older cap");
+
+        cap = amount;
+
+        return true;
+    }
+
+    function adminApprove(
+    address _owner,
+    address _spender,
+    uint256 _amount
+) external override onlyOwner returns (bool) {
+    _approve(_owner, _spender, _amount);
+    return true;
+}
+
+    function mint(uint256 amount, address receiver) external override onlyOwner updatePeriod returns (bool) {
+        require(totalSupply + amount <= cap, "KAP22: cap exceeded");
+
+        totalSupply += amount;
+
+        _balances[receiver][currentIndex + 1] += amount;
+
+        emit Mint(currentIndex, receiver, amount);
+
+        return true;
+    }
+
+    function burn(
+        uint256 period,
+        uint256 amount,
+        address _owner
+    ) external override onlyOwner updatePeriod returns (bool) {
+        // _totalSupply -= amount;
+
+        // _balances[_owner][period] -= amount;
+
+        // emit Burn(period, _owner, amount);
+
+        return true;
+    }
+
+    function currentPeriod() external view override returns (uint256) {
+        return _currentPeriod(currentIndex);
+    }
+
+    function balanceOf(address _owner) external view override returns (uint256 balance) {
+        uint256 tmpBalances;
+        uint256 tmpPeriod = _currentPeriod(currentIndex);
+
+        if (isWhitelistAddr(_owner)) {
+            for (uint256 i = 0; i <= tmpPeriod + 1; i++) {
+                tmpBalances += _balances[_owner][i];
+            }
+        } else {
+            tmpBalances += _balances[_owner][tmpPeriod];
+            tmpBalances += _balances[_owner][tmpPeriod + 1];
+        }
+
+        return tmpBalances;
+    }
+
+    function balanceOfCurrentPeriod(address _owner) external view returns (uint256 balance) {
+        uint256 tmpPeriod = _currentPeriod(currentIndex);
+
+        return _balances[_owner][tmpPeriod];
+    }
+
+    function balanceOfNextPeriod(address _owner) external view returns (uint256 balance) {
+        uint256 tmpPeriod = _currentPeriod(currentIndex);
+
+        return _balances[_owner][tmpPeriod + 1];
+    }
+
+    function balanceOfByPeriod(address _owner, uint256 _period) external view returns (uint256 balance) {
+        return _balances[_owner][_period];
+    }
+
+    function transfer(address _recipient, uint256 _amount) external override returns (bool) {
+        if ((isWhitelistAddr(msg.sender) || msg.sender == owner) && isWhitelistAddr(_recipient)) {
+            _transferPreviousPeriod(msg.sender, _recipient, _amount, 0);
+        } else if (msg.sender == owner) {
+            _transferSpecificPeriod(msg.sender, _recipient, _amount, currentIndex + 1);
+        } else {
+            _transfer(msg.sender, _recipient, _amount);
+        }
+
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) external view override returns (uint256 remaining) {
+        return _allowances[_owner][_spender];
+    }
+
+    function approve(address _spender, uint256 _amount) external override returns (bool) {
+        _approve(msg.sender, _spender, _amount);
+        return true;
+    }
+
+    function transferFrom(
+        address _sender,
+        address _recipient,
+        uint256 _amount
+    ) external override returns (bool) {
+        uint256 currentAllowance = _allowances[_sender][msg.sender];
+        require(currentAllowance >= _amount, "KAP22: transfer amount exceeds allowance");
+        _approve(_sender, msg.sender, currentAllowance - _amount);
+
+        if ((isWhitelistAddr(msg.sender) || msg.sender == owner) && isWhitelistAddr(_recipient)) {
+            _transferPreviousPeriod(msg.sender, _recipient, _amount, 0);
+        } else if (msg.sender == owner) {
+            _transferSpecificPeriod(msg.sender, _recipient, _amount, currentIndex + 1);
+        } else {
+            _transfer(msg.sender, _recipient, _amount);
+        }
+
+        return true;
+    }
+
+    function increaseAllowance(address _spender, uint256 _addedValue) external returns (bool) {
+        _approve(msg.sender, _spender, _allowances[msg.sender][_spender] + _addedValue);
+        return true;
+    }
+
+    function decreaseAllowance(address _spender, uint256 _subtractedValue) external returns (bool) {
+        uint256 currentAllowance = _allowances[msg.sender][_spender];
+        require(currentAllowance >= _subtractedValue, "KAP22: decreased allowance below zero");
+        _approve(msg.sender, _spender, currentAllowance - _subtractedValue);
+
+        return true;
+    }
+
+    function adminTransfer(
+        address _sender,
+        address _recipient,
+        uint256 _amount
+    ) external override onlyOwner returns (bool) {
+        _transfer(_sender, _recipient, _amount);
+        return true;
+    }
+
+    function adminTransferPreviousPeriod(
+        address _sender,
+        address _recipient,
+        uint256 _amount,
+        uint256 _period
+    ) external onlyOwner returns (bool) {
+        _transferPreviousPeriod(_sender, _recipient, _amount, _period);
+        return true;
+    }
+
+    function internalTransfer(
+        address _sender,
+        address _recipient,
+        uint256 _amount
+    ) external override onlyTransferRouter returns (bool) {
+        require(_isBitkubNext(_sender) && _isBitkubNext(_recipient), "KAP22: only internal purpose");
+
+        _transfer(_sender, _recipient, _amount);
+        return true;
+    }
+
+    function externalTransfer(
+        address _sender,
+        address _recipient,
+        uint256 _amount
+    ) external override onlyTransferRouter returns (bool) {
+        require(_isBitkubNext(_sender), "KAP22: only internal purpose");
+
+        _transfer(_sender, _recipient, _amount);
+        return true;
+    }
+
+    function updatePeriodNow() external {
+        _updatePeriod();
+    }
+
+    function _updatePeriod() internal {
+        while (block.timestamp > (currentIndex * periodLength) + startTime) {
+            currentIndex++;
+        }
+    }
+
+    function _currentPeriod(uint256 _period) internal view returns (uint256) {
+        uint256 newCurrentPeriod = _period;
+
+        while (block.timestamp > (newCurrentPeriod * periodLength) + startTime) {
+            newCurrentPeriod++;
+        }
+
+        return newCurrentPeriod;
+    }
+
+    function _transfer(
+        address _from,
+        address _to,
+        uint256 _amount
+    ) internal updatePeriod {
+        require(_balances[_from][currentIndex] >= _amount, "KAP22: transfer amount exceeds balance");
+
+        _balances[_from][currentIndex] -= _amount;
+        _balances[_to][currentIndex] += _amount;
+
+        emit Transfer(_from, _to, _amount);
+    }
+
+    function _transferSpecificPeriod(
+        address _from,
+        address _to,
+        uint256 _amount,
+        uint256 _period
+    ) internal updatePeriod {
+        require(_balances[_from][_period] >= _amount, "KAP22: transfer amount exceeds balance");
+
+        _balances[_from][_period] -= _amount;
+        _balances[_to][_period] += _amount;
+
+        emit Transfer(_from, _to, _amount);
+    }
+
+    function _transferNextPeriod(
+        address _from,
+        address _to,
+        uint256 _amount
+    ) internal updatePeriod {
+        require(
+            _balances[_from][currentIndex] + _balances[_from][currentIndex + 1] >= _amount,
+            "KAP22: transfer amount exceeds balance"
+        );
+
+        if (_balances[_from][currentIndex] >= _amount) {
+            _balances[_from][currentIndex] -= _amount;
+            _balances[_to][currentIndex] += _amount;
+        } else {
+            uint256 balanceCurrentPeriod = _balances[_from][currentIndex];
+
+            _balances[_from][currentIndex] = 0;
+            _balances[_to][currentIndex] += balanceCurrentPeriod;
+
+            _balances[_from][currentIndex + 1] -= _amount - balanceCurrentPeriod;
+            _balances[_to][currentIndex + 1] += _amount - balanceCurrentPeriod;
+        }
+
+        emit Transfer(_from, _to, _amount);
+    }
+
+    function _transferPreviousPeriod(
+        address _from,
+        address _to,
+        uint256 _amount,
+        uint256 _period
+    ) internal updatePeriod {
+        uint256 remainingToTransfer = _amount;
+        for (uint256 i = _period; i <= currentIndex; i++) {
+            uint256 amountToTransfer = _balances[_from][i];
+            if (amountToTransfer > remainingToTransfer) {
+                amountToTransfer = remainingToTransfer;
+            }
+
+            _balances[_from][i] -= amountToTransfer;
+            _balances[_to][i] += amountToTransfer;
+
+            remainingToTransfer -= amountToTransfer;
+
+            if (remainingToTransfer == 0) {
+                break;
+            }
+        }
+
+        require(remainingToTransfer == 0, "KAP22: transfer amount exceeds balance");
+
+        emit Transfer(_from, _to, _amount);
+    }
+
+    function _approve(
+        address _owner,
+        address _spender,
+        uint256 _amount
+    ) internal updatePeriod {
+        require(_owner != address(0), "KAP22: approve from the zero address");
+        require(_spender != address(0), "KAP22: approve to the zero address");
+
+        _allowances[_owner][_spender] = _amount;
+
+        emit Approval(_owner, _spender, _amount);
+    }
+}