Contract 0x9fa4f2c292f5e57ae59d786d1275e1623dada93c

// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;

import "./ERC2771Context.sol";
import "./MinimalForwarder.sol";

/**
 * @title FileRegistry for GhostShare.xyz
 * @dev Main contract, which handles file tracing and access control.
 */
contract FileRegistry is ERC2771Context {
    /* ------------------------------ DATA STORAGE ------------------------------ */
    struct File {
        address fileOwner;
        mapping(address => bool) accessRights;
    }

    mapping(bytes32 => File) public files;

    /* --------------------------------- EVENTS --------------------------------- */
    event FileRegistered(bytes32 fileId, address indexed fileOwner);
    event AccessGranted(
        bytes32 fileId,
        address indexed fileOwner,
        address indexed recipient
    );
    event AccessRevoked(
        bytes32 fileId,
        address indexed fileOwner,
        address indexed recipient
    );

    /* -------------------------------- MODIFIERS ------------------------------- */
    modifier onlyFileOwner(bytes32 fileId) {
        require(
            files[fileId].fileOwner == _msgSender(),
            "FileRegistry::onlyFileOwner: You do not have access."
        );
        _;
    }

    /* ------------------------------- CONSTRUCTOR ------------------------------ */
    constructor(MinimalForwarder forwarder)
        ERC2771Context(address(forwarder))
    {}

    /* -------------------------------------------------------------------------- */
    /*                                  FUNCTIONS                                 */
    /* -------------------------------------------------------------------------- */

    function registerFile(bytes32 fileId) public returns (bool fileRegistered) {
        require(
            files[fileId].fileOwner == address(0),
            "FileRegistry::registerFile: File already exists."
        );
        address msgSender = _msgSender();
        files[fileId].fileOwner = msgSender;
        files[fileId].accessRights[msgSender] = true;
        emit FileRegistered(fileId, msgSender);
        return true;
    }

    function grantAccess(bytes32 fileId, address recipient)
        public
        onlyFileOwner(fileId)
        returns (bool accessGranted)
    {
        require(
            !files[fileId].accessRights[recipient],
            "FileRegistry::grantAccess: Recipient is already granted."
        );
        files[fileId].accessRights[recipient] = true;
        emit AccessGranted(fileId, files[fileId].fileOwner, recipient);
        return true;
    }

    function revokeAccess(bytes32 fileId, address recipient)
        public
        onlyFileOwner(fileId)
        returns (bool accessRevoked)
    {
        require(
            files[fileId].accessRights[recipient],
            "FileRegistry::revokeAccess: No access is granted to this Recipient."
        );
        files[fileId].accessRights[recipient] = false;
        emit AccessRevoked(fileId, files[fileId].fileOwner, recipient);
        return true;
    }

    function hasAccess(bytes32 fileId, address recipient)
        public
        view
        returns (bool _hasAccess)
    {
        return files[fileId].accessRights[recipient];
    }

    /* ----------------------------- HELPER FUNCTION ---------------------------- */
    function hashHelper(string memory CID) public pure returns (bytes32 hash) {
        return keccak256(abi.encodePacked(CID));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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
// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "./Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature)
        internal
        pure
        returns (address, RecoverError)
    {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature)
        internal
        pure
        returns (address)
    {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs &
            bytes32(
                0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
            );
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (
            uint256(s) >
            0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0
        ) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash)
        internal
        pure
        returns (bytes32)
    {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return
            keccak256(
                abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)
            );
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked(
                    "\x19Ethereum Signed Message:\n",
                    Strings.toString(s.length),
                    s
                )
            );
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked("\x19\x01", domainSeparator, structHash)
            );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol)

pragma solidity ^0.8.0;

import "./ECDSA.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(
            typeHash,
            hashedName,
            hashedVersion
        );
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (
            address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID
        ) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return
                _buildDomainSeparator(
                    _TYPE_HASH,
                    _HASHED_NAME,
                    _HASHED_VERSION
                );
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    typeHash,
                    nameHash,
                    versionHash,
                    block.chainid,
                    address(this)
                )
            );
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash)
        internal
        view
        virtual
        returns (bytes32)
    {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (metatx/ERC2771Context.sol)

pragma solidity ^0.8.9;

import "./Context.sol";

/**
 * @dev Context variant with ERC2771 support.
 */
abstract contract ERC2771Context is Context {
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
    address private immutable _trustedForwarder;

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor(address trustedForwarder) {
        _trustedForwarder = trustedForwarder;
    }

    function isTrustedForwarder(address forwarder)
        public
        view
        virtual
        returns (bool)
    {
        return forwarder == _trustedForwarder;
    }

    function _msgSender()
        internal
        view
        virtual
        override
        returns (address sender)
    {
        if (isTrustedForwarder(msg.sender)) {
            // The assembly code is more direct than the Solidity version using `abi.decode`.
            assembly {
                sender := shr(96, calldataload(sub(calldatasize(), 20)))
            }
        } else {
            return super._msgSender();
        }
    }

    function _msgData()
        internal
        view
        virtual
        override
        returns (bytes calldata)
    {
        if (isTrustedForwarder(msg.sender)) {
            return msg.data[:msg.data.length - 20];
        } else {
            return super._msgData();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (metatx/MinimalForwarder.sol)

pragma solidity ^0.8.0;

import "./ECDSA.sol";
import "./EIP712.sol";

/**
 * @dev Simple minimal forwarder to be used together with an ERC2771 compatible contract. See {ERC2771Context}.
 */
contract MinimalForwarder is EIP712 {
    using ECDSA for bytes32;

    struct ForwardRequest {
        address from;
        address to;
        uint256 value;
        uint256 gas;
        uint256 nonce;
        bytes data;
    }

    bytes32 private constant _TYPEHASH =
        keccak256(
            "ForwardRequest(address from,address to,uint256 value,uint256 gas,uint256 nonce,bytes data)"
        );

    mapping(address => uint256) private _nonces;

    constructor() EIP712("MinimalForwarder", "0.0.1") {}

    function getNonce(address from) public view returns (uint256) {
        return _nonces[from];
    }

    function verify(ForwardRequest calldata req, bytes calldata signature)
        public
        view
        returns (bool)
    {
        address signer = _hashTypedDataV4(
            keccak256(
                abi.encode(
                    _TYPEHASH,
                    req.from,
                    req.to,
                    req.value,
                    req.gas,
                    req.nonce,
                    keccak256(req.data)
                )
            )
        ).recover(signature);
        return _nonces[req.from] == req.nonce && signer == req.from;
    }

    function execute(ForwardRequest calldata req, bytes calldata signature)
        public
        payable
        returns (bool, bytes memory)
    {
        require(
            verify(req, signature),
            "MinimalForwarder: signature does not match request"
        );
        _nonces[req.from] = req.nonce + 1;

        (bool success, bytes memory returndata) = req.to.call{
            gas: req.gas,
            value: req.value
        }(abi.encodePacked(req.data, req.from));

        // Validate that the relayer has sent enough gas for the call.
        // See https://ronan.eth.link/blog/ethereum-gas-dangers/
        if (gasleft() <= req.gas / 63) {
            // We explicitly trigger invalid opcode to consume all gas and bubble-up the effects, since
            // neither revert or assert consume all gas since Solidity 0.8.0
            // https://docs.soliditylang.org/en/v0.8.0/control-structures.html#panic-via-assert-and-error-via-require
            assembly {
                invalid()
            }
        }

        return (success, returndata);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length)
        internal
        pure
        returns (string memory)
    {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

[{"inputs":[{"internalType":"contract MinimalForwarder","name":"forwarder","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"fileId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"fileOwner","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"}],"name":"AccessGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"fileId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"fileOwner","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"}],"name":"AccessRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"fileId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"fileOwner","type":"address"}],"name":"FileRegistered","type":"event"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"files","outputs":[{"internalType":"address","name":"fileOwner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"fileId","type":"bytes32"},{"internalType":"address","name":"recipient","type":"address"}],"name":"grantAccess","outputs":[{"internalType":"bool","name":"accessGranted","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"fileId","type":"bytes32"},{"internalType":"address","name":"recipient","type":"address"}],"name":"hasAccess","outputs":[{"internalType":"bool","name":"_hasAccess","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"CID","type":"string"}],"name":"hashHelper","outputs":[{"internalType":"bytes32","name":"hash","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"isTrustedForwarder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"fileId","type":"bytes32"}],"name":"registerFile","outputs":[{"internalType":"bool","name":"fileRegistered","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"fileId","type":"bytes32"},{"internalType":"address","name":"recipient","type":"address"}],"name":"revokeAccess","outputs":[{"internalType":"bool","name":"accessRevoked","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000d9ca9e7a6630b61de80fa70ffa8557d212a40fa

-----Decoded View---------------
Arg [0] : forwarder (address): 0x0d9ca9e7a6630b61de80fa70ffa8557d212a40fa

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000d9ca9e7a6630b61de80fa70ffa8557d212a40fa

241:3173:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3282:130;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2092:447;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;529:172:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3010:181:4;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2545:459;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;471:37;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1652:434;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3282:130;3342:12;3400:3;3383:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;3373:32;;;;;;3366:39;;3282:130;;;:::o;2092:447::-;2210:18;2185:6;1102:12;:10;:12::i;:::-;1075:39;;:5;:13;1081:6;1075:13;;;;;;;;;;;:23;;;;;;;;;;;;:39;;;1054:138;;;;;;;;;;;;:::i;:::-;;;;;;;;;2266:5:::1;:13:::0;2272:6:::1;2266:13;;;;;;;;;;;:26;;:37;2293:9;2266:37;;;;;;;;;;;;;;;;;;;;;;;;;2265:38;2244:141;;;;;;;;;;;;:::i;:::-;;;;;;;;;2435:4;2395:5;:13:::0;2401:6:::1;2395:13;;;;;;;;;;;:26;;:37;2422:9;2395:37;;;;;;;;;;;;;;;;:44;;;;;;;;;;;;;;;;;;2501:9;2454:57;;2476:5;:13:::0;2482:6:::1;2476:13;;;;;;;;;;;:23;;;;;;;;;;;;2454:57;;;2468:6;2454:57;;;;;;:::i;:::-;;;;;;;;2528:4;2521:11;;2092:447:::0;;;;;:::o;529:172:3:-;637:4;677:17;664:30;;:9;:30;;;657:37;;529:172;;;:::o;3010:181:4:-;3109:15;3147:5;:13;3153:6;3147:13;;;;;;;;;;;:26;;:37;3174:9;3147:37;;;;;;;;;;;;;;;;;;;;;;;;;3140:44;;3010:181;;;;:::o;2545:459::-;2664:18;2639:6;1102:12;:10;:12::i;:::-;1075:39;;:5;:13;1081:6;1075:13;;;;;;;;;;;:23;;;;;;;;;;;;:39;;;1054:138;;;;;;;;;;;;:::i;:::-;;;;;;;;;2719:5:::1;:13:::0;2725:6:::1;2719:13;;;;;;;;;;;:26;;:37;2746:9;2719:37;;;;;;;;;;;;;;;;;;;;;;;;;2698:151;;;;;;;;;;;;:::i;:::-;;;;;;;;;2899:5;2859::::0;:13:::1;2865:6;2859:13;;;;;;;;;;;:26;;:37;2886:9;2859:37;;;;;;;;;;;;;;;;:45;;;;;;;;;;;;;;;;;;2966:9;2919:57;;2941:5;:13:::0;2947:6:::1;2941:13;;;;;;;;;;;:23;;;;;;;;;;;;2919:57;;;2933:6;2919:57;;;;;;:::i;:::-;;;;;;;;2993:4;2986:11;;2545:459:::0;;;;;:::o;471:37::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1652:434::-;1706:19;1793:1;1758:37;;:5;:13;1764:6;1758:13;;;;;;;;;;;:23;;;;;;;;;;;;:37;;;1737:132;;;;;;;;;;;;:::i;:::-;;;;;;;;;1879:17;1899:12;:10;:12::i;:::-;1879:32;;1947:9;1921:5;:13;1927:6;1921:13;;;;;;;;;;;:23;;;:35;;;;;;;;;;;;;;;;;;2006:4;1966:5;:13;1972:6;1966:13;;;;;;;;;;;:26;;:37;1993:9;1966:37;;;;;;;;;;;;;;;;:44;;;;;;;;;;;;;;;;;;2048:9;2025:33;;;2040:6;2025:33;;;;;;:::i;:::-;;;;;;;;2075:4;2068:11;;;1652:434;;;:::o;707:445:3:-;809:14;843:30;862:10;843:18;:30::i;:::-;839:307;;;1061:2;1045:14;1041:23;1028:37;1024:2;1020:46;1010:56;;839:307;;;1117:18;:16;:18::i;:::-;1110:25;;;;839:307;707:445;;:::o;640:96:0:-;693:7;719:10;712:17;;640:96;:::o;7:75:7:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:117;443:1;440;433:12;457:117;566:1;563;556:12;580:102;621:6;672:2;668:7;663:2;656:5;652:14;648:28;638:38;;580:102;;;:::o;688:180::-;736:77;733:1;726:88;833:4;830:1;823:15;857:4;854:1;847:15;874:281;957:27;979:4;957:27;:::i;:::-;949:6;945:40;1087:6;1075:10;1072:22;1051:18;1039:10;1036:34;1033:62;1030:88;;;1098:18;;:::i;:::-;1030:88;1138:10;1134:2;1127:22;917:238;874:281;;:::o;1161:129::-;1195:6;1222:20;;:::i;:::-;1212:30;;1251:33;1279:4;1271:6;1251:33;:::i;:::-;1161:129;;;:::o;1296:308::-;1358:4;1448:18;1440:6;1437:30;1434:56;;;1470:18;;:::i;:::-;1434:56;1508:29;1530:6;1508:29;:::i;:::-;1500:37;;1592:4;1586;1582:15;1574:23;;1296:308;;;:::o;1610:154::-;1694:6;1689:3;1684;1671:30;1756:1;1747:6;1742:3;1738:16;1731:27;1610:154;;;:::o;1770:412::-;1848:5;1873:66;1889:49;1931:6;1889:49;:::i;:::-;1873:66;:::i;:::-;1864:75;;1962:6;1955:5;1948:21;2000:4;1993:5;1989:16;2038:3;2029:6;2024:3;2020:16;2017:25;2014:112;;;2045:79;;:::i;:::-;2014:112;2135:41;2169:6;2164:3;2159;2135:41;:::i;:::-;1854:328;1770:412;;;;;:::o;2202:340::-;2258:5;2307:3;2300:4;2292:6;2288:17;2284:27;2274:122;;2315:79;;:::i;:::-;2274:122;2432:6;2419:20;2457:79;2532:3;2524:6;2517:4;2509:6;2505:17;2457:79;:::i;:::-;2448:88;;2264:278;2202:340;;;;:::o;2548:509::-;2617:6;2666:2;2654:9;2645:7;2641:23;2637:32;2634:119;;;2672:79;;:::i;:::-;2634:119;2820:1;2809:9;2805:17;2792:31;2850:18;2842:6;2839:30;2836:117;;;2872:79;;:::i;:::-;2836:117;2977:63;3032:7;3023:6;3012:9;3008:22;2977:63;:::i;:::-;2967:73;;2763:287;2548:509;;;;:::o;3063:77::-;3100:7;3129:5;3118:16;;3063:77;;;:::o;3146:118::-;3233:24;3251:5;3233:24;:::i;:::-;3228:3;3221:37;3146:118;;:::o;3270:222::-;3363:4;3401:2;3390:9;3386:18;3378:26;;3414:71;3482:1;3471:9;3467:17;3458:6;3414:71;:::i;:::-;3270:222;;;;:::o;3498:122::-;3571:24;3589:5;3571:24;:::i;:::-;3564:5;3561:35;3551:63;;3610:1;3607;3600:12;3551:63;3498:122;:::o;3626:139::-;3672:5;3710:6;3697:20;3688:29;;3726:33;3753:5;3726:33;:::i;:::-;3626:139;;;;:::o;3771:126::-;3808:7;3848:42;3841:5;3837:54;3826:65;;3771:126;;;:::o;3903:96::-;3940:7;3969:24;3987:5;3969:24;:::i;:::-;3958:35;;3903:96;;;:::o;4005:122::-;4078:24;4096:5;4078:24;:::i;:::-;4071:5;4068:35;4058:63;;4117:1;4114;4107:12;4058:63;4005:122;:::o;4133:139::-;4179:5;4217:6;4204:20;4195:29;;4233:33;4260:5;4233:33;:::i;:::-;4133:139;;;;:::o;4278:474::-;4346:6;4354;4403:2;4391:9;4382:7;4378:23;4374:32;4371:119;;;4409:79;;:::i;:::-;4371:119;4529:1;4554:53;4599:7;4590:6;4579:9;4575:22;4554:53;:::i;:::-;4544:63;;4500:117;4656:2;4682:53;4727:7;4718:6;4707:9;4703:22;4682:53;:::i;:::-;4672:63;;4627:118;4278:474;;;;;:::o;4758:90::-;4792:7;4835:5;4828:13;4821:21;4810:32;;4758:90;;;:::o;4854:109::-;4935:21;4950:5;4935:21;:::i;:::-;4930:3;4923:34;4854:109;;:::o;4969:210::-;5056:4;5094:2;5083:9;5079:18;5071:26;;5107:65;5169:1;5158:9;5154:17;5145:6;5107:65;:::i;:::-;4969:210;;;;:::o;5185:329::-;5244:6;5293:2;5281:9;5272:7;5268:23;5264:32;5261:119;;;5299:79;;:::i;:::-;5261:119;5419:1;5444:53;5489:7;5480:6;5469:9;5465:22;5444:53;:::i;:::-;5434:63;;5390:117;5185:329;;;;:::o;5520:::-;5579:6;5628:2;5616:9;5607:7;5603:23;5599:32;5596:119;;;5634:79;;:::i;:::-;5596:119;5754:1;5779:53;5824:7;5815:6;5804:9;5800:22;5779:53;:::i;:::-;5769:63;;5725:117;5520:329;;;;:::o;5855:118::-;5942:24;5960:5;5942:24;:::i;:::-;5937:3;5930:37;5855:118;;:::o;5979:222::-;6072:4;6110:2;6099:9;6095:18;6087:26;;6123:71;6191:1;6180:9;6176:17;6167:6;6123:71;:::i;:::-;5979:222;;;;:::o;6207:99::-;6259:6;6293:5;6287:12;6277:22;;6207:99;;;:::o;6312:148::-;6414:11;6451:3;6436:18;;6312:148;;;;:::o;6466:307::-;6534:1;6544:113;6558:6;6555:1;6552:13;6544:113;;;6643:1;6638:3;6634:11;6628:18;6624:1;6619:3;6615:11;6608:39;6580:2;6577:1;6573:10;6568:15;;6544:113;;;6675:6;6672:1;6669:13;6666:101;;;6755:1;6746:6;6741:3;6737:16;6730:27;6666:101;6515:258;6466:307;;;:::o;6779:377::-;6885:3;6913:39;6946:5;6913:39;:::i;:::-;6968:89;7050:6;7045:3;6968:89;:::i;:::-;6961:96;;7066:52;7111:6;7106:3;7099:4;7092:5;7088:16;7066:52;:::i;:::-;7143:6;7138:3;7134:16;7127:23;;6889:267;6779:377;;;;:::o;7162:275::-;7294:3;7316:95;7407:3;7398:6;7316:95;:::i;:::-;7309:102;;7428:3;7421:10;;7162:275;;;;:::o;7443:169::-;7527:11;7561:6;7556:3;7549:19;7601:4;7596:3;7592:14;7577:29;;7443:169;;;;:::o;7618:239::-;7758:34;7754:1;7746:6;7742:14;7735:58;7827:22;7822:2;7814:6;7810:15;7803:47;7618:239;:::o;7863:366::-;8005:3;8026:67;8090:2;8085:3;8026:67;:::i;:::-;8019:74;;8102:93;8191:3;8102:93;:::i;:::-;8220:2;8215:3;8211:12;8204:19;;7863:366;;;:::o;8235:419::-;8401:4;8439:2;8428:9;8424:18;8416:26;;8488:9;8482:4;8478:20;8474:1;8463:9;8459:17;8452:47;8516:131;8642:4;8516:131;:::i;:::-;8508:139;;8235:419;;;:::o;8660:243::-;8800:34;8796:1;8788:6;8784:14;8777:58;8869:26;8864:2;8856:6;8852:15;8845:51;8660:243;:::o;8909:366::-;9051:3;9072:67;9136:2;9131:3;9072:67;:::i;:::-;9065:74;;9148:93;9237:3;9148:93;:::i;:::-;9266:2;9261:3;9257:12;9250:19;;8909:366;;;:::o;9281:419::-;9447:4;9485:2;9474:9;9470:18;9462:26;;9534:9;9528:4;9524:20;9520:1;9509:9;9505:17;9498:47;9562:131;9688:4;9562:131;:::i;:::-;9554:139;;9281:419;;;:::o;9706:291::-;9846:34;9842:1;9834:6;9830:14;9823:58;9915:34;9910:2;9902:6;9898:15;9891:59;9984:5;9979:2;9971:6;9967:15;9960:30;9706:291;:::o;10003:366::-;10145:3;10166:67;10230:2;10225:3;10166:67;:::i;:::-;10159:74;;10242:93;10331:3;10242:93;:::i;:::-;10360:2;10355:3;10351:12;10344:19;;10003:366;;;:::o;10375:419::-;10541:4;10579:2;10568:9;10564:18;10556:26;;10628:9;10622:4;10618:20;10614:1;10603:9;10599:17;10592:47;10656:131;10782:4;10656:131;:::i;:::-;10648:139;;10375:419;;;:::o;10800:235::-;10940:34;10936:1;10928:6;10924:14;10917:58;11009:18;11004:2;10996:6;10992:15;10985:43;10800:235;:::o;11041:366::-;11183:3;11204:67;11268:2;11263:3;11204:67;:::i;:::-;11197:74;;11280:93;11369:3;11280:93;:::i;:::-;11398:2;11393:3;11389:12;11382:19;;11041:366;;;:::o;11413:419::-;11579:4;11617:2;11606:9;11602:18;11594:26;;11666:9;11660:4;11656:20;11652:1;11641:9;11637:17;11630:47;11694:131;11820:4;11694:131;:::i;:::-;11686:139;;11413:419;;;:::o

ipfs://e584491ea3ab6b6875e11b68e458bea73ecc617cdbf4b9dfde1341b1db6b77a0