Contract 0xcd1b4690f317f3108f34074620a59df86bab871d

// 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];
    }
}

// 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":"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:2952:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;:::-;;;;;;;;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;88:117:7:-;197:1;194;187:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:126::-;727:7;767:42;760:5;756:54;745:65;;690:126;;;:::o;822:96::-;859:7;888:24;906:5;888:24;:::i;:::-;877:35;;822:96;;;:::o;924:122::-;997:24;1015:5;997:24;:::i;:::-;990:5;987:35;977:63;;1036:1;1033;1026:12;977:63;924:122;:::o;1052:139::-;1098:5;1136:6;1123:20;1114:29;;1152:33;1179:5;1152:33;:::i;:::-;1052:139;;;;:::o;1197:474::-;1265:6;1273;1322:2;1310:9;1301:7;1297:23;1293:32;1290:119;;;1328:79;;:::i;:::-;1290:119;1448:1;1473:53;1518:7;1509:6;1498:9;1494:22;1473:53;:::i;:::-;1463:63;;1419:117;1575:2;1601:53;1646:7;1637:6;1626:9;1622:22;1601:53;:::i;:::-;1591:63;;1546:118;1197:474;;;;;:::o;1677:90::-;1711:7;1754:5;1747:13;1740:21;1729:32;;1677:90;;;:::o;1773:109::-;1854:21;1869:5;1854:21;:::i;:::-;1849:3;1842:34;1773:109;;:::o;1888:210::-;1975:4;2013:2;2002:9;1998:18;1990:26;;2026:65;2088:1;2077:9;2073:17;2064:6;2026:65;:::i;:::-;1888:210;;;;:::o;2104:329::-;2163:6;2212:2;2200:9;2191:7;2187:23;2183:32;2180:119;;;2218:79;;:::i;:::-;2180:119;2338:1;2363:53;2408:7;2399:6;2388:9;2384:22;2363:53;:::i;:::-;2353:63;;2309:117;2104:329;;;;:::o;2439:::-;2498:6;2547:2;2535:9;2526:7;2522:23;2518:32;2515:119;;;2553:79;;:::i;:::-;2515:119;2673:1;2698:53;2743:7;2734:6;2723:9;2719:22;2698:53;:::i;:::-;2688:63;;2644:117;2439:329;;;;:::o;2774:118::-;2861:24;2879:5;2861:24;:::i;:::-;2856:3;2849:37;2774:118;;:::o;2898:222::-;2991:4;3029:2;3018:9;3014:18;3006:26;;3042:71;3110:1;3099:9;3095:17;3086:6;3042:71;:::i;:::-;2898:222;;;;:::o;3126:169::-;3210:11;3244:6;3239:3;3232:19;3284:4;3279:3;3275:14;3260:29;;3126:169;;;;:::o;3301:239::-;3441:34;3437:1;3429:6;3425:14;3418:58;3510:22;3505:2;3497:6;3493:15;3486:47;3301:239;:::o;3546:366::-;3688:3;3709:67;3773:2;3768:3;3709:67;:::i;:::-;3702:74;;3785:93;3874:3;3785:93;:::i;:::-;3903:2;3898:3;3894:12;3887:19;;3546:366;;;:::o;3918:419::-;4084:4;4122:2;4111:9;4107:18;4099:26;;4171:9;4165:4;4161:20;4157:1;4146:9;4142:17;4135:47;4199:131;4325:4;4199:131;:::i;:::-;4191:139;;3918:419;;;:::o;4343:243::-;4483:34;4479:1;4471:6;4467:14;4460:58;4552:26;4547:2;4539:6;4535:15;4528:51;4343:243;:::o;4592:366::-;4734:3;4755:67;4819:2;4814:3;4755:67;:::i;:::-;4748:74;;4831:93;4920:3;4831:93;:::i;:::-;4949:2;4944:3;4940:12;4933:19;;4592:366;;;:::o;4964:419::-;5130:4;5168:2;5157:9;5153:18;5145:26;;5217:9;5211:4;5207:20;5203:1;5192:9;5188:17;5181:47;5245:131;5371:4;5245:131;:::i;:::-;5237:139;;4964:419;;;:::o;5389:118::-;5476:24;5494:5;5476:24;:::i;:::-;5471:3;5464:37;5389:118;;:::o;5513:222::-;5606:4;5644:2;5633:9;5629:18;5621:26;;5657:71;5725:1;5714:9;5710:17;5701:6;5657:71;:::i;:::-;5513:222;;;;:::o;5741:291::-;5881:34;5877:1;5869:6;5865:14;5858:58;5950:34;5945:2;5937:6;5933:15;5926:59;6019:5;6014:2;6006:6;6002:15;5995:30;5741:291;:::o;6038:366::-;6180:3;6201:67;6265:2;6260:3;6201:67;:::i;:::-;6194:74;;6277:93;6366:3;6277:93;:::i;:::-;6395:2;6390:3;6386:12;6379:19;;6038:366;;;:::o;6410:419::-;6576:4;6614:2;6603:9;6599:18;6591:26;;6663:9;6657:4;6653:20;6649:1;6638:9;6634:17;6627:47;6691:131;6817:4;6691:131;:::i;:::-;6683:139;;6410:419;;;:::o;6835:235::-;6975:34;6971:1;6963:6;6959:14;6952:58;7044:18;7039:2;7031:6;7027:15;7020:43;6835:235;:::o;7076:366::-;7218:3;7239:67;7303:2;7298:3;7239:67;:::i;:::-;7232:74;;7315:93;7404:3;7315:93;:::i;:::-;7433:2;7428:3;7424:12;7417:19;;7076:366;;;:::o;7448:419::-;7614:4;7652:2;7641:9;7637:18;7629:26;;7701:9;7695:4;7691:20;7687:1;7676:9;7672:17;7665:47;7729:131;7855:4;7729:131;:::i;:::-;7721:139;;7448:419;;;:::o

ipfs://823fa2352b721418d7edc096425ce5602e8c1a72bf233c1c0b2864c972aa998f