Contract Address Details

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

import "./Editor.sol";
import "./Identity.sol";
import "./HitchensUnorderedAddressSet.sol";
import "./OwnableUpgradeable.sol";

// Decentral Publication Contracts v1.0 (contracts/Publication.sol)
/** @title Contract for one specific publication which is owned by the publication's author */
contract Publication is OwnableUpgradeable {
    using HitchensUnorderedAddressSetLib for HitchensUnorderedAddressSetLib.Set;
    // Different roles an endorser can have
    enum EndorserRole{ NONE, READER, SUPERVISOR, EXAMINER }
    // Different states a publication can have
    enum PublicationState{ NONE, SUBMITTED, PUBLISHED, RETRACTED }
    struct Endorsement {
        bool exists;
        string document;
        EndorserRole role;
    }
    // Version of the publication contract
    uint8 public constant version = 1;
    // List of endorsers of the publication
    mapping(address => Endorsement) public endorsers;
    HitchensUnorderedAddressSetLib.Set internal endorsersSet;
    // Identifier of the publishing journal
    uint8 public journal;
    // File hashes for the published document and it's meta data
    string public document;
    string public metadata;
    // State of the publication process
    PublicationState public state;
    // Address of the editor proxy contract
    Editor public editorProxy;
    // Address of the identity proxy contract
    Identity public identityProxy;
    event LogNewPublication(address sender, string document, string metadata, PublicationState state);
    event LogNewEndorsement(address sender, string document, string comment);
    event LogUpdateEndorserRole(address sender, address endorser, string document, EndorserRole oldRole, EndorserRole newRole);
    event LogUpdateEndorsementDocument(address sender, address endorser, string oldDocument, string newDocument);
    event LogUpdateEndorsementComment(address sender, address endorser, string document, string comment);
    event LogEndorsementRevocation(address sender, address endorser, string document, string comment);
    event LogUpdatePublicationDocument(address sender, string oldDocument, string newDocument, string comment);
    event LogUpdatePublicationMetadata(address sender, string oldMetadata, string newMetadata, string comment);
    event LogPublicationPublished(address sender, string document, string metadata);
    event LogPublicationRetraction(address sender, string comment);
    /**
    *  Called by the author to initialize the contract variables
    *  @param _owner Address of the author of the publication
    *  @param _document Off-chain reference to the main document of the publication (e.g., IPFS hash)
    *  @param _metadata Off-chain reference to the publication metadata document (e.g., IPFS hash)
    *  @param _identity Off-chain reference to the identity document (e.g., IPFS hash)
    *  @param _editorProxy Address to the Editor (proxy) contract with which the clones are initialized
    *  @param _identityProxy Address to the Identity (proxy) contract which maps addresses to real world identities
    *  @param _journal Identifier of the publishing journal
    */
    function initialize(address _owner, string memory _document, string memory _metadata, string memory _identity, Editor _editorProxy, Identity _identityProxy, uint8 _journal) external initializer {
        require(
            bytes(_document).length > 0 && 
            bytes(_metadata).length > 0 &&
            bytes(_identity).length > 0, 
            "Input for document, identity, or metadata cannot be empty"
        );    
        identityProxy = _identityProxy;
        try identityProxy.hasIdentity(tx.origin) returns (bool result) {
            if(!result) {
                try identityProxy.addIdentity(_identity) {
                } catch Error(string memory reason){
                    require(false, reason);
                }
            }
        } catch Error(string memory reason){
            require(false, reason);
        }
        editorProxy = _editorProxy;
        journal = _journal;
        document = _document;
        metadata = _metadata;
        state = PublicationState.SUBMITTED;
        emit LogNewPublication(tx.origin, _document, _metadata, state);
        __Ownable_init();
        transferOwnership(_owner);
    }
    /**
    *  Endorse the current publication document hash. Function automatically creates a new mapping
    *  in the Identity contract for the endorser if no mapping exists.
    *  @param _identity Off-chain reference to the identity document (e.g., IPFS hash)
    *  @param _comment Comment of the endorser (e.g., reason for his endorsement)
    */
    function endorse(string memory _identity, string calldata _comment) notRetracted external {
        require(msg.sender != owner(), "Function cannot be called by the contract owner");
        require(!endorsersSet.exists(msg.sender), "Function cannot be called by an endorser");
        try identityProxy.hasIdentity(msg.sender) returns (bool result) {
            if(!result) {
                try identityProxy.addIdentity(_identity) {
                } catch {
                require(false, "Identity could not be stored in Identity contract");
                }
            }
        } catch {
            require(false, "Identity could not be stored in Identity contract");
        }
        endorsersSet.insert(msg.sender);
        endorsers[msg.sender] = Endorsement(true,document,EndorserRole.READER);
        emit LogNewEndorsement(msg.sender, document, _comment);
    }
    /**
    *  Updates the current role assigned to the specified endorser
    *  @param _endorser Address of the endorser whose role is to be updated
    *  @param _role New role to be assigned
    */
    function updateEndorserRole(address _endorser, EndorserRole _role) onlyOwnerOrEditor(keccak256(abi.encodePacked(_endorser,_role))) endorsementExists(_endorser) external {
        require(_role != EndorserRole.NONE, "Invalid endorser role");
        Endorsement memory e = endorsers[_endorser];
        EndorserRole oldRole = e.role;
        e.role = _role;
        endorsers[_endorser] = e;
        emit LogUpdateEndorserRole(msg.sender, _endorser, e.document, oldRole, _role);
    }
    /**
    *  Updates the endorsement of the caller to the current document hash version
    */
    function updateEndorsementDocument() endorsementExists(msg.sender) external {
        string memory oldDocument = endorsers[msg.sender].document;
        endorsers[msg.sender].document = document;
        emit LogUpdateEndorsementDocument(msg.sender, msg.sender, oldDocument, document);
    }
    /**
    *  Updates the endorsement comment of the caller to the provided text
    *  @param _comment New comment of the endorser (e.g., reason for his endorsement)
    */
    function updateEndorsementComment(string calldata _comment) endorsementExists(msg.sender) external {
        emit LogUpdateEndorsementComment(msg.sender, msg.sender, endorsers[msg.sender].document, _comment);
    }
    /**
    *  Updates the endorsement comment of the specified endorser to the provided text
    *  @param _endorser Address of the endorser whose comment is to be updated
    *  @param _comment New comment of the endorser (e.g., reason for his endorsement)
    */        
    function updateEndorsementCommentExt(address _endorser, string calldata _comment) onlyEditor(keccak256(abi.encodePacked(_endorser,_comment))) endorsementExists(_endorser) external {
        emit LogUpdateEndorsementComment(msg.sender, _endorser, endorsers[_endorser].document, _comment);
    }
    /**
    *  Removes the endorsement of the caller from the publication
    *  @param _comment Reason for retracting the endorsement
    */
    function revokeEndorsement(string calldata _comment) endorsementExists(msg.sender) external {
        __deleteEndorsement(msg.sender, _comment);
    }
    /**
    *  Removes the endorsement of the specified endorser from the publication
    *  @param _endorser Address of the endorser whose endorsement is to be revoked
    *  @param _comment Reason for revoking the endorsement
    */
    function revokeEndorsementExt(address _endorser, string calldata _comment) onlyOwnerOrEditor(keccak256(abi.encodePacked(_endorser,_comment))) endorsementExists(_endorser) external {
        __deleteEndorsement(_endorser, _comment);
    }
    /**
    *  Publishes the publication if the contract state includes the required document hashes 
    *  and at least one privileged edorsement (i.e., from an endorser with supervisor or examiner role)
    */
    function publish() onlyEditor(keccak256("")) external {
        require(state == PublicationState.SUBMITTED, "Function requires contract state: submitted");
        require(
            bytes(document).length > 0 && 
            bytes(metadata).length > 0, 
            "Input for document or metadata cannot be empty"
        );  
        uint counter = 0;
        for(uint i = 0; i < endorsersSet.count(); i++) {
            Endorsement memory e = endorsers[endorsersSet.keyAtIndex(i)];
            if((e.role == EndorserRole.SUPERVISOR || e.role == EndorserRole.EXAMINER) && keccak256(bytes(e.document)) == keccak256(bytes(document))) {
                counter++;
            }       
        }
        require(counter >= 1,"Insufficient number of privileged endorsements");
        state = PublicationState.PUBLISHED;
        emit LogPublicationPublished(msg.sender, document, metadata);
    }
    /**
    *  Update the document hash
    *  @param _document Off-chain reference to the new main document of the publication (e.g., IPFS hash)
    *  @param _comment Comment describing the document changes
    */
    function updateDocument(string memory _document, string calldata _comment) onlyOwnerOrEditor(keccak256(abi.encodePacked(_document,_comment))) notRetracted external {
        require(
            bytes(_document).length > 0, 
            "Input for document cannot be empty"
        );
        string memory oldDocument = document;
        document = _document;
        emit LogUpdatePublicationDocument(msg.sender, oldDocument, document, _comment);
    }
    /**
    *  Update the metadata hash
    *  @param _metadata Off-chain reference to the new publication metadata document (e.g., IPFS hash)
    *  @param _comment Comment describing the document changes
    */
    function updateMetadata(string memory _metadata, string calldata _comment) onlyOwnerOrEditor(keccak256(abi.encodePacked(_metadata,_comment))) notRetracted external {
        require(
            bytes(_metadata).length > 0, 
            "Input for metadata cannot be empty"
        );
        string memory oldMetadata = metadata;
        metadata = _metadata;
        emit LogUpdatePublicationMetadata(msg.sender, oldMetadata, metadata, _comment);
    }
    /**
    *  Ireversibly retracts the publication
    *  @param _comment Comment describing the reason for retracting the publication
    */
    function retractPublication(string calldata _comment) onlyOwnerOrEditor(keccak256(abi.encodePacked(_comment))) notRetracted external {
        state = PublicationState.RETRACTED;
        delete document; 
        delete metadata;
        while (endorsersSet.count() > 0) {
            address key = endorsersSet.keyAtIndex(0);
            delete endorsers[key];
            endorsersSet.remove(key);
        }
        delete endorsersSet;
        emit LogPublicationRetraction(msg.sender, _comment);
    }
    /**
    *  Removes the endorsement of the specified endorser from the publication
    *  @param _endorser Address of the endorser whose endorsement is to be removed
    *  @param _comment Reason for removing the endorsement
    */
    function __deleteEndorsement(address _endorser, string calldata _comment) internal {
        endorsersSet.remove(_endorser);
        string memory doc = endorsers[_endorser].document;
        delete endorsers[_endorser];
        emit LogEndorsementRevocation(msg.sender, _endorser, doc, _comment);
    }
    /**
    *  Asserts whether the caller is allowed to perform a certain action
    *  @param _data Encoded description of the action
    */
    function assertEditorialPermission(bytes32 _data) internal view returns (bool) {
        bytes32 action = keccak256(abi.encodePacked(msg.sig,_data));
        try editorProxy.actionAllowed(action) returns (bool allowed) {
            return allowed;
        } catch {
            return false;
        }
    }
    /**
    *  Only editors may perfom the asserted action
    *  @param _data Encoded description of the action
    */
    modifier onlyEditor(bytes32 _data){
        require(assertEditorialPermission(_data), "Function can only be called with editorial access rights");
        _;
    }
    /**
    *  Only the publication author or an editor may perform the asserted action
    *  @param _data Encoded description of the action
    */
    modifier onlyOwnerOrEditor(bytes32 _data){
        require(msg.sender == owner() || assertEditorialPermission(_data), "Function is restricted to the contract owner and editors");
        _;
    }
    /**
    *  Allows to only call a function if the given endorsement exists
    *  @param _endorser Address of the endorser to be admitted
    */
    modifier endorsementExists(address _endorser) {
        require(endorsersSet.exists(_endorser), "No matching endorsement found");
        _;
    }
    /**
    *  Allows to only call a function only if the publication has not been retracted earlier
    */
    modifier notRetracted(){
        require(state != PublicationState.RETRACTED, "Function cannot be called on a retracted publication");
        _;
    }
}
        

// File: @openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }
    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");
        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }
    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }
    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }
    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }
    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }
    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }
    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }
    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}
          

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

// OpenZeppelin Contracts v4.4.1 (proxy/Clones.sol)
/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 *
 * _Available since v3.4._
 */
library ClonesUpgradeable {
    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address implementation) internal returns (address instance) {
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            instance := create(0, ptr, 0x37)
        }
        require(instance != address(0), "ERC1167: create failed");
    }
    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            instance := create2(0, ptr, 0x37, salt)
        }
        require(instance != address(0), "ERC1167: create2 failed");
    }
    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(ptr, 0x14), shl(0x60, implementation))
            mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
            mstore(add(ptr, 0x38), shl(0x60, deployer))
            mstore(add(ptr, 0x4c), salt)
            mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
            predicted := keccak256(add(ptr, 0x37), 0x55)
        }
    }
    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(address implementation, bytes32 salt)
        internal
        view
        returns (address predicted)
    {
        return predictDeterministicAddress(implementation, salt, address(this));
    }
}
          

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

import "./Initializable.sol";
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
 * @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;
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "./Initializable.sol";
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
 * @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 ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
        __Context_init_unchained();
    }
    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
    uint256[50] private __gap;
}
          

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

import "./HitchensUnorderedAddressSet.sol";
import "./OwnableUpgradeable.sol";

// Decentral Publication Contracts v1.0 (contracts/Editor.sol)
/** @title Upgradeable contract for managing editorial functions */
contract Editor is OwnableUpgradeable {
    using HitchensUnorderedAddressSetLib for HitchensUnorderedAddressSetLib.Set;
    // Version of the contract
    uint8 public constant version = 1;
    // Set of current editors
    HitchensUnorderedAddressSetLib.Set internal editorsSet;
    event LogEditorAdded(address con, address sender, address editor);
    event LogEditorRemoved(address sender, address editor);
    /**
    *  Initializes the contract variables. Replaces constructor to enable
    *  upgradeability of the contract.
    */
    function initialize() external initializer {
        __Ownable_init(); // contract creator becomes the owner
        addEditor(tx.origin);
    }
    /**
    *  Removes an editor from the editorial list
    *  @param _editor Address of the editor to be removed
    */
    function removeEditor(address _editor) onlyOwner external {
        editorsSet.remove(_editor);
        emit LogEditorRemoved(msg.sender, _editor);
    }
    /**
    *  Provides a plain array of all editor addresses
    *  @return Address array of all editors
    */
    function getEditors() external view returns (address[] memory) {
        return editorsSet.keyList;
    }
    /**
    *  Checks if a requested action is allowed to be performed by the requesting 
    *  address on the given contract
    *  @return bool True if the action is allowed 
    *  @dev In the current contract version, editors may perform all actions. Future
    *       contract versions may utilize msg.sender (address of the target
    *       contract) and the first parameter (signiture of the requested action) for a
    *       more granular access management system.
    */
    function actionAllowed(bytes32) external view returns (bool) {
        return (isEditor(tx.origin));
    }
    /**
    *  Checks if a given address is an editor
    *  @param _addr Address of the potential editor
    *  @return bool true if it is an editor
    */
    function isEditor(address _addr) public view returns (bool) {
        return (editorsSet.exists(_addr));
    }
    /**
    *  Adds a new editor to the editorial list
    *  @param _addr Address of the editor to be added
    */
    function addEditor(address _addr) onlyOwner public {
        editorsSet.insert(_addr); // will fail automatically if the key already exists.  
        emit LogEditorAdded(address(this), msg.sender, _addr);
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
/*
Hitchens UnorderedAddressSet v0.93
Library for managing CRUD operations in dynamic address sets.
https://github.com/rob-Hitchens/UnorderedKeySet
Copyright (c), 2019, Rob Hitchens, the MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
THIS SOFTWARE IS NOT TESTED OR AUDITED. DO NOT USE FOR PRODUCTION.
*/
library HitchensUnorderedAddressSetLib {
    struct Set {
        mapping(address => uint) keyPointers;
        address[] keyList;
    }
    function insert(Set storage self, address key) internal {
        require(key != address(0), "UnorderedKeySet(100) - Key cannot be 0x0");
        require(!exists(self, key), "UnorderedAddressSet(101) - Address (key) already exists in the set.");
        self.keyList.push(key);
        self.keyPointers[key] = self.keyList.length - 1;
    }
    function remove(Set storage self, address key) internal {
        require(exists(self, key), "UnorderedKeySet(102) - Address (key) does not exist in the set.");
        address keyToMove = self.keyList[count(self)-1];
        uint rowToReplace = self.keyPointers[key];
        self.keyPointers[keyToMove] = rowToReplace;
        self.keyList[rowToReplace] = keyToMove;
        delete self.keyPointers[key];
        self.keyList.pop();
    }
    function count(Set storage self) internal view returns(uint) {
        return(self.keyList.length);
    }
    function exists(Set storage self, address key) internal view returns(bool) {
        if(self.keyList.length == 0) return false;
        return self.keyList[self.keyPointers[key]] == key;
    }
    function keyAtIndex(Set storage self, uint index) internal view returns(address) {
        return self.keyList[index];
    }
}
          

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

import "./Editor.sol";
import "./HitchensUnorderedAddressSet.sol";
import "./OwnableUpgradeable.sol";

// Decentral Publication Contracts v1.0 (contracts/Identity.sol)
/** @title Upgradeable contract for managing the mapping between identities and addesses */
contract Identity is OwnableUpgradeable {
    using HitchensUnorderedAddressSetLib for HitchensUnorderedAddressSetLib.Set;
    struct IDMeta {
        bool exists;
        string metadata;
        bool validated;
    }
    // Version of the contract
    uint8 public constant version = 1;
    // Address of the editor proxy contract
    Editor public editorProxy;
    // Mapping between addresses and a respective identity metadata struct
    HitchensUnorderedAddressSetLib.Set internal identitiesSet;
    mapping(address => IDMeta) public identities;
    // List of blocked addresses that have no write permissions
    HitchensUnorderedAddressSetLib.Set internal blockedSet;
    event LogIdentityAdded(address sender, address identity, string metadata);
    event LogIdentityUpdated(address sender, address identity, string oldMetadata, string newMetadata, string comment);
    event LogIdentityRemoved(address sender, address identity, string metadata, string comment);
    event LogIdentityValidated(address sender, address identity, string comment);
    event LogIdentityInvalidated(address sender, address identity, string comment);
    event LogIdentityBlocked(address sender, address identity, string comment);
    event LogIdentityUnblocked(address sender, address identity, string comment);   
    /**
    *  Initializes the contract variables. Replaces constructor to enable
    *  upgradeability of the contract.
    *  @param _editorProxy Address of the Editor (proxy) contract 
    */
    function initialize(Editor _editorProxy) external initializer {
        editorProxy = _editorProxy;
        __Ownable_init();
    }
    /**
    *  Add new identity mapping between the caller and the given metadata document hash
    *  @param _metadata Off-chain reference to the identity document (e.g., IPFS hash) 
    */
    function addIdentity(string memory _metadata) notBlocked(tx.origin) external {
        __addIdentity(tx.origin, _metadata);
    }
    /**
    *  Add new identity mapping between the given address and the given metadata document hash
    *  @param _addr Address of the account to be mapped to the given identity document hash 
    *  @param _metadata Off-chain reference to the identity document (e.g., IPFS hash) 
    */
    function addIdentityExt(address _addr, string memory _metadata) notBlocked(_addr) onlyEditor external {
        __addIdentity(_addr, _metadata);
    }
    /**
    *  Update the metadata document hash of an existing identity mapping of the caller
    *  @param _metadata Off-chain reference to the new identity document (e.g., IPFS hash) 
    *  @param _comment Comment describing the document changes
    */
    function updateIdentity(string memory _metadata, string calldata _comment) hasIdent(tx.origin) external {
        __updateIdentity(tx.origin, _metadata, _comment);
    }
    /**
    *  Update the metadata document hash of an existing identity mapping of the given address
    *  @param _addr Address of the account whose mapping is to be updated 
    *  @param _metadata Off-chain reference to the new identity document (e.g., IPFS hash) 
    *  @param _comment Comment describing the document changes
    */
    function updateIdentityExt(address _addr, string memory _metadata, string calldata _comment) hasIdent(_addr) onlyEditor external {
        __updateIdentity(_addr, _metadata, _comment);
    }
    /**
    *  Remove the mapping of the caller
    *  @param _comment Comment describing the reason for removing the mapping
    */
    function removeIdentity(string calldata _comment) hasIdent(tx.origin) external {
        __removeIdentity(tx.origin, _comment);
    }
    /**
    *  Remove the mapping of the given address
    *  @param _addr Address of the account whose mapping is to be removed 
    *  @param _comment Comment describing the reason for removing the mapping
    */
    function removeIdentityExt(address _addr, string calldata _comment) hasIdent(_addr) onlyEditor external {
        __removeIdentity(_addr, _comment);
    }
    /**
    *  Change the state of the mapping to validated
    *  @param _addr Address of the account whose mapping is to be updated
    *  @param _comment Comment describing the reason for validating the mapping
    */
    function validate(address _addr, string calldata _comment) hasIdent(_addr) onlyEditor external {
        identities[_addr].validated = true;
        emit LogIdentityValidated(msg.sender, _addr, _comment);
    }
    /**
    *  Change the state of the mapping to invalidated
    *  @param _addr Address of the account whose mapping is to be updated
    *  @param _comment Comment describing the reason for invalidating the mapping
    */
    function invalidate(address _addr, string calldata _comment) hasIdent(_addr) onlyEditor external {
        identities[_addr].validated = false;
        emit LogIdentityInvalidated(msg.sender, _addr, _comment);
    }
    /**
    *  Adding the given address to the block list and removing its mapping
    *  @param _addr Address of the account to be blocked
    *  @param _comment Comment describing the reason for blocking the address
    */
    function blockAddress(address _addr, string calldata _comment) notBlocked(_addr) onlyEditor external {
        if(identitiesSet.exists(_addr)) {
            __removeIdentity(_addr,"Added to blocklist");
        }
        blockedSet.insert(_addr);
        emit LogIdentityBlocked(msg.sender, _addr, _comment);
    }
    /**
    *  Removing the given address from the block list
    *  @param _addr Address of the account to be unblocked
    *  @param _comment Comment describing the reason for unblocking the address
    */
    function unblockAddress(address _addr, string calldata _comment) onlyEditor external {
        require(blockedSet.exists(_addr),"Address is not blocked");
        blockedSet.remove(_addr);
        emit LogIdentityUnblocked(msg.sender, _addr, _comment);
    }
    /**
    *  Setting a new address for the Editor contract, which handels the access management of the 
    *  editorial functions in this contract.
    *  @param _editorProxy Address of the new Editor contract
    */
    function updateEditorProxy(Editor _editorProxy) onlyOwner external {
        editorProxy = _editorProxy;
    }
    /**
    *  Checks if a given address has a validated identity mapping
    *  @param _addr Address to be checked
    *  @return bool True if the validated mapping exists
    */
    function isValidated(address _addr) hasIdent(_addr) external view returns(bool) {
        return identities[_addr].validated;
    }
    /** 
    *  Checks if a given address has an identity mapping
    *  @param _addr Address to be checked
    *  @return bool True if the mapping exists
    */
    function hasIdentity(address _addr) external view returns(bool) {
        return identitiesSet.exists(_addr);
    }
    /** 
    *  Provides a list of all addresses with an identity mapping
    *  @return address[] Array of all mapped addresses
    */
    function getIdentities() external view returns(address[] memory) {
        return identitiesSet.keyList;
    }
    /** 
    *  Checks if a given address is on the block list
    *  @param _addr Address to be checked
    *  @return bool True if the address is on the block list
    */
    function isBlocked(address _addr) external view returns(bool) {
        return blockedSet.exists(_addr);
    }
    /** 
    *  Provides a list of all addresses on the block list
    *  @return address[] Array of all blocked addresses
    */
    function getBlocked() external view returns(address[] memory) {
        return blockedSet.keyList;
    }
    /**
    *  Add new identity mapping between the given address and the given metadata document hash
    *  @param _addr Address of the account to be mapped to the given identity document hash 
    *  @param _metadata Off-chain reference to the identity document (e.g., IPFS hash) 
    */
    function __addIdentity(address _addr, string memory _metadata) internal {
        require(!identitiesSet.exists(_addr),"Identity already exists");
        identitiesSet.insert(_addr);
        identities[_addr] = IDMeta(true,_metadata,false);
        emit LogIdentityAdded(msg.sender, _addr, _metadata);
    }
    /**
    *  Remove the mapping of the given address
    *  @param _addr Address of the account whose mapping is to be removed 
    *  @param _comment Comment describing the reason for removing the mapping
    */
    function __removeIdentity(address _addr, string memory _comment) internal {
        identitiesSet.remove(_addr);
        string memory metadata = identities[_addr].metadata;
        delete identities[_addr];
        emit LogIdentityRemoved(msg.sender, _addr, metadata, _comment);
    }
    /**
    *  Update the metadata document hash of an existing identity mapping of the given address
    *  @param _addr Address of the account whose mapping is to be updated 
    *  @param _metadata Off-chain reference to the new identity document (e.g., IPFS hash) 
    *  @param _comment Comment describing the document changes
    */
    function __updateIdentity(address _addr, string memory _metadata, string calldata _comment) internal {
        string memory oldMetadata = identities[_addr].metadata;
        identities[_addr].metadata = _metadata;
        emit LogIdentityUpdated(msg.sender, _addr, oldMetadata, _metadata, _comment);
        identities[_addr].validated = false;
        emit LogIdentityInvalidated(msg.sender, _addr, "Updated metadata");
    }
    /**
    *  Only editors may perfom the asserted action
    */
    modifier onlyEditor {
        try editorProxy.actionAllowed('') returns (bool allowed) {
            require(allowed, "Function can only be called with editorial access rights");
        } catch {
            require(false, "Editor contract unavailable");
        }
        _;
    }
    /**
    *  Only addresses that are not on the block list may perform the asserted action
    *  @param _addr Address to be checked
    */
    modifier notBlocked(address _addr) {
        require(!blockedSet.exists(_addr), "Address is blocked");
        _;
    }
    /**
    *  Only addresses that have a identity mapping may perform the asserted action
    *  @param _addr Address to be checked
    */
    modifier hasIdent(address _addr) {
        require(identitiesSet.exists(_addr), "No matching identity found");
        _;
    }
}
          

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

import "./AddressUpgradeable.sol";

// OpenZeppelin Contracts v4.4.1 (proxy/utils/Initializable.sol)
/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the
 * initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() initializer {}
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;
    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;
    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        // If the contract is initializing we ignore whether _initialized is set in order to support multiple
        // inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
        // contract may have been reentered.
        require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");
        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
        }
    }
    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} modifier, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }
    function _isConstructor() private view returns (bool) {
        return !AddressUpgradeable.isContract(address(this));
    }
}
          

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

import "./Context.sol";
// OpenZeppelin Contracts v4.4.1 (access/Ownable.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.
 *
 * By default, the owner account will be the one that deploys the contract. 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;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }
    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }
    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }
    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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
pragma solidity ^0.8.12;

import "./Initializable.sol";
import "./ContextUpgradeable.sol";

// OpenZeppelin Contracts v4.4.1 (access/Ownable.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.
 *
 * By default, the owner account will be the one that deploys the contract. 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 OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }
    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }
    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }
    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }
    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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);
    }
    uint256[49] private __gap;
}
          

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

import './Identity.sol';
import './Publication.sol';
import "./HitchensUnorderedAddressSet.sol";
import "./Ownable.sol";
import "./ClonesUpgradeable.sol";

// Decentral Publication Contracts v1.0 (contracts/PublicationFactory.sol)
/** @title Upgradeable factory contract for creating Publication contract clones */
contract PublicationFactory is Ownable {
    using HitchensUnorderedAddressSetLib for HitchensUnorderedAddressSetLib.Set;
    // Master copy for the publication contract clones
    address public publicationImpl;
    // Editor contract 
    Editor public editorProxy;
    // Identity contract 
    Identity public identityProxy;
    // Set of all deployed publication contract clones
    HitchensUnorderedAddressSetLib.Set internal publicationsSet;
    event LogPublicationContractCreated(address addr, address sender);
    /**
    *  Constructur sets the master copy contract for the factory and
    *  the address of the Editor (proxy) contract.
    *  @param _publicationImpl Address to the master copy contract for the clone factory
    *  @param _editorProxy Address to the Editor (proxy) contract with which the clones are initialized
    *  @param _identityProxy Address to the Identity (proxy) contract which maps addresses to real world identities
    */
    constructor (address _publicationImpl, address _editorProxy, address _identityProxy) {
        publicationImpl = _publicationImpl;
        editorProxy = Editor(_editorProxy);
        identityProxy = Identity(_identityProxy);
    }
    /**
    *  Creates a clone of the the maste copy publication contract. To be called by the author of the publication to initiate the
    *  submission process. The clone is initialized with the provided submission documents (location of the main document and 
    *  respectiv metadata) and the owner of the cloned contract is set to sender's address. 
    *  The addresses of all clones are automatically stored in the publicationsSet.
    *  @param _document Off-chain reference to the main document of the publication (e.g., IPFS hash)
    *  @param _metadata Off-chain reference to the publication metadata document (e.g., IPFS hash)
    *  @param _identity Off-chain reference to the identity document (e.g., IPFS hash)
    *  @return address Address of the newly created contract clone 
    */
    function createPublication(string memory _document, string memory _metadata, string memory _identity) external returns (address){
        address clone = ClonesUpgradeable.clone(publicationImpl);
        try Publication(clone).initialize(msg.sender, _document, _metadata, _identity, editorProxy, identityProxy, 1) {
            //require(initialized, "publication initialization failed");
        } catch Error(string memory reason){
            require(false, reason);
        }
        publicationsSet.insert(clone);
        emit LogPublicationContractCreated(clone, msg.sender);
        return clone;
    }
    /**
    *  Returns the addresses of all clone contracts created by the factory
    *  @return address[] Array of clone contract addresses
    */
    function getPublications() external view returns (address[] memory) {
        return publicationsSet.keyList;
    }
}