Contract Address Details

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "./AdminZamik.sol";

/**
 * @title EntropyOracle
 * @notice Collects validator entropy from PulseChain block data
 * @dev Uses block.prevrandao (post-merge randomness) + validator signatures
 *      as entropy sources for ZK circuit inputs
 *
 * Hardening (v2) — iz varnostnega pregleda (Copilot/Gemini + verifikacija):
 *  - deauthorizeValidator(): možnost odvzema pooblastila (kompromitiran validator)
 *  - commitEntropy(): require(entropyHash != 0) — prepreči neveljavne/uninicializirane zapise
 *  - getEntropy(): bounds check → revert namesto vračanja bytes32(0)
 *  - dogodki: ValidatorDeauthorized, EntropyMarkedUsed; validator je 'indexed'
 *  OPOMBA: zaupanje v off-chain validatorja (entropyHash ni on-chain preverjen
 *  proti block.prevrandao) ostaja po zasnovi. Varnost uporabnika nosi entropija
 *  12-besedne kode (pk), ne ta vrednost. Za večjo trust-minimizacijo razmisli o
 *  mešanju on-chain entropije: keccak256(block.prevrandao, msg.sender, recordCount).
 */
contract EntropyOracle is Ownable, AdminZamik {
    struct EntropyRecord {
        bytes32 entropyHash;
        uint256 blockNumber;
        uint256 timestamp;
        address validator;
        bool used;
    }

    mapping(uint256 => EntropyRecord) public entropyRecords;
    mapping(address => bool) public authorizedValidators;
    uint256 public recordCount;

    event EntropyCommitted(uint256 indexed recordId, bytes32 entropyHash, address indexed validator);
    event ValidatorAuthorized(address indexed validator);
    event ValidatorDeauthorized(address indexed validator);
    event EntropyMarkedUsed(uint256 indexed recordId);

    constructor() Ownable(msg.sender) {}

    /**
     * @notice Validator commits entropy derived from block randomness
     * @dev entropyHash = keccak256(block.prevrandao + validatorSig + nonce)
     */
    function commitEntropy(bytes32 entropyHash) external returns (uint256 recordId) {
        require(authorizedValidators[msg.sender], "Not authorized validator");
        require(entropyHash != bytes32(0), "Zero entropy");
        recordId = recordCount++;
        entropyRecords[recordId] = EntropyRecord({
            entropyHash: entropyHash,
            blockNumber: block.number,
            timestamp: block.timestamp,
            validator: msg.sender,
            used: false
        });
        emit EntropyCommitted(recordId, entropyHash, msg.sender);
    }

    function getEntropy(uint256 recordId) external view returns (bytes32) {
        require(recordId < recordCount, "Invalid record index");
        return entropyRecords[recordId].entropyHash;
    }

    function markUsed(uint256 recordId) external onlyOwner {
        require(recordId < recordCount, "Invalid record index");
        entropyRecords[recordId].used = true;
        emit EntropyMarkedUsed(recordId);
    }

    /**
     * PODELITEV MOCI GRE SKOZI ZAMIK, ODVZEM NE.
     *
     * Pooblascen validator vnasa entropijo, na kateri slonijo commitmenti.
     * Podtaknjen validator je zato napad na sam vir nakljucja — in je viden
     * vnaprej, zato javna napoved + zamik.
     *
     * deauthorizeValidator ostaja takojsen: ob kompromitiranem kljucu je treba
     * ukrepati zdaj.
     */
    function napoviAuthorizeValidator(address validator) external onlyOwner {
        require(validator != address(0), "Zero address");
        _napovej(keccak256(abi.encode("authorizeValidator", validator)), "EntropyOracle.authorizeValidator");
    }

    function authorizeValidator(address validator) external onlyOwner {
        require(validator != address(0), "Zero address");
        _porabi(keccak256(abi.encode("authorizeValidator", validator)), "EntropyOracle.authorizeValidator");
        authorizedValidators[validator] = true;
        emit ValidatorAuthorized(validator);
    }

    /// @notice Odvzame pooblastilo validatorju (npr. ob kompromitaciji ključa).
    function deauthorizeValidator(address validator) external onlyOwner {
        authorizedValidators[validator] = false;
        emit ValidatorDeauthorized(validator);
    }

    /// @notice Onemogoceno: renounceOwnership() bi trajno onemogocil
    ///         (de)avtorizacijo validatorjev — oracle bi ostal zamrznjen.
    function renounceOwnership() public pure override {
        revert("Renounce onemogocen");
    }
}
        

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}
          

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

import "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title AdminZamik
 * @notice Casovni zamik na nevarne admin spremembe.
 *
 * ZAKAJ TO OBSTAJA
 * ----------------
 * Owner kljuc na tej platformi NE more krasti: ne more kovati zetonov, ne more
 * premikati tujih zetonov in ne more v escrow. Kar PA lahko, je tiho zamenjati
 * nastavitve pod nogami uporabnikov — KYC listo, placilni token, prijavljeno
 * vrednost sredstva.
 *
 * Vsi trije so napadi, ki jih je mogoce VIDETI VNAPREJ. Zato jih ne branimo z
 * multisigom (ki varuje lastnika kljuca), ampak s casovnim zamikom (ki varuje
 * UPORABNIKA): sprememba se mora najprej javno napovedati, sele po zamiku jo je
 * mogoce izvesti. Uporabnik ima ves ta cas, da spremembo vidi in izstopi.
 *
 * Namenoma NI zunanje timelock pogodbe kot lastnika. Tak vzorec doda tveganje
 * nedosegljivosti: ce lastniku kdaj ne uspe sestaviti transakcije skozi tujo
 * pogodbo, so kontrakti zamrznjeni za vedno. Tu je zamik vgrajen, lastnik pa
 * ostane navadna denarnica.
 *
 * KAJ ZAMIK NE POKRIVA (namerno)
 * ------------------------------
 *   - pause()   — zasilna zavora mora biti takojsnja, sicer ni zavora
 *   - unpause() — vrnitev v obratovanje naj bo hitra
 *   - odvzem pravice zaustavljalca — ob razkritem kljucu ga moras vreci TAKOJ
 * Nevarnost caka, zasilna zavora ne.
 */
abstract contract AdminZamik is Ownable {
    /// @notice Rok, v katerem je napoved uporabna. Po njem potece.
    /// @dev Brez tega bi stara napoved lezala na verigi kot nabita puska:
    ///      napoves nekaj neopaznega danes, izvedes cez pol leta, ko nihce vec
    ///      ne gleda. Napoved, ki ni bila izvedena v roku, je treba ponoviti.
    uint256 public constant ROK = 7 days;

    /// @notice id napovedi → cas, od katerega je izvedljiva (0 = ni napovedi)
    mapping(bytes32 => uint256) public izvedljivoOd;

    event SpremembaNapovedana(bytes32 indexed id, string kaj, uint256 izvedljivoOd, uint256 potece);
    event SpremembaIzvedena(bytes32 indexed id, string kaj);
    event SpremembaPreklicana(bytes32 indexed id, string kaj);

    /// @notice Koliko casa mora sprememba cakati.
    ///
    /// ⚠️⚠️ TRENUTNO 10 MINUT — RAZVOJNA VREDNOST ZA TESTNET (943).
    ///      Nastavljeno 24. 8. 2026 po Juretovi odlocitvi. Projekt se razvija
    ///      izkljucno na testnetu; mainnet je na pavzi.
    ///
    ///      PRED KAKRSNIMKOLI DEPLOYEM NA MAINNET (369) VRNI NA 48 ur.
    ///      Deset minut zamika na mainnetu pomeni, da napadalec z admin
    ///      kljucem izvede spremembo, preden jo utegnes opaziti — zamik je
    ///      takrat videti prisoten, a je brez ucinka.
    ///
    /// @dev virtual ostaja, da lahko posamezna pogodba vrednost se povozi
    ///      (MarketplaceTestnet to pocne).
    function zamik() public view virtual returns (uint256) {
        return 10 minutes;
    }

    // ── Notranje ────────────────────────────────────────────────────────────

    /// @dev id MORA vsebovati tocne parametre spremembe, sicer bi lahko
    ///      napovedal nedolzno vrednost in izvedel skodljivo.
    function _napovej(bytes32 id, string memory kaj) internal {
        require(izvedljivoOd[id] == 0, "Ze napovedano");
        uint256 od = block.timestamp + zamik();
        izvedljivoOd[id] = od;
        emit SpremembaNapovedana(id, kaj, od, od + ROK);
    }

    function _porabi(bytes32 id, string memory kaj) internal {
        uint256 od = izvedljivoOd[id];
        require(od != 0, "Ni napovedano");
        require(block.timestamp >= od, "Zamik se ni potekel");
        require(block.timestamp <= od + ROK, "Napoved je potekla");
        delete izvedljivoOd[id];
        emit SpremembaIzvedena(id, kaj);
    }

    // ── Javno ───────────────────────────────────────────────────────────────

    /// @notice Preklic napovedane spremembe. Takojsen — premisliti se mora biti
    ///         mogoce hitreje, kot se izvede.
    function prekliciSpremembo(bytes32 id, string calldata kaj) external onlyOwner {
        require(izvedljivoOd[id] != 0, "Ni napovedano");
        delete izvedljivoOd[id];
        emit SpremembaPreklicana(id, kaj);
    }

    /// @notice Stanje napovedi — da ga stran in nadzorni sistem lahko prikazeta.
    function stanjeNapovedi(bytes32 id)
        external
        view
        returns (bool napovedana, uint256 od, uint256 potece, bool izvedljivaZdaj)
    {
        uint256 t = izvedljivoOd[id];
        if (t == 0) return (false, 0, 0, false);
        return (true, t, t + ROK, block.timestamp >= t && block.timestamp <= t + ROK);
    }
}