| // SPDX-License-Identifier: MIT |
| pragma solidity ^0.8.20; |
|
|
| import {ERC721URIStorage, ERC721} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol"; |
| import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol"; |
| import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol"; |
| import {Pausable} from "@openzeppelin/contracts/utils/Pausable.sol"; |
| import {IERC5192} from "./interfaces/IERC5192.sol"; |
|
|
| /** |
| * @title KatchSignals |
| * @author Katch Team |
| * @notice Soulbound NFT contract for minting user signals and recording likes on-chain |
| * @dev ERC-721 + ERC-5192 soulbound contract with role-based access control and pause functionality. |
| * NFTs are non-transferable — users cannot transfer, sell, or trade signals. |
| * |
| * Roles: |
| * - OWNER_ROLE: Cold wallet (Ledger/Safe) - manages admin, pause, ownership transfer |
| * - ADMIN_ROLE: Hot wallet (backend) - mint, burn, like, setTokenURI |
| * |
| * Key features: |
| * - Soulbound (ERC-5192): all tokens are permanently locked |
| * - Only admin can mint signals to users |
| * - On-chain like tracking (one like per user per signal) |
| * - Two-step ownership transfer for safety |
| * - Pausable: owner can pause admin operations |
| */ |
| contract KatchSignals is ERC721URIStorage, AccessControl, Pausable, IERC5192 { |
| /*////////////////////////////////////////////////////////////// |
| ROLES |
| //////////////////////////////////////////////////////////////*/ |
| |
| /// @notice Role identifier for the contract owner (cold wallet) |
| bytes32 public constant OWNER_ROLE = keccak256("OWNER_ROLE"); |
| /// @notice Role identifier for the admin (hot wallet) |
| bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE"); |
| |
| /*////////////////////////////////////////////////////////////// |
| ERRORS |
| //////////////////////////////////////////////////////////////*/ |
| |
| /// @notice Thrown when setting address to zero |
| error InvalidAddress(); |
|
|
| /// @notice Thrown when attempting a disabled transfer |
| error TransfersDisabled(); |
| |
| /// @notice Thrown when attempting a disabled approval |
| error ApprovalsDisabled(); |
|
|
| /// @notice Thrown when caller is not the pending owner |
| error NotPendingOwner(); |
| |
| /// @notice Thrown when attempting to use direct AccessControl role management |
| error RoleManagementDisabled(); |
|
|
| /// @notice Thrown when array lengths do not match |
| error ArrayLengthMismatch(); |
| |
| /// @notice Thrown when new admin is the same as current admin |
| error AdminNotChanged(); |
|
|
| /*////////////////////////////////////////////////////////////// |
| EVENTS |
| //////////////////////////////////////////////////////////////*/ |
|
|
| /// @notice Emitted when a new signal is minted |
| event SignalMinted(uint256 indexed signalId, address indexed to, string tokenURI); |
| |
| /// @notice Emitted when a signal is burned |
| event SignalBurned(uint256 indexed signalId, address indexed owner); |
|
|
| /// @notice Emitted when a signal is liked |
| event SignalLiked(uint256 indexed signalId, address indexed liker); |
| |
| /// @notice Emitted when a signal is unliked |
| event SignalUnliked(uint256 indexed signalId, address indexed liker); |
|
|
| /// @notice Emitted when a signal's URI is updated |
| event SignalURIUpdated(uint256 indexed signalId, string newURI); |
| |
| /// @notice Emitted when admin role is changed |
| event AdminChanged(address indexed oldAdmin, address indexed newAdmin); |
|
|
| /// @notice Emitted when ownership transfer is initiated |
| event OwnershipTransferStarted(address indexed currentOwner, address indexed pendingOwner); |
| |
| /// @notice Emitted when ownership transfer is completed |
| event OwnershipTransferred(address indexed oldOwner, address indexed newOwner); |
|
|
| /// @notice Emitted when ownership transfer is cancelled |
| event OwnershipTransferCancelled(address indexed currentOwner, address indexed cancelledPendingOwner); |
| |
| /*////////////////////////////////////////////////////////////// |
| STORAGE |
| //////////////////////////////////////////////////////////////*/ |
| |
| /// @notice The current owner address |
| address private _owner; |
|
|
| /// @notice The pending owner for two-step ownership transfer |
| address public pendingOwner; |
| |
| /// @notice The current admin address |
| address public admin; |
|
|
| /// @notice Auto-increment counter for signal IDs (starts at 1) |
| uint256 private _nextSignalId; |
| |
| /// @notice Tracks whether a user has liked a specific signal |
| mapping(uint256 => mapping(address => bool)) private _likes; |
|
|
| /// @notice Tracks the number of likes per signal |
| mapping(uint256 => uint256) private _likesCount; |
| |
| /*////////////////////////////////////////////////////////////// |
| CONSTRUCTOR |
| //////////////////////////////////////////////////////////////*/ |
| |
| /** |
| * @notice Deploys the KatchSignals contract |
| * @param owner_ The owner address (cold wallet) |
| * @param admin_ The admin address (hot wallet) |
| */ |
| constructor( |
| address owner_, |
| address admin_ |
| ) ERC721("[katch] signals", "SIGNAL") { |
| if (owner_ == address(0)) revert InvalidAddress(); |
| if (admin_ == address(0)) revert InvalidAddress(); |
| |
| _grantRole(OWNER_ROLE, owner_); |
| _grantRole(ADMIN_ROLE, admin_); |
| |
| _setRoleAdmin(ADMIN_ROLE, OWNER_ROLE); |
| _setRoleAdmin(OWNER_ROLE, OWNER_ROLE); |
| |
| _owner = owner_; |
| admin = admin_; |
| _nextSignalId = 1; |
| } |
| |
| /*////////////////////////////////////////////////////////////// |
| DISABLED ERC721 FUNCTIONS |
| //////////////////////////////////////////////////////////////*/ |
| |
| /// @notice Disabled. Signals are soulbound and cannot be transferred. |
| function transferFrom(address, address, uint256) public pure override(ERC721, IERC721) { |
| revert TransfersDisabled(); |
| } |
|
|
| /// @notice Disabled. Signals are soulbound and cannot be transferred. |
| function safeTransferFrom(address, address, uint256, bytes memory) public pure override(ERC721, IERC721) { |
| revert TransfersDisabled(); |
| } |
| |
| /// @notice Disabled. Approvals are not needed for soulbound tokens. |
| function approve(address, uint256) public pure override(ERC721, IERC721) { |
| revert ApprovalsDisabled(); |
| } |
|
|
| /// @notice Disabled. Approvals are not needed for soulbound tokens. |
| function setApprovalForAll(address, bool) public pure override(ERC721, IERC721) { |
| revert ApprovalsDisabled(); |
| } |
| |
| /*////////////////////////////////////////////////////////////// |
| ADMIN FUNCTIONS |
| //////////////////////////////////////////////////////////////*/ |
| |
| /** |
| * @notice Mints a soulbound signal NFT to a user |
| * @param to The recipient address |
| * @param uri The token URI (metadata URL) |
| */ |
| function mint(address to, string calldata uri) external onlyRole(ADMIN_ROLE) whenNotPaused { |
| uint256 signalId; |
| unchecked { signalId = _nextSignalId++; } // overflow unrealistic for NFT counter |
| _mint(to, signalId); |
| _setTokenURI(signalId, uri); |
| |
| emit SignalMinted(signalId, to, uri); |
| emit Locked(signalId); |
| } |
| |
| /** |
| * @notice Burns a signal NFT (content moderation) |
| * @param signalId The ID of the signal to burn |
| */ |
| function burn(uint256 signalId) external onlyRole(ADMIN_ROLE) whenNotPaused { |
| address signalOwner = _requireOwned(signalId); |
| _burn(signalId); |
| delete _likesCount[signalId]; |
| |
| emit SignalBurned(signalId, signalOwner); |
| } |
| |
| /** |
| * @notice Toggles a like on a signal (like/unlike) |
| * @dev First call = like, second call = unlike, third = like, etc. |
| * @param signalId The ID of the signal to toggle like on |
| * @param liker The address of the user toggling the like |
| */ |
| function like(uint256 signalId, address liker) external onlyRole(ADMIN_ROLE) whenNotPaused { |
| _requireOwned(signalId); |
| if (liker == address(0)) revert InvalidAddress(); |
| |
| if (_likes[signalId][liker]) { |
| _likes[signalId][liker] = false; |
| unchecked { _likesCount[signalId]--; } |
| |
| emit SignalUnliked(signalId, liker); |
| } else { |
| _likes[signalId][liker] = true; |
| unchecked { _likesCount[signalId]++; } |
| |
| emit SignalLiked(signalId, liker); |
| } |
| } |
| |
| /** |
| * @notice Updates the token URI of an existing signal |
| * @param signalId The ID of the signal to update |
| * @param newURI The new token URI |
| */ |
| function setSignalURI(uint256 signalId, string calldata newURI) external onlyRole(ADMIN_ROLE) whenNotPaused { |
| _requireOwned(signalId); |
| _setTokenURI(signalId, newURI); |
| |
| emit SignalURIUpdated(signalId, newURI); |
| } |
| |
| /** |
| * @notice Batch updates token URIs for multiple signals |
| * @param signalIds Array of signal IDs to update |
| * @param newURIs Array of new token URIs (must match signalIds length) |
| */ |
| function setSignalURIBatch(uint256[] calldata signalIds, string[] calldata newURIs) external onlyRole(ADMIN_ROLE) whenNotPaused { |
| if (signalIds.length != newURIs.length) revert ArrayLengthMismatch(); |
| |
| for (uint256 i; i < signalIds.length; ) { |
| _requireOwned(signalIds[i]); |
| _setTokenURI(signalIds[i], newURIs[i]); |
| emit SignalURIUpdated(signalIds[i], newURIs[i]); |
| unchecked { i++; } |
| } |
| } |
| |
| /*////////////////////////////////////////////////////////////// |
| OWNER FUNCTIONS |
| //////////////////////////////////////////////////////////////*/ |
| |
| /** |
| * @notice Changes the admin address |
| * @dev Works even when contract is paused. |
| * @param newAdmin The new admin address |
| */ |
| function setAdmin(address newAdmin) external onlyRole(OWNER_ROLE) { |
| if (newAdmin == address(0)) revert InvalidAddress(); |
| |
| address oldAdmin = admin; |
| if (newAdmin == oldAdmin) revert AdminNotChanged(); |
| |
| _revokeRole(ADMIN_ROLE, oldAdmin); |
| _grantRole(ADMIN_ROLE, newAdmin); |
| |
| admin = newAdmin; |
| |
| emit AdminChanged(oldAdmin, newAdmin); |
| } |
| |
| /// @notice Pauses admin operations (mint, burn, like, setSignalURI) |
| function pause() external onlyRole(OWNER_ROLE) { |
| _pause(); |
| } |
|
|
| /// @notice Unpauses admin operations |
| function unpause() external onlyRole(OWNER_ROLE) { |
| _unpause(); |
| } |
| |
| /** |
| * @notice Starts ownership transfer to a new address (step 1 of 2) |
| * @param newOwner The address to transfer ownership to |
| */ |
| function transferOwnership(address newOwner) external onlyRole(OWNER_ROLE) { |
| if (newOwner == address(0)) revert InvalidAddress(); |
| |
| pendingOwner = newOwner; |
| |
| emit OwnershipTransferStarted(msg.sender, newOwner); |
| } |
| |
| /** |
| * @notice Cancels a pending ownership transfer |
| */ |
| function cancelTransferOwnership() external onlyRole(OWNER_ROLE) { |
| address cancelled = pendingOwner; |
| pendingOwner = address(0); |
| |
| emit OwnershipTransferCancelled(msg.sender, cancelled); |
| } |
| |
| /** |
| * @notice Completes ownership transfer (step 2 of 2) |
| * @dev Must be called by the pending owner |
| */ |
| function acceptOwnership() external { |
| if (msg.sender != pendingOwner) revert NotPendingOwner(); |
| |
| address oldOwner = _owner; |
| |
| _revokeRole(OWNER_ROLE, oldOwner); |
| _grantRole(OWNER_ROLE, msg.sender); |
| |
| _owner = msg.sender; |
| pendingOwner = address(0); |
| |
| emit OwnershipTransferred(oldOwner, msg.sender); |
| } |
| |
| /*////////////////////////////////////////////////////////////// |
| DISABLED ACCESSCONTROL FUNCTIONS |
| //////////////////////////////////////////////////////////////*/ |
| |
| /// @notice Disabled. Use setAdmin() to change the admin role. |
| function grantRole(bytes32, address) public pure override { |
| revert RoleManagementDisabled(); |
| } |
|
|
| /// @notice Disabled. Use setAdmin() to change the admin role. |
| function revokeRole(bytes32, address) public pure override { |
| revert RoleManagementDisabled(); |
| } |
| |
| /// @notice Disabled. Use setAdmin() or transferOwnership() instead. |
| function renounceRole(bytes32, address) public pure override { |
| revert RoleManagementDisabled(); |
| } |
|
|
| /*////////////////////////////////////////////////////////////// |
| VIEW FUNCTIONS |
| //////////////////////////////////////////////////////////////*/ |
| |
| /// @notice Returns the number of likes for a signal |
| function likesCount(uint256 signalId) external view returns (uint256) { |
| _requireOwned(signalId); |
| return _likesCount[signalId]; |
| } |
|
|
| /// @notice Returns whether a user has liked a specific signal |
| function hasLiked(uint256 signalId, address user) external view returns (bool) { |
| _requireOwned(signalId); |
| return _likes[signalId][user]; |
| } |
| |
| /// @notice Returns the current owner address |
| function owner() external view returns (address) { |
| return _owner; |
| } |
|
|
| /// @notice Checks if an address has the OWNER_ROLE |
| function hasRoleOwner(address account) external view returns (bool) { |
| return hasRole(OWNER_ROLE, account); |
| } |
| |
| /// @notice Checks if an address has the ADMIN_ROLE |
| function hasRoleAdmin(address account) external view returns (bool) { |
| return hasRole(ADMIN_ROLE, account); |
| } |
|
|
| /*////////////////////////////////////////////////////////////// |
| ERC-5192 (SOULBOUND) |
| //////////////////////////////////////////////////////////////*/ |
| |
| /// @notice Returns the locking status of a token. Always true — all signals are soulbound. |
| /// @param tokenId The token to check |
| /// @return True (always locked) |
| function locked(uint256 tokenId) external view returns (bool) { |
| _requireOwned(tokenId); |
| return true; |
| } |
|
|
| /*////////////////////////////////////////////////////////////// |
| INTERFACE SUPPORT |
| //////////////////////////////////////////////////////////////*/ |
| |
| /// @notice Returns true if the contract supports the given interface |
| function supportsInterface(bytes4 interfaceId) |
| public |
| view |
| override(ERC721URIStorage, AccessControl) |
| returns (bool) |
| { |
| return interfaceId == type(IERC5192).interfaceId || super.supportsInterface(interfaceId); |
| } |
| } |
|
|
