@kub-chain/contracts 1.0.0

package/contracts/token/KAP-1155/interfaces/IKAP1155.sol

@@ -0,0 +1,69 @@
+//SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0 <0.9.0;
+
+import {IKAP165} from "../../../utils/introspections/IKAP165.sol";
+
+interface IKAP1155 is IKAP165 {
+    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
+
+    event TransferBatch(
+        address indexed operator,
+        address indexed from,
+        address indexed to,
+        uint256[] ids,
+        uint256[] values
+    );
+
+    event ApprovalForAll(address indexed account, address indexed operator, bool approved);
+
+    event URI(string value, uint256 indexed id);
+
+    function balanceOf(address account, uint256 id) external view returns (uint256);
+
+    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
+        external
+        view
+        returns (uint256[] memory);
+
+    function setApprovalForAll(address operator, bool approved) external;
+
+    function isApprovedForAll(address account, address operator) external view returns (bool);
+
+    function adminTransfer(
+        address sender,
+        address recipient,
+        uint256 id,
+        uint256 amount
+    ) external;
+
+    function internalTransfer(
+        address sender,
+        address recipient,
+        uint256 id,
+        uint256 amount
+    ) external returns (bool);
+
+    function externalTransfer(
+        address sender,
+        address recipient,
+        uint256 id,
+        uint256 amount
+    ) external returns (bool);
+
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 id,
+        uint256 amount,
+        bytes calldata data
+    ) external;
+
+    function safeBatchTransferFrom(
+        address from,
+        address to,
+        uint256[] calldata ids,
+        uint256[] calldata amounts,
+        bytes calldata data
+    ) external;
+}

package/contracts/token/KAP-1155/interfaces/IKAP1155Enumerable.sol

@@ -0,0 +1,7 @@
+
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IKAP1155Enumerable {
+    function totalSupply() external view returns (uint256);
+}

package/contracts/token/KAP-1155/interfaces/IKAP1155Metadata.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IKAP1155Metadata {
+    function name() external view returns (string memory);
+
+    function symbol() external view returns (string memory);
+
+    function uri(uint256 tokenId) external view returns (string memory);
+
+    function kapURI(uint256 tokenId) external view returns (string memory);
+}

package/contracts/token/KAP-1155/interfaces/IKAP1155Receiver.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IKAP1155Receiver {
+    function onKAP1155Received(
+        address operator,
+        address from,
+        uint256 id,
+        uint256 value,
+        bytes calldata data
+    ) external returns (bytes4);
+
+    function onKAP1155BatchReceived(
+        address operator,
+        address from,
+        uint256[] calldata ids,
+        uint256[] calldata values,
+        bytes calldata data
+    ) external returns (bytes4);
+}

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